接口和多态

1.接口就是多个类的公共规范

接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

如何定义一个接口的格式：

public interface 接口名称{
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class

如果是java7，那么接口中可以包含的内容有：1.常量 2.抽象方法

java8,还可额外包含有：默认方法，静态方法

java9.额外包含有：私有方法。

2.接口中抽象方法的定义：

1 /*在任何java版本中，接口都能定义抽象方法。
 2 格式：
 3 public abstract 返回值类型 方法名称（参数列表);
 4 
 5 注意事项：
 6 1.接口当中的抽象方法，修饰符必须是两个固定关键字，public abstract
 7 2.这两个关键字修饰符，可以选择型省略，
 8 */
 9 public interface Demo01Interface {
10     //以下四种都是抽象方法
11     public abstract void methodAbs1();
12     abstract  void methodAbs2();
13     public void methodAbs3();
14     void methodAbs4();
15 }

3.接口抽象方法的使用

1 public interface Demo01Interface {
 2     //以下四种都是抽象方法
 3     public abstract void methodAbs1();
 4     abstract  void methodAbs2();
 5     public void methodAbs3();
 6     void methodAbs4();
 7 
 8 
 9 
10 public class MyInterfaceAbstractImpl implements Demo01Interface{
11 
12     @Override
13     public void methodAbs1() {
14         System.out.println("这是第一个方法");
15     }
16 
17     @Override
18     public void methodAbs2() {
19         System.out.println("这是第二个方法");
20 
21     }
22 
23     @Override
24     public void methodAbs3() {
25         System.out.println("这是第三个方法");
26 
27     }
28 
29     @Override
30     public void methodAbs4() {
31         System.out.println("这是第四个方法");
32 
33     }
34 }
35 
36 
37 
38 接口的使用步骤：
39 1.接口不能直接使用，必须有一个“实现类”来“实现”该接口
40 格式：
41 public class 实现类名称 implements 接口名称{
42 
43 }
44 2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
45 实现：去掉abstract关键字，加上方法体大括号。
46 3.创建实现类的对象，进行使用
47 注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己必须是抽象类。
48 */
49 public class DemoInterface {
50     public static void main(String[] args) {
51         //错误写法，不能直接new接口对象使用
52         //Demo01Interface demo = new Demo01Interface();
53         //创建实现类的对象使用
54         MyInterfaceAbstractImpl inter = new MyInterfaceAbstractImpl();
55         inter.methodAbs1();
56         inter.methodAbs2();
57         inter.methodAbs3();
58         inter.methodAbs4();
59 
60     }
61 }

4.接口的默认定义方法

1 public interface InterfaceDefault {
 2     //抽象方法
 3     public abstract void methodAbs();
 4     //新增加了一个抽象方法
 5    // public abstract void methodAbs2();
 6 
 7     public default void methodDefault(){
 8         System.out.println("这是新添加的默认方法");
 9     }
10 
11 }
12 
13 
14 
15 
16 public class MyInterfaceDefaultA implements InterfaceDefault{
17     @Override
18     public void methodAbs(){
19         System.out.println("实现了抽象方法，AAA");
20     }
21 
22     @Override
23     public void methodDefault(){
24         System.out.println("实现类A覆盖重写了接口的默认方法");
25     }
26 
27 }
28 
29 
30 public class MyInterfaceDefaultB implements InterfaceDefault{
31 
32     @Override
33     public void methodAbs() {
34         System.out.println("实现了抽象方法：BBB");
35     }
36 }
37 
38 
39 public class Demo02Interface {
40     public static void main(String[] args) {
41         //创建了实现类对象
42         MyInterfaceDefaultA m = new MyInterfaceDefaultA();
43         //调用抽象方法，实际运行的是右侧的实现类
44         m.methodAbs(); //实现了抽象方法，AAA
45 
46         //实现类A覆盖重写了接口的默认方法
47         m.methodDefault(); //实现类A覆盖重写了接口的默认方法
48         System.out.println("-----------------");
49 
50         MyInterfaceDefaultB m1 = new MyInterfaceDefaultB();
51         m1.methodAbs(); //实现了抽象方法：BBB
52         m1.methodDefault();//这是新添加的默认方法
53     }
54 }