Java基础—接口、多态性、对象的向上/下转型

一、接口

1.接口概念

生活中的接口就是一种公共的规范标准，由此引申出代码中的接口：

接口就是多个类的公共规范。
接口是一种【引用数据类型】，其中最重要的内容就是抽象方法。
基本数据类型：byte、short、int、long、float、double、char、boolean（四类八种），除此以外的都是引用数据类型。

2.接口的内容

1.常量（成员变量）
  成员变量其实就是常量，格式：[public] [static] [final] 数据类型 常量名称 = 数据值;(中括号表示可以省略不写)
  注意！！！
	  常量必须进行赋值，而且一旦赋值不能改变；
	  常量名称完全大写，用下划线进行分隔。

2.抽象方法【重点】
  接口中最重要的就是抽象方法，格式：[public] [abstract] 返回值类型 方法名称（参数列表）;
  注意：实现类必须覆盖重写接口【所有的】抽象方法，除非实现类也是抽象类。

3.默认方法
  接口里允许定义默认方法，格式：[public] default 返回值类型 方法名称(参数列表){方法体};
  注意：默认方法也可以被覆盖重写

4.静态方法
  接口里允许定义静态方法，格式：[public] static 返回值类型 方法名称(参数列表){方法体};
  注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。这一点和调用static关键字修饰的方法时，直接通过类名调用一样。

5.私有方法
  接口里允许定义私有方法，格式：
  	普通私有方法：private 返回值类型 方法名称(参数列表){方法体};
  	静态私有方法：private static 返回值类型 方法名称(参数列表){方法体};
  	注意：private的方法只有接口自己才能调用，不能被实现类或其他调用

3.如何定义一个接口？
接口的关键字是：interface

public interface 接口名称{

// 接口内容

}

注意：定义一个标准类的时候，关键字是class，编译之后生成的字节码文件是.class文件；当换成interface关键字以后，生成的字节码文件仍然是.class文件。

4.如何使用一个接口？

1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。（“实现类”好比于“子类”，“实现”好比于“extends”）
格式：
public class 实现类名称 implements 接口名称{
    // ...
}

补充：继承关系的格式
public class 子类 extends 父类{
    // ...
}

2.接口的实现类必须覆盖重写接口中【所有的】抽象方法。
实现（覆盖重写）：去掉abstract关键字，加上方法体和大括号。
覆盖重写的过程就是由抽象到具体的过程。

3.通过创建实现类的对象。进行使用。

【注意事项】：
如果实现类并没有覆盖重写接口中【所有的】抽象方法，那么这个实现类本身必须是【抽象类】。

5.接口中的常量

接口当中可以定义常量，这其实是一个成员变量，只不过必须使用public static final三个关键字进行修饰，从效果上看，这个成员变量就相当于常量。

格式：[public] [static] [final] 数据类型 常量名称 = 数据值;

修饰符：
	public：权限最高，谁都可以用
	static：静态，表示和对象没有关系，直接通过接口名称调用即可。
	final：表示不可变

注意事项：
	1.接口当中的常量，必须进行赋值
	2.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

6.接口中的抽象方法

定义抽象方法的格式：[public] [abstract] 返回值类型 方法名称(参数列表);(没有大括号和方法体)

注意事项：
1.接口当中的抽象方法，修饰符必须是两个【固定】的关键字：public abstract

2.这两个关键字修饰符，可以选择性的省略,public和abstract省略哪一个都可以，或者都省略。

3.方法的三要素，可以随意定义。

7.接口中的默认方法

默认方法会被实现类继承下去，所以默认方法可以用于【接口的升级】。

接口的默认方法，可以通过接口实现类对象，直接调用。

接口的默认方法，也可以被接口实现类进行覆盖重写。

定义默认方法的格式：
public default 返回值类型 方法名称（参数列表）{
// 方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。

8.接口中的静态方法

静态方法只和类有关系，与对象没有关系，所以不能通过接口实现类的对象来调用接口当中的静态方法。即静态和对象是没有关系的。

正确使用方法是直接通过接口名称调用其中的静态方法，格式：接口名称.静态方法名(参数);

定义静态方法的格式：
public static 返回值类型 方法名称(参数列表){
// 方法体
}

注：就是将abstract和default换成static即可，带上方法体。

9.接口中的私有方法

当一个接口中的两个方法存在相同代码，为了减少代码的重复，我们需要将其【共性部分】抽取出来，但是这个共有方法不应该让实现类使用，应该是【私有化】的。

如果在一个实现类中，能直接访问到接口中为了共性部分而设计的默认方法，那么是有问题的。因为，这个默认方法只是为了共性提取而设计的，普通实现类对象不应该能访问到才对。

1.普通私有方法：解决多个【默认方法】之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表){
    方法体
}

2.静态私有方法：解决多个【静态方法】之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表){
    方法体
}

10.使用接口的注意事项

1.接口是没有静态代码块或者构造方法的。构造方法是用来创建对象的，但是接口的使用必须要通过实现类来实现。

2.一个【子类】的直接父类是【唯一】的，但是一个【实现类】可以同时实现【多个】接口
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    // 覆盖重写所有抽象方法
}

注意！！！
Java中任何一个类，其实都是Object直接或间接的子类。
所以定义格式补充完整时，即一个类在继承父类的同时，实现了接口：
public class MyInterfaceImpl extends Object implements MyInterfaceA, MyInterfaceB

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类【一定要】对冲突的默认方法进行覆盖重写。

6.一个类如果直接父类当中的方法，和接口当中的默认方法，产生了冲突（【优先级问题】），【优先用】父类中的方法

11.接口之间的多继承

1.类与类之间是【单继承】的。直接父类只能有一个

2.类与接口之间是【多实现】的，一个类可以实现多个接口。

3.接口与接口之间是【多继承】的。
  public interface MyInterface extends MyInterfaceA, MyInterfaceB{

注意事项：
1.多个父接口当中的抽象方法如果重复，没有关系。
2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的重写覆盖，而且要带着default关键字。

二、多态性

1.多态概述
继承是多态的前提。继承性在Java中的体现：extends继承、implements实现。

多态性，是指对象有多种形态，例如一个人既是学生，又是人类，所以他就同时具有学生和人类两种形态，这就是多态性。

代码当中体现多态性：【父类引用指向子类对象】。(即左父右子就是多态，右侧子类对象被当做父类进行使用)

格式：
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称();

一个子类其实就是一个父类。

2.访问成员变量的方式

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

1.【直接】通过【对象名称】访问成员变量：
    看【等号左边】是谁，优先用谁，没有则向上找。
    
2.【间接】通过【成员方法】访问成员变量：
    【看该方法属于谁】，就优先用谁，没有则向上找。

注意事项：
1.成员变量是不能被覆盖重写的，只有方法才能够覆盖重写。
  这也就决定了，访问成员变量时，看等号左边，因为【子类对象不能重写成员变量】；访问成员方法时，看等号右边，因为【子类对象可能会覆盖重写成员方法】，最终是由子类对象决定的。

2.访问【成员变量】时，看【等号左边】是谁，就优先用谁，没有则向上找。

3.访问成员方法的规则

在多态中，访问成员方法时，看new的是谁，就优先用谁，没有则向上找。即看【等号右边】。

4.访问成员变量和访问成员方法的对比

访问成员变量：编译时看左边，运行时看左边

访问成员方法：编译时看左边，运行时看右边

巧记：
	1.因为成员变量不能被覆盖重写，所以右边不影响成员变量，所以编译和运行都看左边
	
	2.因为成员方法可以被覆盖重写，所以右边会对其产生影响，所以编译看左边，但是运行时看右边。

5.使用多态的好处

无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。（等号左边具有统一性）

三、对象的向上/下转型

1、对象的【向上转型】，其实就是【多态】写法

1.格式：
父类名称 对象名 = new 子类名称();

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

3.类似于：
double num = 100;   // 正确，int --> double,自动类型转化，从小范围到大范围

【注意事项】：
    1.向上转型一定是安全的。【从小范围转向了大范围】

    2.向上转型也存在一个【弊端】:
      对象一旦向上转型为父类，那么就【无法调用子类原本特有的内容】。

    3.解决方案：用对象的【向下转型】【还原】。

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

1.格式：
子类名称 对象名 = (子类名称)父类对象;
备注：此处的小括号【类似于强制类型转换】的效果，所以可以把它看成是引用对象类型中的强制类型转换。
     专业术语来讲，叫做向下转型

2.含义：
将父类对象，【还原】成为本来的子类对象。

3.类似于：（基本数据类型中的强制转换）
int num = (int)10.0;    // 正确
int num = (int)10.5;    // 错误，会发生精度损失

注意事项：
    1.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫
    2.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

3.instanceof关键字

instanceof关键字用于类型判断，可以保证在向下转型的时候不会出错。可以知道一个父类引用的对象，本来是什么子类。

格式：
对象 instanceof 类名称
会得到一个【boolean】值，也就是判断前面的对象能不能当做后面类型的实例。

注意事项：
向下转型一定要进行instanceof判断，否则会发生ClassCastException（类转换异常）。