1.理解接口的作用 及写法,可以熟练的定义接口 2.理解多态产生的条件,理解多态的好处,理解多态的应用场景 3. 对扩展开放 对修改关闭的遵循规范

1.接口

1.1接口的概述(理解)

  • 接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用。

  • Java中接口存在的两个意义

    1. 用来定义规范

    2. 用来做功能的拓展

1.2 接口的定义及使用

  • 接口用关键字interface修饰

    1
    public interface 接口名 {} 
  • 类实现接口用implements表示

    1
    public class 类名 implements 接口名 {}

1.3接口的特点(记忆)

  • 接口不能实例化

    ​ 我们可以创建接口的实现类对象使用

  • 接口的子类(必须把所有没有声明的方法声明清楚)

    ​ 要么重写接口中的所有抽象方法

    ​ 要么子类也是抽象类

1.4接口的成员特点(记忆)

  • 成员特点

    • 成员变量

      ​ 只能是常量
      ​ 默认修饰符:public static final

    • 构造方法

      ​ 接口与抽象类完全是两个 体系东西

      ​ 没有,因为接口主要是扩展功能的,而没有具体存在

    • 成员方法

      ​ 只能是抽象方法

      ​ 默认修饰符:public abstract

      ​ 关于接口中的方法,JDK8和JDK9中有一些新特性,后面再讲解

  • 代码演示

    • 接口
    1
    2
    3
    4
    5
    public interface Inter {
    public static final int NUM = 10;

    public abstract void show();
    }
    • 实现类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class InterImpl implements Inter{

    public void method(){
    // NUM = 20;
    System.out.println(NUM);
    }

    public void show(){

    }
    }
    • 测试类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class TestInterface {
    /*
    成员变量: 只能是常量 系统会默认加入三个关键字
    public static final
    构造方法: 没有
    成员方法: 只能是抽象方法, 系统会默认加入两个关键字
    public abstract
    */
    public static void main(String[] args) {
    System.out.println(Inter.NUM);
    }

    }

1.5接口中默认方法【应用】

  • 格式

    public default 返回值类型 方法名(参数列表) { }

  • 作用

    解决接口升级的问题

  • 范例

    1
    2
    public default void show3() { 
    }
  • 注意事项

    • 默认方法不是抽象方法,所以不强制被重写。但是可以被重写,重写的时候去掉default关键字
    • public可以省略,default不能省略
    • 如果实现了多个接口,多个接口中存在相同的方法声明,子类就必须对该方法进行重写

1.6接口中静态方法【应用】

  • 格式

    public static 返回值类型 方法名(参数列表) { }

  • 范例

    1
    2
    public static void show() {
    }
  • 注意事项

    • 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用
    • public可以省略,static不能省略

1.7接口中私有方法【应用】

  • 私有方法产生原因

    Java 9中新增了带方法体的私有方法,这其实在Java 8中就埋下了伏笔:Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题:当两个默认方法或者静态方法中包含一段相同的代码实现时,程序必然考虑将这段实现代码抽取成一个共性方法,而这个共性方法是不需要让别人使用的,因此用私有给隐藏起来,这就是Java 9增加私有方法的必然性

  • 定义格式

    • 格式1

      private 返回值类型 方法名(参数列表) { }

    • 范例1

      1
      2
      private void show() {  
      }
    • 格式2

      private static 返回值类型 方法名(参数列表) { }

    • 范例2

      1
      2
      private static void method() {  
      }
  • 注意事项

    • 默认方法可以调用私有的静态方法和非静态方法
    • 静态方法只能调用私有的静态方法

1.8类和接口的关系(记忆)

  • 类与类的关系

    ​ 继承关系,只能单继承,但是可以多层继承

  • 类与接口的关系

    ​ 实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口

    ​ 如果与父类有相同的 方法需要继承或实现 优先使用父类的方法

    ​ 如果没有父类, 并且多实现了, 有相同的默认方法, 在实现类中必须手动重写

  • 接口与接口的关系

    ​ 继承关系,可以单继承,也可以多继承

    ​ 抽象方法在实现类中必须全部重写

2.多态

2.1多态的概述(记忆)

  • 什么是多态

    ​ 同一个对象,在不同时刻表现出来的不同形态

  • 多态的前提

    • 要有继承或实现关系
    • 要有方法的重写
    • 要有父类引用指向子类对象(堆内存子类对象 , 栈内存 父类变量引用)
  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    class Animal {
    public void eat(){
    System.out.println("动物吃饭");
    }
    }

    class Cat extends Animal {
    @Override
    public void eat() {
    System.out.println("猫吃鱼");
    }
    }

    public class Test1Polymorphic {
    /*
    多态的前提:

    1. 要有(继承 \ 实现)关系
    2. 要有方法重写
    3. 要有父类引用, 指向子类对象
    */
    public static void main(String[] args) {
    // 当前事物, 是一只猫
    Cat c = new Cat();
    // 当前事物, 是一只动物
    Animal a = new Cat();
    a.eat();

    }
    }

2.2多态中的成员访问特点(记忆)

  • 成员访问特点

    • 成员变量

      ​ 编译看父类,运行看父类

    • 成员方法(因为重写了父类的方法)

      ​ 编译看父类,运行看子类

    • 构造方法

      ​ 使用子类的构造方法, 内部调用super()// 先父类 再子类

    • 静态方法

      编译看父类 运行看父类

  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    class Fu {
    int num = 10;

    public void method(){
    System.out.println("Fu.. method");
    }
    }

    class Zi extends Fu {
    int num = 20;

    public void method(){
    System.out.println("Zi.. method");
    }
    }

    public class Test2Polymorpic {
    /*
    多态的成员访问特点:

    成员变量: 编译看左边 (父类), 运行看左边 (父类)

    成员方法: 编译看左边 (父类), 运行看右边 (子类)
    */
    public static void main(String[] args) {
    Fu f = new Zi();
    System.out.println(f.num);
    f.method();
    }
    }

2.3多态的好处和弊端(记忆)

  • 好处

    ​ 提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作

  • 弊端

    ​ 不能使用子类的特有成员

2.4多态中的转型(应用)

  • 向上转型(自动类型转换)

    ​ 父类引用指向子类对象就是向上转型

  • 向下转型(强制类型转换)

    ​ 格式:子类型 对象名 = (子类型)父类引用;

  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    class Fu {
    public void show(){
    System.out.println("Fu..show...");
    }
    }

    class Zi extends Fu {
    @Override
    public void show() {
    System.out.println("Zi..show...");
    }

    public void method(){
    System.out.println("我是子类特有的方法, method");
    }
    }

    public class Test3Polymorpic {
    public static void main(String[] args) {
    // 1. 向上转型 : 父类引用指向子类对象
    Fu f = new Zi();
    f.show();
    // 多态的弊端: 不能调用子类特有的成员
    // f.method();

    // A: 直接创建子类对象
    // B: 向下转型

    // 2. 向下转型 : 从父类类型, 转换回子类类型
    Zi z = (Zi) f;
    z.method();
    }
    }

2.5多态中转型存在的风险和解决方案 (应用)

  • 风险

    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

  • 解决方案

    • 关键字

      instanceof

    • 使用格式

      变量名 instanceof 类型

      通俗的理解:判断关键字左边的变量,是否是右边的类型,返回boolean类型结果

  • 代码演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    abstract class Animal {
    public abstract void eat();
    }

    class Dog extends Animal {
    public void eat() {
    System.out.println("狗吃肉");
    }

    public void watchHome(){
    System.out.println("看家");
    }
    }

    class Cat extends Animal {
    public void eat() {
    System.out.println("猫吃鱼");
    }
    }

    public class Test4Polymorpic {
    public static void main(String[] args) {
    useAnimal(new Dog());
    useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){ // Animal a = new Dog();
    // Animal a = new Cat();
    a.eat();
    //a.watchHome();

    // Dog dog = (Dog) a;
    // dog.watchHome(); // ClassCastException 类型转换异常

    // 判断a变量记录的类型, 是否是Dog
    if(a instanceof Dog){
    Dog dog = (Dog) a;
    dog.watchHome();
    }
    }

    }

3.概念总结

面向对象三大特征

封装:将数据封装到实体类中

继承:子类继承父类的特点

多态:父类调用子类的方法

接口:定义规则

分类分包思想

controller:与用户交互

service:处理业务逻辑

dao:操作数据

domain:封装数据