4.面向对象高级

面向对象高级

一、面向对象的三大特征之三：多态

1.多态概述

• 多态是在继承/实现情况下的一种现象，表现为：对象多态、行为多态

1.1 多态的前提

• 有继承/实现关系；
• 存在父类引用子类对象；
• 存在方法重写

1.2 多态的注意事项

• 多态是对象、行为的多态，Java中的属性(成员变量)不谈多态
• 对成员方法来说：编译看左边，运行看右边
• 多态下不能使用子类的独有功能

1.3 使用多态的好处和弊端

1. 好处：

• 在多态形式下，右边对象是解耦合的，更便于扩展和维护
• 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利

2. 弊端：

• 无法使用子类特有的方法

解决：强制类型转换

2.类型转换

可以把对象转换成其真正的类型，从而解决了多态下不能调用子类独有方法的问题

2.1 类型转换分类

• 自动类型转换：父类 变量名 = new 子类();

  People s1 = new Teacher();
  

• 强制类型转换：子类 变量名 = (子类) 父类变量

  People p1 = new Teacher();
            
  Teacher t1 = (Teacher) p1;
  

2.2 强制类型转换注意事项

• 存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。

• 运行时，如果发现对象的真实类型与强转后的类型不同，就会报==类型转换异常（ClassCastException)==的错误出来

强转前，Java建议：

• 使用instanceof关键字，判断当前对象的真实类型，再进行强转

  if (p instanceof Student){ }
  

二、final关键字

1.final概述

• final 关键字是最终的意思，可以修饰（类、方法、变量[局部变量]）

• 修饰类：该类被称为最终类，特点是不能被继承了。

• 修饰方法：该方法被称为最终方法，特点是不能被重写了。

• 修饰变量：该变量只能被赋值一次。

2.final修饰变量注意点

• final修饰基本类型的变量，变量存储的数据不能被改变。

• final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

3.final使用场景:常量

使用了 final static 修饰的成员变量就称为常量

3.1 作用

通常用于记录系统中的配置信息

注意！

常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来

3.2 使用常量记录系统配置信息的优势、执行原理

• 代码可读性更好，可维护性也更好。

• 程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

public final static SCHOOL_NAME	 = "传智教育"

三、抽象类abstract

1.abstract概述

• 在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法

• abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法

  抽象类中的抽象方法：必须abstract修饰，只有方法签名，不能有方法体

public abstract class A {
    
    // 抽象方法：必须abstract修饰，只有方法签名，不能有方法体   
    public abstract void test();
}

2.抽象类注意事项

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

• 类该有的成员（成员变量、方法、构造器）抽象类都可以有。

• 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。【不能实例化】

• 一个类继承抽象类，必须重写父类抽象类的全部抽象方法，否则这个类也必须定义成抽象类。【或者将该类定义为abstract类】

• abstractb不能和final、private、static联合使用，只能单独使用abstract或者联合public abstract使用。

抽象类的继承：

• 子类是抽象类
• 子类重写父类所有的抽象方法

3.模板方法

• 解决方法中存在重复代码的问题

• 写法：

  1. 将功能的组成或者步骤定义在父类中
  2. 对于每个小步骤，如果父类中能明确则直接定义，如果父类中明确不了，在父类中定义成抽象方法，要求子类重写
  3. 子类只需要重写抽象方法即可

• 案例：制造汽车：白车、黑车

• 步骤：

​ 1.定义抽象类 编写制造汽车的模板方法(color重写：abstract color(){ })

​ 2.白车、黑车类继承上个抽象类，重写color方法

​ 3.在测试类中创建白车、黑车对象，分别调用 抽象类中的 模板方法——完成汽车的制造

//抽象模板方法类
public abstract class AbstractFactoryCar {
    public void createFrame(){
        System.out.println("制造汽车框架");
    }
    public void installComponent(){
        System.out.println("安装零件");
    }
    //上色
    public abstract void coloring();
    public void over(){
        System.out.println("安装完毕！");
    }
    //制造汽车
    public void builderCar(){
        createFrame();
        installComponent();
        coloring();
        over();
    }
}

//白车、黑车类【重写coloring方法】
public class WhiteCar extends AbstractFactoryCar{
    @Override
    public void coloring() {
        System.out.println("给汽车喷上白色的漆");
    }
}
public class BlackCar extends AbstractFactoryCar{
    @Override
    public void coloring() {
        System.out.println("给汽车喷上黑色的漆");
    }
}

//测试类制造汽车
public class Demo {
    public static void main(String[] args) {
        WhiteCar c1 = new WhiteCar();
        c1.builderCar();

        System.out.println("===========");

        BlackCar c2 = new BlackCar();
        c2.builderCar();
    }
}

四、接口interface

1.接口概述

• Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口【规则】。

public interface 接口名 {
    
       // 成员变量（常量）
    	接口只能定义常量，前面不加修饰符，系统会默认加上 public static final 
      String name = "sa"; <==> public static final String name = "sa";
    
       // 成员方法（抽象方法）
        接口类中定义方法时，默认会添加 public abstract修饰
      void show();  <==> public abstract void show();
} 

2.接口注意事项

• 接口不能创建对象；接口是用来被类实现（implements）的，实现接口的类称为实现类

  修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {
      
  }
  

• 一个类可以实现多个接口（接口可以理解成干爹），实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类

• 接口中的方法全都是抽象方法，没有方法体

3.接口的好处

• 弥补了类单继承的不足，一个类同时可以实现多个接口
• 让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现

JDK 8开始，接口新增了三种形式的方法：默认、私有、静态

public interface A{    
    /**     
    * 1、默认方法（实例方法）：使用用default修饰，默认会被加上public修饰。     
    * 注意：只能使用接口的实现类对象调用     
    */    
    default void test1(){...}   
    /**     
    * 2、私有方法：必须用private修饰(JDK 9开始才支持)     
    */    
    private void test2(){ ...}
    /**     
    * 3、类方法（静态方法）：使用static修饰，默认会被加上public修饰。     
    * 注意：只能用接口名来调用。     
    */    
    static void test3(){...}
}

4.接口的多继承

• 一个接口可以继承多个接口
• 作用：便于实现类去实现

注意事项：

1. 一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。

2. 一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。

3. 一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。

4. 一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。