接口

一个类只能继承一个类，如果想要继承多个类中的方法，那么就需要用到接口。接口增加了代码的复用性和拓展性。

1.接口的定义：

与定义类相似，用interface修饰(没有class)，编译会生成.class文件，但不是类，是一种引用类型。接口的使用不能创建

对象，可以被实现，接口的实现是通过implements关键字加接口名实现，一个实现接口的类，必须重写所有抽象方法，

创建该类的对象就可以调用方法，否则只能是抽象类。

2.定义格式:

public interface 接口名称 {

       // 静态常量

// 抽象方法

// 默认方法

// 静态方法

// 私有方法(有static和没有static)

}

3.成员的定义：

a)静态常量：public static final 数据类型  大写变量名 =  值;

例子：public static final int num = 20；（修饰不写会默认添加）

b)抽象方法：public abstract void 方法名();

例子：public abstract void method();       和抽象类中定义已一样

c)默认方法：public default void 方法名(){....}

例子：public default void method(){....}           关键字default修饰

d)静态方法：public static void 方法名(){...}

public static void 方法名(){....}                      关键字static修饰

e)私有方法 private 修饰的方法

private void 方法名(){...}

private static void 方法名(){...}

4.接口的使用：

必须重写所有的抽象方法，默认方法选择性重写，私有方法和静态方法和实现类无关，使用关键字implements实现，然

后创建实现类的对象使用

私有方法：只有默认方法可以调用。

私有静态方法：默认方法和静态方法可以调用。

5.接口的多实现：

public class 实现类/子类  implements 接口1,接口2，接口3{

//必须实现(覆盖重写)所有的抽象方法

接口1+接口2+接口3+父类中的抽象方法

对于接口相同的抽象方法，只重写一次就可以

//默认方法

必须覆盖重写，冲突的

//私的，静态的不考虑

}

6.继承与接口的优先级：

一个类可继承一个父类实现多个接口，

public class 子类/实现类 extends 父类  implements 接口1,接口2,接口3{

父类+接口1,接口2,接口3  抽象方法都必须覆盖重写

多个接口中重名的，只覆盖重写一次

//默认方法

接口1,接口2,接口3，有默认方法与父类中的重名。

父类中优先级高 

子类中更高

}

7.接口与接口的多继承

类与类是单继承，接口可以继承多个

类与类， 单继承

类与接口，实现

接口与接口，多继承

public interface 子接口 extends 接口1，接口2,接口3...{

// 继承过来的抽象方法:接口1+接口+接口3中

冲突：只覆盖重写一个

// 继承过来 默认方法

冲突：多个默认方法重名必须重写一次

}

public class 子类/实现类  implments 子接口{....}

8.接口的注意事项：

1.不能成员变量

2.不能get/set公有普通方法

3.不能构造方法

4.不能静态代码块

多态

多态是指同一行为，具有多个不同表现形式。比如动物以这个类，猫和狗的叫声是不同的，同一个动作不同的表现，需要

用多态实现。

1.不用多态实现不同动物不同的行为，需要创建不同类的对象，然后调用参数不同的方法

2.如果使用多态，不需要根据对象的具体类型，也就是调用方法传参的时候不用考虑是猫是狗，统一是动物对象传参：如下

多态的使用格式：

        父类  对象名 =   new  子类();   //类的多态

接口  对象名 =   new  子类();   //接口的多态

3.类的多态

父类  对象名 =   new  子类();   //类的多态

1.子类不能是抽象类

2.父类一般是抽象类

3.父类可以不是直接父类，还可是间接父类

4.接口的多态

接口  对象名 =   new  子类();   //接口的多态

1.子类/实现必须实现这个接口

2.子类不能是抽象类

5.多态的好处

1. 提高代码的复用性与扩展性
2. 定义方法变量的参数或者返回值的时候
3. 有接口写接口，有父类写父类

6.多态的特点

成员变量编译看左边，运行看左边

成员方法编译看左边，运行看右边

7.弊端：

子类对象保存成父类类型，不能调用子类的成员

8.多态的转型分为向上转型与向下转型两种

向下转型

        父类转成子类型

        子类类型  对象名 =(子类类型) 父类

向上转型

        子类类型转成父类

        父类  对象名 =  子类对象

9.转型异常

      1.向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的

      2.向上转型的时候，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法

    3.转型异常，向下转型的时候，编译器是不报错的，但是遇到向下转换正别的子类型的时候运行会报错

10.instanceof 关键字

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验

使用方式：变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false