Java笔记(09)：面向对象--接口

Posted 2020-09-19 花醉红尘

1、接口的成员特点：

 1 /*
 2     接口的特点：
 3         A:接口用关键字interface表示    
 4             interface 接口名 {}
 5         B:类实现接口用implements表示
 6             class 类名 implements 接口名 {}
 7         C:接口不能实例化
 8             那么，接口如何实例化呢?
 9             按照多态的方式来实例化。
10         D:接口的子类
11             a:可以是抽象类。但是意义不大。
12             b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
13     
14     由此可见：
15         A:具体类多态(几乎没有)
16         B:抽象类多态(常用)
17         C:接口多态(最常用)
18 */
19 //定义动物培训接口
20 interface AnimalTrain {
21     public abstract void jump();
22 }
23 
24 //抽象类实现接口
25 abstract class Dog implements AnimalTrain {
26 }
27 
28 //具体类实现接口
29 class Cat implements AnimalTrain {
30     public void jump() {
31         System.out.println("猫可以跳高了");
32     }
33 }
34 
35 class InterfaceDemo {
36     public static void main(String[] args) {
37         //AnimalTrain是抽象的; 无法实例化
38         //AnimalTrain at = new AnimalTrain();
39         //at.jump();
40         
41         AnimalTrain at = new Cat();
42         at.jump();
43     }
44 }

2、类与类、类与接口、接口与接口的关系：

 1 /*
 2     类与类：
 3         继承关系,只能单继承,可以多层继承。
 4     类与接口：
 5         实现关系,可以单实现,也可以多实现。
 6         并且还可以在继承一个类的同时实现多个接口。
 7     接口与接口：
 8         继承关系,可以单继承,也可以多继承。
 9 */
10 interface Father {
11     public abstract void show();
12 }
13 
14 interface Mother {
15     public abstract void show2();
16 }
17 
18 interface Sister extends Father,Mother {
19 
20 }
21 
22 //class Son implements Father,Mother //多实现
23 class Son extends Object implements Father,Mother {
24     public void show() {
25         System.out.println("show son");
26     }
27     
28     public void show2() {
29         System.out.println("show2 son");
30     }
31 }
32 
33 class InterfaceDemo3 {
34     public static void main(String[] args) {
35         //创建对象
36         Father f = new Son();
37         f.show();
38         //f.show2(); //报错
39     
40         Mother m = new Son();
41         //m.show(); //报错
42         m.show2();
43     }
44 }

3、抽象类和接口的区别

A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象

B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承

C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

4、猫狗案例：

  1 /*
  2     猫狗案例,加入跳高的额外功能
  3     
  4     分析：从具体到抽象
  5         猫：
  6             姓名,年龄
  7             吃饭，睡觉
  8         狗：
  9             姓名,年龄
 10             吃饭，睡觉
 11             
 12         由于有共性功能，所以，我们抽取出一个父类：
 13         动物：
 14             姓名,年龄
 15             吃饭();
 16             睡觉(){}
 17             
 18         猫：继承自动物
 19         狗：继承自动物
 20         
 21         跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
 22         接口：
 23             跳高
 24             
 25         部分猫：实现跳高
 26         部分狗：实现跳高
 27     实现；
 28         从抽象到具体
 29         
 30     使用：
 31         使用具体类
 32 */
 33 //定义跳高接口
 34 interface Jumpping {
 35     //跳高功能
 36     public abstract void jump();
 37 }
 38 
 39 //定义抽象类
 40 abstract class Animal {
 41     //姓名
 42     private String name;
 43     //年龄
 44     private int age;
 45     
 46     public Animal() {}
 47     
 48     public Animal(String name,int age) {
 49         this.name = name;
 50         this.age = age;
 51     }
 52     
 53     public String getName() {
 54         return name;
 55     }
 56     
 57     public void setName(String name) {
 58         this.name = name;
 59     }
 60     
 61     public int getAge() {
 62         return age;
 63     }
 64     
 65     public void setAge(int age) {
 66         this.age = age;
 67     }
 68     
 69     //吃饭();
 70     public abstract void eat();
 71     
 72     //睡觉(){}
 73     public void sleep() {
 74         System.out.println("睡觉觉了");
 75     }
 76 }
 77 
 78 //具体猫类
 79 class Cat extends Animal {
 80     public Cat(){}
 81     
 82     public Cat(String name,int age) {
 83         super(name,age);
 84     }
 85     
 86     public void eat() {
 87         System.out.println("猫吃鱼");
 88     }
 89 }
 90 
 91 //具体狗类
 92 class Dog extends Animal {
 93     public Dog(){}
 94     
 95     public Dog(String name,int age) {
 96         super(name,age);
 97     }
 98     
 99     public void eat() {
100         System.out.println("狗吃肉");
101     }
102 }
103 
104 //有跳高功能的猫
105 class JumpCat extends Cat implements Jumpping {
106     public JumpCat() {}
107     
108     public JumpCat(String name,int age) {
109         super(name,age);
110     }
111 
112     public void jump() {
113         System.out.println("跳高猫");
114     }
115 }
116 
117 //有跳高功能的狗
118 class JumpDog extends Dog implements Jumpping {
119     public JumpDog() {}
120     
121     public JumpDog(String name,int age) {
122         super(name,age);
123     }
124 
125     public void jump() {
126         System.out.println("跳高狗");
127     }
128 }
129 
130 class InterfaceTest {
131     public static void main(String[] args) {
132         //定义跳高猫并测试
133         JumpCat jc = new JumpCat();
134         jc.setName("哆啦A梦");
135         jc.setAge(3);
136         System.out.println(jc.getName()+"---"+jc.getAge());
137         jc.eat();
138         jc.sleep();
139         jc.jump();
140         System.out.println("-----------------");
141         
142         JumpCat jc2 = new JumpCat("加菲猫",2);
143         System.out.println(jc2.getName()+"---"+jc2.getAge());
144         jc2.eat();
145         jc2.sleep();
146         jc2.jump();
147     
148     }
149 }