Java面向对象与类(五):接口,多态

一.接口

1. 概述

• 接口的内部主要就是封装了方法
• Java7–>接口包含内容有常量和抽象方法(abstract方法)
• Java8–>额外包含默认方法和静态方法
• Java9–>额外包含私有方法
• 引用数据类型：数组，类，接口。
• 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成**.class**文件，但一定要明确它并 不是类，而是另外一种引用数据类型。
• 接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。
• 一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象 类

2. 定义格式

public interface 接口名称 {
      
	// 抽象方法 
	// 默认方法 
	// 静态方法 
	// 私有方法 
}

• 含有抽象方法
• 抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。修饰符必须为两个固定的关键字,public abstract,可以选择性省略.该方法供子类实现使用。

public interface InterFaceName {
      
	public abstract void method(); 
}

• 含有默认方法和静态方法
• 默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。解决接口升级的方法. 可以通过接口实现类对象直接调用,也可被接口实现类进行覆盖重写.

//定义接口
public interface MyInterfaceDefault {
     

    //抽象方法
    public abstract void methodAbs();

    //新的默认方法
    public default void methodDefault(){
     
        System.out.println("新添加的默认方法");
    }
//实现类A
public class MyInterfaceDefaultA implements MyInterfaceDefault{
     
    @Override
    public void methodAbs() {
     
        System.out.println("实现了抽象方法.AAA");
    }
//实现类B
public class MyInterfaceDefaultB implements MyInterfaceDefault{
     
    @Override
    public void methodAbs() {
     
        System.out.println("实现了抽象方法,BBB");
    }

    @Override
    public void methodDefault() {
     //对默认方法进行覆盖重写
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
//测试类
public class Demo02Interface {
     

    public static void main(String[] args) {
     
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs();

        //调用默认方法,如果实现类不存在,就会向上找接口的方法
        a.methodDefault();
        System.out.println("==========================");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault();
    }

• 静态方法：使用 static 修饰，供接口直接调用。不能通过接口实现类的对象来调用接口的静态方法.可以直接通过接口名称调用其中的静态方法.调用格式 : 接口名称.静态方法名(参数);

public interface InterFaceName {
      
	public default void method() {
      
		// 执行语句 
	}
	public static void method2() {
      
		// 执行语句 
	} 
}

• 含有私有方法和私有静态方法
• 私有方法：抽取一个公有方法,解决两个默认方法之间重复代码的问题,这个方法不允许实现类使用,私有化的,使用 private 修饰，供接口中的默认方法或者静态方法调用。
• 普通私有方法:解决多个默认方法之间重复代码问题

public 返回值类型 方法名称(参数列表){
     
	//方法体;
}

• 静态私有方法:解决多个静态方法之间重复代码问题

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

3. 基本实现

• 概述
• 类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。
• 实现的动作类 似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
• 非抽象子类实现接口：
• 1. 必须重写接口中所有抽象方法===>去掉abstract关键字,加上方法体大括号。
• 2.创建实现类的对象,进行使用。

//实现格式
public class 实现类名称 implements 接口名 {
      
	// 重写接口中抽象方法【必须】 
	// 重写接口中默认方法【可选】 
}

• 如果实现类没有覆盖接口中所有的抽象方法,这个实现类自己必须是抽象类.
• 抽象方法使用
• 必须全部实现
• 默认方法使用
• 可以继承，可以重写，二选一，但是只能通过实现类的对象来调用
• 1. 继承默认方法
• 2. 重写默认方法
• 静态方法使用
• 静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：
• 私有方法使用
• 私有方法：只有默认方法可以调用。
• 私有静态方法：默认方法和静态方法可以调用。
• 接口中定义成员变量
• 使用final关键字修饰,表示不可改变.
• 接口中常量,必须进行赋值.
• 接口常量名称,使用完全大写的字母,使用下划线进行分隔.
• 使用public static final三个关键字

public interface MyInterfaceConst {
     

    public static final int NUM_OF_MY_CLASS = 10;

}
public class Demo05Interface {
     

    public static void main(String[] args) {
     
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

• 接口的多实现
• 接口无静态代码或者构造方法的
• 一个类直接父类唯一,一个类可以实现多个接口
• 实现类实现的多个接口,存在重复的抽象方法,只需要覆盖重写一次即可.
• 如果实现类没有覆盖所有接口的所有抽象方法,则实现类就必须是一个抽象类
• 如果实现类实现的多个接口中,存在重复的默认方法,则实现类对冲突的默认方法进行覆盖重写.
• 一个类若直接父类中方法,和接口中默认方法产生冲突,优先使用父类中方法.

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
      
	// 重写接口中抽象方法【必须】 
	// 重写接口中默认方法【不重名时可选】 
}

public interface MyInterfaceA {
     

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault(){
     
        System.out.println("默认方法AAA");
    }
}
public interface MyInterfaceB {
     

    public abstract void methodB();

    public abstract void methodAbs();

    public default void methodDefault(){
     
        System.out.println("默认方法BBB");
    }
}
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
     
    @Override
    public void methodA() {
     
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodAbs() {
     
        System.out.println("覆盖重写了AB接口均有的抽象方法");
    }

    @Override
    public void methodDefault() {
     
        System.out.println("对冲突方法进行默认重写");
    }

    @Override
    public void methodB() {
     
        System.out.println("覆盖重写了B方法");
    }
}

• 接口小结
• 成员变量为常量,格式:[public] [static] [final] 数据类型 常量名称 = 数据值;
  注意 : 常量必须进行赋值,赋值不可改变;常量名称完全大写,下划线分隔.
• 接口中的抽象方法,格式 :[public] [abstract] 返回值类型 方法名称(参数列表);,实现类必须覆盖重写接口所有的抽象方法,除非实现类是抽象类.
• java8以后,接口里允许定义默认方法,格式:[public] default 返回值类型 方法名称(参数列表) {方法体};,默认方法也可被覆盖重写.
• java8以后,接口允许定义静态方法,格式:[public] static 返回值类型 方法名称(参数列表){方法体};,通过接口名称进行调用,不能通过实现类对象调用接口静态方法.
• java9开始,接口允许定义私有方法,只有接口自己才能调用,格式:
• 普通私有方法 : private 返回值类型 方法名称(参数列表){方法体};
• 静态私有方法 : private static 返回值类型 方法名称(参数列表) {方法体};
• 接口之间多继承
• 类与类之间单继承,直接父类只有一个
• 类与接口之间多实现,一个类实现多个接口
• 接口与接口之间多继承的
  注意事项:
• 多个父接口中的抽象方法如果重复,没有关系
• 多个父接口的默认方法重复,子接口必须进行默认方法的覆盖重写,必须带default修饰符.

二.多态

• 引入
• ，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。
• 多态： 是指同一行为，具有多个不同表现形式。
• 前提
• .继承或者实现【二选一】
• 方法的重写【意义体现：不重写，无意义】
• 父类引用指向子类对象【格式体现】
• 多态的体现

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

• 访问成员变量两种形式
• 直接通过对象名称访问成员变量,优先使用等号左边,否则负责向上寻找
• 间接通过成员方法访问成员变量,这个方法属于谁,优先用谁,没有向上找.
• 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。子类没有覆盖重写,就是父类;子类覆盖重写,就是子类.

//定义父类
public abstract class Animal {
      
	public abstract void eat(); 
}
//定义子类
class Cat extends Animal {
      
	public void eat() {
      
		System.out.println("吃鱼"); 	
	} 
}
class Dog extends Animal {
      
	public void eat() {
      
		System.out.println("吃骨头"); 
	} 
}
//定义测试类
public class Test {
      
	public static void main(String[] args) {
      
		// 多态形式，创建对象 
		Animal a1 = new Cat(); 
		// 调用的是 Cat 的 eat 
		a1.eat(); 

		// 多态形式，创建对象 
		Animal a2 = new Dog(); 
		// 调用的是 Dog 的 eat 
		a2.eat(); 
	} 
}

• 多态成员方法使用
• 首先看new的是谁,就优先调用谁,否则向上查找
• 编译看左边,运行看右边

((Zi) obj).methodZi();

• 多态好处
• 实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。

三.引用类型转换

• 向上转型
• 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
• 当父类引用指向一个子类对象时，便是向上转型。
  

//使用格式：
父类类型 对象名 = new 子类类型(); 
如：Animal a = new Cat();

• 向下转型
• 父类类型向子类类型向下转换的过程，这个过程是强制的。
• 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型.

//使用格式
子类类型 变量名 = (子类类型) 父类变量名; 
如:Cat c =(Cat) a;