Chapter10【接口、多态】

Chapter10【接口、多态】
Chapter10【接口、多态】

第一章接口

1.1 概述

接口是Java中的引用类型，是方法的集合

类的内部封装了成员变量、构造方法和成员方法

接口的内部主要的就是封装了方法，包含
1. 抽象方法 abstract（JDK 7及以前）
2. 默认方法和静态方法 default（JDK8）
3. 私有方法 static（JDK9）
重点：静态私有方法，解决多个静态方法之间重复代码问题

接口的定义与定义类方式相似，但是可以被实现的（implements，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类（没完全重写接口中的方法）。
```
// 接口A
public interface MyInterfaceA{
    //定义一个抽象方法
    public abstract void methodA();
    
    
}
// 接口B
public interface MyInterfaceB(){
    //定义抽象法
    public abstract void methodB();
}
// 定义实现类

public class MyInterface implements MyInterfaceA,MyInterfaceB(){
    @Override
    public void methodA(){
        System.out.println("覆盖重写了抽象方法A")
    }
     @Override
    public void methodB(){
        System.out.println("覆盖重写了抽象方法B")
    }
}
/*
如果接口中的抽象方法没有完全重写，那么实现类就必须的是抽象类
*/
// 定义实现类A
public abstract class MyInterface implements MyInterfaceA,MyInterfaceB(){
    @Override
    public void methodA(){
        System.out.println("覆盖重写了抽象方法A")
    }
}
```
1.2 定义格式
```
public interface 接口名称{
    //抽象方法
    //默认方法
    //静态方法
    //私有方法
}
```
1.含有抽象方法

在任何版本的Java中，接口都能定义抽象方法

格式：

public abstract 返回值类型方法名称（参数列表）；

注意事项：
1. 接口中的抽象方法，修饰符必须是两个固定的关键词：public abstract
2. 两个关键字的修饰符可以选择性的省略。（刚学不推荐）
3. 方法三要素，可以随意定义。
```
public interface MySaterfaceAbstract{
    //这是一个抽象方法
  	public abstract void methodAbs1();
    
    //这也是抽象方法
    abstract void methodAbs2();
    
    //这也是抽象方法
    public void methodAbs3();
    
    //这也是抽象方法
    void methodAbs4();
}
```
使用abstract关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：
```
public interface InterFaceName{
    public abstract void method();
}
```
2.含有默认方法和静态方法

默认方法：使用default修饰，不可以省略，供子类调用或者子类重写。

静态方法：使用static修饰，供接口直接调用。
```
public interface InterFaceName{
    public default void method(){
        //执行语句
    }
    public static void method2(){
        //执行语句
    }
}
```
3.含有私有方法和静态方法

私有方法：使用private修饰，供接口中默认方法或者静态方法调用
```
public interface InterFaceName{
    private void method(){
        //执行语句
    }
}
```
1.3 基本实现

1.实现的概述

类与接口的关系为实现关系，即类实现接口，该类称为接口的实现类，也可以称为接口的子类。

实现的动作类似继承，格式相仿，只是关键字不同，实现用implements关键字。

非抽象子类实现接口：
1. 必须重写接口中所有的抽象方法。
2. 集成了接口的默认方法，即可直接调用，也可以重写。
备注：接口中的默认方法，可以解决接口的升级问题。

实现格式：
```
class 类名 implements 接口名{
    //重写接口中的抽象方法【必须】
    //重写接口中的抽象方法【可选】
}
```
2.接口抽象方法的使用

必须全部实现，代码如下：

定义接口：
```
public interface LiveAble{  
    public abstract void eat();
    public abstract void sleep();
}
```
定义实现类：
```
public class Animal implements LiveAble{
    @Override
    public void eat(){
        System.out.println("吃东西");
    }
    
    @Override
    public void sllep(){
        System.out.println("睡觉觉")；
    }
}
```
定义测试类：
```
public static InterfaceDemo{
    public static void main(String[] args){
        //创建子类对象
        Animal  a = new Animal();
        a.eat();//吃东西
        a.sleep();//睡觉觉
    }
}
```
3.默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类来调用.
1. 继承默认方法，代码如下
  
  定义接口：默认方法用default修饰
```
public interface LiveAble{
    public default void fly(){
        System.out.println("天上飞的")
    }
}
```
  定义实现类：
```
public class Animal implements LiveAble{
    //继承直接调用
}
```
  定义测试类：
```
public class InterfaceDemo{
    public static void main(String[]  args){
        //创建子类对象
        Animal a = new Animal();
        //调用默认方法
        a.fly();//天上飞的
    }
}
```
  1. 重写默认方法，代码如下：
    
    定义接口：
    
    public intrface LiveAble{ public default void fly(){ System.out.println("天上飞的")； } }
    
    定义实现类：
    
    public class Animal implements LiveAble{ @Override public void fly(){ System.out.println("水里游的")； } }
    
    定义测试类：
    
    public class InterfaceDemo{ public static void main(String[] args){ //创建子类 Animal a= new Animal(); //调用重写方法 a.fly();//水里游的 } }
4.静态方法

注意事项：不能通过接口实现类的对象来调用当中的静态方法

应直接通过接口名称调用，直接调用其中的静态方法

格式：

接口名.静态方法名（参数）

定义接口：
```
public interface LiveAble{
    public static void run(){
        System.out.println("奋斗");
    }
}
```
定义实现类：
```
public class Animal implements LiveSble{
    //无法重写静态方法
}
```
定义测试类：
```
public class Interface{
    public static void main(Stringp[] args){
        //Animal.run();【错误】无法集成方法，也无法调用
        LiveSble.run();//奋斗 
    }
}
```
5.接口私有方法
- 普通私有方法：只有默认静态方法可以调用。
  
  解决多个默认方法之间的重复代码问题
  
  格式：
  
  private 返回值类型方法名称（参数列表）{
  
  方法体
  
  }
- 私有静态方法：默认方法和静态方法可以调用。
  
  解决多个静态方法之间重复代码问题。
  
  格式：
  
  private static 返回值类型方法名称（参数列表）{
  
  方法体
  
  }
定义接口：
```
public interface LiveAble{
    default void fun(){
        fun1();
        fun2();
    }
}

private void fun1(){
    System.out.println("嗨起来~");
}
private void fun2(){
    System.out.println("燥起来~");
}
```
1.4 接口的常量

定义

接口当中也可以定义“成员变量“，但是必须使用 public static final三个关键字进行修饰。

格式

public static final 数据类型常量名称 = 数据值；

注意事项：
1. 接口中的常量，可以省略public static final 不写,注意不写也这样。
2. 接口中的常量必须赋值。一旦赋值不能修改
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
```
public interface MyInterfaceConst{
    public static final int NUM_OF_MY_CLASS = 666;
}
```
小结：

在java 9+版本中，接口的内容可以有：

[ ] :中括号的内容写的可以省略
1. 成员变量其实就是常量，格式：
  
  [public] [static] [final] 数据类型常量名称 = 数据值；
  
  注意：
  
  常量必须进行赋值，而且一反赋值不能改变
  
  常量名称必须完全大，用下划线进行分隔。
2. 接口中最重要的就是抽象方法，格式：
  
  [public] [static] 返回值类型方法名称(参数列表);
  
  注意：实现类必须覆盖重写类接口所有的抽象方法，除非实现类是抽象类。
3. 从java 8开始，接口允许定义默认方法，格式：
  
  [public] default 返回值类型方法名称（参数列表）{ 方法体 }
  
  注意：默认方法也可以被覆盖重写。
4. 从Java 8开始，接口里允许定义静态方法，格式：
  
  [public] static 返回值类型方法名称(参数列表){ 方法体 }
  
  注意：应该通过接口名进行调用。
5. 从java 9开始，接口里允许定义私有方法，格式：
  
  普通私有方法：private 返回值类型方法名称（参数列表） { 方法体 }
  
  静态私有方法：private static 返回值类型方法名称 (参数列表){ 方法体 }
  
  注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。
1.5 接口的多实现

在继承体系中，一个类只能继承一个父类。

一个类可以实现多个接口，这叫做接口的多实现，并且，一个类能继承一个父类，同时实现多个接口

实现格式：
```
public class 类名 [extends 父类名] implements 接口名1，接口名2...{
    //重写接口中的抽象方法【必须】
    //重写接口中的默认方法【不重名时可选】
}
```
【】：表示可选操作

1.抽象方法

接口中有多个抽象方法时，实现类必须重写抽象方法。

注意：

如果抽象方法有重名的，只需要重写一次

代码如下

定义多个接口：

abstract 抽象方法

default 默认方法
```
// 接口A   
public interface A{
    public abstract void showA();
    public abstract void show();
}
// 接口B
public interface B{
    public abstract void showB();
    public abstract void show();
}
```
定义实现类：
```
public class C implements A,B{
    @Override
    public void showA(){
        System.out.println("showA")
    }
    @Override
    public void showB(){
        System.out.println("showB");
    }
    @override
    public void show(){
        System.out.println("show");
    }
}
```
2.默认方法

接口中，有多个默认方法时，实现类都是可以继承使用的，如果默认方法有重名的，必须重写一次。

代码如下

定义多个接口：
```
public interface A{
    public default void methodA(){}
    public default void method(){}
}
interface B{
    public default void methodB(){}
    public default void method(){}
}
```
定义实现类：
```
public class C implements A,B{
    @Override
    public void method(){
        System.out.println("对重名的默认方法进行重写")；
    }
}
```
3.静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过个子接口名访问静态方法。

4.优先级的问题

当一个类，既继承一个父类，又实现了若干个接口时，父类中的成员方法与接口中的默认方法重名时，子类就近选择执行父类的成员方法。

代码如下

定义接口：
```
public interface A{
    public default void methodA(){
        System.out.println("默认方法A");
    }
}
```
定义父类：
```
class D{
    public void methodA(){
        System.out.println("父类方法")
    }
}
```
定义子类：
```
class C extends D implements A{
    public void methodA(){
        System.out.println("子类方法")
    }
}
```
定义测试类：
```
public static void main(String[] args){
    C c = new c();
    c.method();//父类方法
}
```
接口多实现小结：

使用接口的时候，需要注意：
1. 接口是没有静态代码块或构造方法的。
2. 一个类的直接父类值唯一的，但是一个类可以同时实现多个接口。
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口中的所有抽象方法，那么该实现类必须是一个抽象类。
5. 如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6. 一个类如果直接父类当中的方法，和接口中的冲突，优先使用父类当中的方法
第二章多态

2.1 概述

引入

面向对象的三大特征：封装、继承、多态。

extends继承或者implements实现，是多态的前提条件。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义
- 多态：是指统一行为，具有多个不同的表现形式。
前提【重点】
1. 继承或者实现【二选一】
2. 方法的重写【意义的体现：不重写，无意义】
3. 父类引用指向子类对象【格式对象】
2.2 多态的体现

多态体现的格式：
```
父类类型 变量名 = new 子类对象；
类名.方法名（）;
```
父类类型：是指子类对象继承的父类类型，或者实现的父类接口类型。

代码如下：
```
Fu  f = new Zi();
f.method();
```
编译看左边，执行看右边

当使用多态的方法时，首先检查父类中是否又该方法，如果没有，则编译报错；如果有侧执行子类重写的方法。

代码如下

定义父类：
```
public abstract void Animal(){
    public abstract void eat();
}
```
定义子类：
```
public Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
}

public Dog extends Animal{
    public void Dog(){
        System.out.println("狗吃肉");
    }
}
```
定义测试类
```
public static void main(String[] args){
    //多态形式  创建对象
    Animal a1 = new Cat();
    //调用的是cat的eat
    a1.eat();
    
    Animal a2 = new Dog();
    a2.eat();
}
```
访问成员变量的两种方式：
1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有从则向上找
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
2.3 多态的好处

父类：员工Employee

子类：讲师类Teacher和助教类Assistant

代码如下：
```
// 如果不用多态，只用子类
Teacher one = new Teacher();
one.work();//讲课
Assistant two = new Assistant();
two.work();//辅导

我现在唯一关心的就是调用work方法，其他功能不关心

//使用多态
Employee one = new Teacher();
one.work();// 讲课

Employee two = new Assistant();
teo.work();
```
好处：

无论右边new的时候换成那个子类对象，等号左边调用方法都不会改变。

2.4 引用类型转换

多态的转换分为向上转型与向下转型两种：

向上转型

其实就是多态的写法:

格式：父类名称对象名 = new 子类名称（）；

含义：右侧创建一个子类对象，把他当做父类来看待使用

Animal animal = new Cat();

注意事项：向上转型一定是安全的，从小范围转向了大范围，比如从小范围的猫，转到了大范围的动物

类似于：

double num = 100;// 正确 int -- > double ，自动类型转换

向下转型

对象的向下转型，其实就是一个【还原】得动作。

格式：子类名称对象名 = （子类名称）父类名称；

含义：将父类对象，【还原】称为本来的子类对象

Animal animal = new Cat（）；// 本来是猫，向上转型成为动物

Cat cat = （cat） animal;// 本来是猫，已经被当做动物了，还原回来成为本来的猫

注意事项：

a.必须保证对象本来创建的时候，就是猫，才能向下转型称为猫。

b.如果对象创建的时候本来不是猫，非要向下转型成为猫，就会报错。ClassCastException

类似于：

int num = (int ) 10.0;// 可以

int num = (int ) 10.5;// 不可以，精度损失

图解：

类型判断

格式：

对象 instanceof 类名称

将会得到一个Boolean值结果，也就是判断前面的对象能不能做后面类型的实例。
```
public static void main(String[] args){
    Animal animal = new Dog();// 本来是狗
    animal.eat(); // 狗吃骨头
    
    //如果希望调用子类特有的方法，需要向下转型
    //判断一下父类引用的animal本来是不是Dog
    if(animal instanceof Dog){
        Dog dog = (Dog) animal;
        dog.watchHome();
    }
    //判断一下animal本来是不是cat
    if(animal instanceof Cat){
        Cat cat = (Cat) animal;
        cat.catchMouse();
    }
}
```
第三章接口多态的综合案例

3.1 笔记本电脑

笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。

定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守 USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

3.2 案例分析

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

USB接口，包含开启功能、关闭功能

笔记本类，包含运行功能、关机功能、使用USB设备功能

鼠标类，要实现USB接口，并具备点击的方法

键盘类，要实现USB接口，具备敲击的方法

3.3 案例实现

定义USB接口：
```
public interface USB{
    // 开启功能
    public abstract open();
    // 关闭功能
    public abstract colse();
}
```
定义鼠标类：
```
public class Mouse implements USB(){
    public void open(){
        System.out.println("鼠标开启");
    }
    void close(){
        System.out.println("鼠标关闭");
    }
    public void click(){
        System.out.println("鼠标单击");
    }
}
```
定义键盘类：
```
class KeyBoard implements USB{
    void open(){
        System.out.println("键盘开启");
    }
    void close(){
       	System.out.println("键盘关闭");
    }
    public void type(){
        System.out.println("键盘打字");
    }
}
```
定义笔记本类：
```
class Laptop{
    // 笔记本开机
    public void run(){
        System.out.println("笔记本开机");
    }
    // 笔记本关机
    public voiod shutDown(){
        System.out.println("笔记本关机");
    }
    
    // 使用USB设备的方法，使用接口作为参数
    public void usbDevice(USB usb){
        // 打开设备
        usb.open();
        // 一定要先判断 判断前面的对象能不能做后面类型的实体
        if(usb instanceof Mouse){
             // 向下转型
            Mouse mouse = (Mouse) usb;
            mouse.click();
        }else if(usb instanceof Keyboard){			// 先判断
            Keyboard keyboard = (Kydoard)  usb;
            keydoard.type();
        }
        // 关闭设备
        usb.close();
    }
    
}
```
定义测试类：
```
public class Test{
    public static void main(String[] args){
        // 创建笔记本实体对象
        Laptop laptop = new Laptop();
        // 笔记本开机
        laptop.run();
        
        // 创建鼠标实体对象 多态写法
        USB usbMouse = new Mouse();
        // 参数是usb类型，传递进去的就是usb类型
        laptop.usbDevice(usbMouse);
        // 创建一个USB键盘  不用多态写法
        Keyboard keyboard = new Keyborad();
        // 发生了向上转型
        laptop,subDevice(keyboard);
        
         // 笔记本关机
        laptop.close();
        System.out.println("+++++++++++");
        method(10.0);// 正确写法，double-->double 
        methos(20);// int -- > double
        int a = 30;
        method(a); // int -- > double
        }
       // 举例说明：
        public void method(double num){
            System.out.println(num);
        
    }
}
```
相关阅读:
smarty
js进阶
 JS 基础
 php之面向对象（2）
php之面向对象（1）
PHP之图形处理
 PHP代码分离
 PHP文件上传与安全
 PHP substr截取中文字符出现乱码的问题解疑
 关于学习方法
原文地址：https://www.cnblogs.com/anke-z/p/12425315.html

Chapter10【接口、多态】

Chapter10【接口、多态】

第一章 接口

1.1 概述

1.2 定义格式

1.含有抽象方法

2.含有默认方法和静态方法

3.含有私有方法和静态方法

1.3 基本实现

1.实现的概述

2.接口抽象方法的使用

3.默认方法的使用

4.静态方法

5.接口私有方法

1.4 接口的常量

定义

格式

注意事项：

小结：

1.5 接口的多实现

1.抽象方法

2.默认方法

3.静态方法

4.优先级的问题

接口多实现小结：

第二章 多态

2.1 概述

引入

定义

前提【重点】

2.2 多态的体现

访问成员变量的两种方式：

2.3 多态的好处

2.4 引用类型转换

向上转型

向下转型

类型判断

第三章 接口多态的综合案例

3.1 笔记本电脑

3.2 案例分析

3.3 案例实现

第一章接口

第二章多态

第三章接口多态的综合案例