Java基础 (四) | 封装、继承、多态

Scroll Down

前言

本文章主要学习Java中的重要概念封装、继承和多态,通过案例的方式进行讲解,让你对继承和多态在企业中的应用更加了解。

一、大纲

  • 封装
  • 继承
  • 多态
  • 接口和抽象类

二、封装

2.1、什么是封装

​ 封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节

2.2、特点

  1. 对成员变量实行更准确的控制。
  2. 封装可以隐藏内部程序实现的细节。
  3. 良好的封装能够减少代码之间的耦合度。
  4. 外部成员无法修改已封装好的程序代码。
  5. 方便数据检查,有利于保护对象信息的完整性,同时也提高程序的安全性。
  6. 便于修改,体高代码的可维护性。

2.3、封装的使用

  • 使用private修饰符,表示最小的访问权限。
  • 对成员变量的访问,统一提供setXXX,getXXX方法。
而对于这样一个实体对象,外部程序只有赋值和获取值的权限,是无法对内部进行修改,因此我们还可以在内部进行一些逻辑上的判断等,来完成我们业务上的需要。

三、继承

3.1、什么是继承

​ 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
当然,如果在父类中拥有私有属性(private修饰),则子类是不能被继承的。

3.2、继承的特点

继承的特点:

  • 提高代码复用性。
  • 父类的属性方法可以用于子类。
  • 可以轻松的定义子类。
  • 使设计应用程序变得简单。

关于继承的注意事项

  • 只支持单继承,即一个子类只允许有一个父类,但是可以实现多级继承,及子类拥有唯一的父类,而父类还可以再继承。
  • 子类可以拥有父类的属性和方法。
  • 子类可以拥有自己的属性和方法。
  • 子类可以重写覆盖父类的方法。

3.3、继承的使用

在父子类关系继承中,如果成员变量重名,则创建子类对象时,访问有两种方式。

  • a、直接通过子类对象访问成员变量(等号左边是谁,就优先使用谁,如果没有就向上找。)
  • b、间接通过成员方法访问成员变量(该方法属于谁,谁就优先使用,如果没有就向上找。

同理:
​ 成员方法也是一样的,创建的对象是谁,就优先使用谁,如果没有则直接向上找。

注意事项:
​ 无论是成员变量还是成员方法,如果没有都是向上父类中查找,绝对不会向下查找子类的。

在继承关系中,关于成员变量的使用:
​ * 局部成员变量:直接使用
​ * 本类成员变量:this.成员变量
​ * 父类成员变量:super.父类成员变量

int numZi = 10;
 public void method() {
   int numMethod = 20;
   System.out.println(numMethod);  // 访问局部变量
   System.out.println(this.numZi); // 访问本类成员变量
   System.out.println(super.numFu); // 访问本类成员变量
}

3.4、重写,重载

重写(override)
​ 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!

class Animal{
   public void move(){
      System.out.println("动物行走!");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}

重写的规则:
​ 1、参数列表必须与被重写方法相同
​ 2、访问权限不能比父类中被重写的方法的访问权限更低(public>protected>(default)>private)。
​ 3、父类成员的方法只能被它的子类重写。
​ 4、被final修饰的方法不能被重写。
​ 5、构造方法不能
重载(overload)
​ 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

​ 最常用的地方就是构造器的重载。
重载规则:
​ 1、被重载的方法必须改变参数列表(参数个数或者类型不一样)。
​ 2、被重载的方法可以改变返回类型。
​ 3、被重载的方法可以改变访问修饰符。

3.5、this,super,final关键字

super()关键字的用法

  • 子类的成员方法中,访问父类的成员变量。
  • 子类的成员方法中,访问父类的成员方法。
  • 子类的构造方法中,访问父类的构造方法。

this关键字用法

  • 本类成员方法中,访问本类的成员变量。
  • 本类成员方法中,访问本类的另一个成员方法。
  • 本类的构造方法中,访问本类的另一个构造方法。

final关键字
final修饰不能被继承,不能被修改

注意

  • this关键字同super一样,必须在构造方法的第一个语句,且是唯一的。
  • this与super不能同时存在。

3.6、构造器

​继承关系中,父子类构造方法的访问特点:

  • 在子类构造方法中有一个默认隐含的super();调用,因此一定是先调用父类构造方法,再调用子类构造方法。
  • 子类构造可以通过super();调用父类的重载构造。(重载)
  • super();的父类调用构造方法,必须在子类构造中的第一行,就是第一个;号结束的元素,并且只能调用一次。

3.7、关于继承的注意事项:

​ 1. Java语言是单继承的,一个子类只能有唯一一个父类
​ 2. Java语言可以是多级继承,一个子类有一个父类,一个父类还可以有一个父类。
​ 3. 一个子类只有一个父类,但是一个父类可以有多个子类。
165530120190905083148379927405540.png

四、多态

4.1、什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。

4.2、多态的特点

  1. 消除类型之间的耦合关系,实现低耦合。
  2. 灵活性。
  3. 可扩充性。
  4. 可替换性。

4.3、多态的体现形式

  • 继承
  • 父类引用指向子类
  • 重写

4.4、向上转型

格式:父类名称 对象名 = new 子类名称(); 
含义:右侧创建一个子类对象,把它当作父类来使用。
注意:向上转型一定是安全的。
缺点:一旦向上转型,子类中原本特有的方法就不能再被调用了。	

五、接口和抽象类

接口可以看做特殊的抽象类,只是所有的方法都是抽象方法(没有实现的方法),接口的方法都是默认public abstract的

5.1、区别

  • 接口关键字interface,抽象类是abstract
  • 接口支持多继承,抽象类一个子类继承一个抽象类,并且也要定义抽象类和实现
  • 抽象类可以包含属性、方法、构造方法,但是构造方法不能用于实例化,主要用途是被子类调用。
  • 都不能被实例化
  • 都可以被继承

5.2、什么是抽象类

  • abstract 关键字声明
  • 不实例化
  • 抽象类可以包含抽象方法和普通方法
  • 抽象方法是没有具体实现的方法
  • 继承关系中,之类必须重写父类的抽象方法
    实例
public class Methon {

    /**
     * 抽象类使用 abstract 声明
     * 不能被实例话
     */
    static abstract class Father {
        // 方法使用abstract声明,之类继承时候必须重写
        abstract void absMe();

        static void b() {
            System.out.println("普通方法");
        }
    }

    static class Child extends Father {

        @Override
        void absMe() {
            System.out.println("抽象类实现");
        }
    }

    public static void main(String[] args) {
        // 抽象类使用 abstract 声明 不能被实例话
//        Father child = new Father();

        Child child = new Child();
        child.absMe();

        Father.b();
    }
    
}

银行柜台案例

public class Bank {

    static abstract class Father {
        abstract String deposit(String money);
    }

    static class CaseDeskChild extends Father {

        @Override
        String deposit(String money) {
            System.out.println("柜台存款:" + money);
            return "柜台小票";
        }
    }

    static class AtmChild extends Father {

        @Override
        String deposit(String money) {
            System.out.println("ATM存款:" + money);
            return "ATM小票";
        }
    }

    public static void main(String[] args) {
        Father deskChild = new Bank.CaseDeskChild();
        Father atmChild = new Bank.AtmChild();

        deskChild.deposit("100");
        atmChild.deposit("100");

    }
}

5.3、什么是接口

  • 使用interface声明
  • 通常I开头,如:IDataType
  • 变量默认修饰: public static final 修饰
  • 方法默认修饰: public abstract
  • jdk7- 版本,接口只准许抽象方法
    作用
    接口可以继承另一个接口【单继承机制】
    一个类型可以实现多个接口【多实现机制】
  • jdk8- 版本,静态方法
    作用
    提供所有实现类一个公共的方法,访问公共数据
    接口中静态方法主要被接口名称调用
    静态方法:不能被实现类继承,不能被子接口继承
  • jdk8- 版本,默认方法
    作用
    提供所有实现类一个特殊方法,提供了默认处理方式
    可以被子接口继承,可以被实现类继承和重写
    只能通过实例话对象进行调用

5.4、接口当中的常量的用法:

  • 接口当中定义的常量:可以省略public static final。
  • 接口当中定义的常量:必须进行赋值。
    ​* 接口当中定义的常量:常量的名称要全部大写,多个名称之间使用下划线进行分割。

5.5、接口的注意事项:

  • 接口是没有静态代码块或者构造方法
  • 一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。
  • 如果实现类没有覆盖重写接口中所有的抽象方法,那么实现类就必须是一个抽象类
  • 如果实现类中实现多个接口,存在重复的抽象方法,那么只需要覆盖重写一次即可。
  • 在Java中,如果实现类的直接继承父类与实现接口发生冲突时,父类优先级高于接口。

5.6、接口之间的关系:

  • 多个接口之间是继承关系。
  • 多个父接口当中默认方法如果重复,那么子接口必须进行默认方法的覆盖重写。

接口拓展

问题:
​ 现在接口中需要抽取一个公有的方法,用来解决默认方法中代码重复的问题。
​ 但是这个共有的方法不能让实现类实现,所以应该设置为私有化。

在JDK8之后:
​ 1,default修饰,接口里允许定义默认的方法,但默认方法也可以覆盖重写。
​ 2,接口里允许定义静态方法。

在JDK9之后:
​ 1,普通私有方法,解决多个默认方法之间代码重复的问题。
​ 2,静态私有化,解决多个静态方法之间代码重复问题。
​ 接口的注意事项:
​ 1,不能通过接口的实现类对象去调用接口中的静态方法。
​ 正确语法:接口名称调用静态方法。