【day12】面向对象编程进阶（接口与多态）

【day11】回顾

在深入本模块之前，让我们回顾一下【day11】中的关键内容：

1. 继承：子类继承父类，可以直接使用父类中非私有成员，避免代码重复。
2. 关键字：extends用于实现类继承。
3. 成员访问特点：
   • 成员变量：取决于等号左边的对象。
   • 成员方法：取决于new的对象。
4. 方法重写：子类中定义与父类方法名和参数列表相同的方法。
5. 继承中构造的特点：创建子类对象时，先初始化父类。
6. super：代表父类引用，用于调用父类构造、成员变量和成员方法。
7. this：代表当前对象，用于区分重名的成员变量和局部变量。
8. 继承的特点：
   • 只支持单继承，不支持多继承。
   • 支持多层继承。
   • 一个父类可以拥有多个子类。

模块十二重点

本模块我们将探索接口和多态的概念，包括：

1. 定义接口。
2. 在接口中定义抽象方法、默认方法、静态方法和成员变量。
3. 调用接口中的成员。
4. 理解多态的前提。
5. 利用多态的方式创建对象。
6. 了解使用多态的好处。
7. 在多态的前提下进行向下转型。
8. 利用instanceof判断类型。

第一章：接口

1. 接口的介绍

接口是Java中一种定义标准和规则的方式，它允许类实现一个或多个接口，从而确保类遵循特定的规范。

2. 接口的定义及使用

接口：是一个引用数据类型，是一种标准，规则

1. jdk7以及之前:

   • 抽象方法: public abstract -> 即使不写public abstract, 默认也有
   • 成员变量: public static final 数据类型 变量名 = 值-> 即使不写public static final,默认也有
   • final是最终的,被final修饰的变量不能二次赋值,所以我们一般将final修饰的变量视为常量

2. jdk8:

   • 默认方法:public default 返回值类型 方法名(形参){}
   • 静态方法:public static 返回值类型 方法名(形参){}

3. jdk9开始:

   • 私有方法: private的方法

定义接口

public interface 接口名 {// 抽象方法、默认方法、静态方法、成员变量
}

实现接口

public class 实现类名 implements 接口名 {// 实现接口中的抽象方法
}

使用接口

public interface USB {public abstract void open();public abstract void close();
}public class Mouse implements USB {@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic void close() {System.out.println("鼠标关闭");}
}public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();mouse.close();}
}

3. 接口中的成员

抽象方法

public interface USB {public abstract void open();
}

默认方法

1. 格式:

  public default 返回值类型 方法名(形参){方法体return 结果}

2. 使用:
   • 定义实现类,实现接口
   • 默认方法可重写,可不重写
   • 创建实现类对象,调用默认方法

public interface USB {public default void methodDef() {System.out.println("我是默认方法");}
}

public class Mouse implements USB {@Overridepublic void methodDef(){System.out.println("我是重写接口中的默认方法");}
}

public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.methodDef();}
}

静态方法

1. 定义格式:

public static 返回值类型 方法名(形参){方法体return 结果} 

2. 使用: 接口名直接调用

public interface USB {public static void methodSta() {System.out.println("我是接口中的静态方法");}
}

成员变量

public interface USB {public static final int NUM1 = 100;
}

4. 接口的特点

• 接口可以多继承，一个接口可以继承多个接口。
• 一个实现类可以实现一个或多个接口。
• 一个子类可以继承一个父类的同时实现一个或多个接口。

当一个类实现多个接口时,如果接口中的抽象方法有重名且参数一样的,只需要重写一次

public interface InterfaceA {public abstract void method();
}public interface InterfaceB {public abstract void method();
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}
}

当一个类实现多个接口时,如果多个接口中默认方法有重名的,且参数一样的,必须重写一次默认方法

public interface InterfaceA {public abstract void method();public default void methodDef(){System.out.println("我是接口A中的默认方法");}
}public interface InterfaceB {public abstract void method();/*    public default void methodDef(){System.out.println("我是接口B中的默认方法");}*/public default void methodDef(int a) {System.out.println("我是接口B中的默认方法");}
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}/*    @Overridepublic void methodDef() {System.out.println("重写后的默认方法");}*/
}public class Test01 {public static void main(String[] args) {InterfaceImpl anInterface = new InterfaceImpl();anInterface.methodDef();anInterface.methodDef(10);}
}

5. 接口和抽象类的区别

• 抽象类可以有成员变量、构造方法、成员方法和抽象方法。
• 接口成员单一，一般用于抽取方法，视为功能的集合。
• 类不能多继承，但接口可以。
  

第二章：多态

面向对象三大特征: 封装、继承 、多态

1. 多态的介绍

多态是面向对象编程的三大特征之一，它允许父类引用指向子类对象，从而在运行时动态决定调用哪个类的方法。

多态的前提

• 必须存在子父类继承或接口实现关系。
• 必须存在方法重写。
• 使用父类引用指向子类对象。

多态的基本使用

public abstract class Animal {public abstract void eat();
}public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗啃骨头");}//特有方法public void lookDoor(){System.out.println("狗会看门");}
}public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}//特有方法public void catchMouse(){System.out.println("猫会捉老鼠");}
}

public class Test01 {public static void main(String[] args) {//原始方式Dog dog = new Dog();dog.eat();//重写的dog.lookDoor();//特有的Cat cat = new Cat();cat.eat();//重写的cat.catchMouse();//特有的System.out.println("==================");//多态形式new对象Animal animal = new Dog();//相当于double b = 10animal.eat();//重写的 animal接收的是dog对象,所以调用的是dog中的eat
//      animal.lookDoor();   多态前提下,不能直接调用子类特有成员Animal animal1 = new Cat();animal1.eat();//cat重写的}
}

2. 多态的条件下成员的访问特点

• 成员变量：取决于等号左边的对象。
• 成员方法：取决于new的对象。

3. 多态的好处

多态提高了程序的扩展性和灵活性。通过多态，我们可以编写出更通用、更灵活的代码，使得代码更容易维护和扩展。

4. 多态中的转型

向上转型

Animal animal = new Dog();

向下转型

Dog dog = (Dog) animal;

5. 转型可能会出现的问题

向下转型可能会抛出ClassCastException，因此在向下转型之前，我们可以使用instanceof进行类型检查。

if (animal instanceof Dog) {Dog dog = (Dog) animal;
}

6. 综合练习

定义笔记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用;
进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

• USB接口，包含开启功能、关闭功能
• 笔记本类，包含运行功能、关机功能、使用USB设备功能
• 鼠标类，要符合USB接口
• 键盘类，要符合USB接口

public interface USB {void open();void close();
}public class Mouse implements USB {@Overridepublic void open() {System.out.println("鼠标开启");}@Overridepublic void close() {System.out.println("鼠标关闭");}//特有方法public void click() {System.out.println("点击鼠标");}
}public class KeyBoard implements USB {@Overridepublic void open() {System.out.println("键盘开启");}@Overridepublic void close() {System.out.println("键盘关闭");}public void input() {System.out.println("敲击键盘");}
}public class NoteBook {//开机public void start(){System.out.println("开机");}//使用USB/*USB usb = mouse  多态USB usb = keyBoard 多态*/public void useUSB(USB usb){if (usb instanceof Mouse){Mouse mouse = (Mouse) usb;mouse.open();mouse.click();mouse.close();}else{KeyBoard keyBoard = (KeyBoard) usb;keyBoard.open();keyBoard.input();keyBoard.close();}//usb.open();//usb.close();}//关机public void stop(){System.out.println("关机");}
}

public class Test01 {public static void main(String[] args) {NoteBook noteBook = new NoteBook();Mouse mouse = new Mouse();noteBook.start();noteBook.useUSB(mouse);noteBook.stop();System.out.println("===========");KeyBoard keyBoard = new KeyBoard();noteBook.start();noteBook.useUSB(keyBoard);noteBook.stop();}
}