11.接口

接口

接口的概述：

　　接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

　　接口相当于特殊的抽象类，一个“纯”的抽象类，Java中的接口更多的体现在对行为的抽象

接口的特点：

- 接口用关键字interface修饰
  - 　　　　public interface 接口名{}
- 类实现接口用implements表示
  - 　　　　public class 类名 implentments 接口名{}
- 接口不能实例化
  - 　　　　接口如何实例化呢？参照多态的方式，通过实现类对象进行实例化，这叫接口多态
  - 　　多态的形式：具体类多态，抽象类多态，接口多态
  - 　　多态的前提：有继承或者实现关系，有方法重写；有父（类/接口）引用指向（子/实现）类对象
- 接口的实现类
  - 　　　　要么重写接口中的所有抽象方法
  - 　　要么是抽象类

接口的成员特点：

成员变量
- 　　只能是公开静态常量
- 默认修饰符：public static final
构造方法

　接口中没有构造方法，因为接口主要是对行为进行抽象，是没有具体存在
一个类如果没有父类，默认继承自Object类

成员方法
- 　　只能是公开抽象方法
- 默认修饰符：public abstract

课堂案例：猫和狗

需求：对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能，请采用抽象类和接口来实现猫狗案例

并在测试类中进行测试

思路：

定义接口(Jumping)
- 　　成员方法：跳高（）
定义抽象动物类（Animal）
- 　　成员变量：姓名、年龄；构造方法：无参、带参；成员方法：get/set方法，吃饭
定义具体猫类（Cat）,继承动物类，实现跳高接口
- 　　构造方法：无参、带参；成员方法：重写吃饭(){...},重写跳高方法(){......}
定义狗类（Dog）,继承动物类，实现跳高接口
- 　　构造方法：无参、带参；成员方法：重写吃饭(){...},重写跳高方法(){......}
定义测试类（AnimalDemo）,写代码测试

代码如下

  1 public class AnimalDemo {
  2     public static void main(String[] args) {
  3         //创建对象，调用方法
  4         Jumpping jumpping = new Cat();
  5         jumpping.jump();
  6         System.out.println("--------");
  7         
  8         Animal animal  = new Cat();
  9         animal.setName("波斯");
 10         animal.setAge(5);
 11         System.out.println(animal.getName()+","+animal.getAge());
 12         animal.eat();
 13         System.out.println("--------");
 14         
 15         //常用的方式还是直接创建子类对象，既包含eat方法，又包含jump方法
 16         Cat aCat =  new Cat();
 17         aCat.setName("加菲");
 18         aCat.setAge(5);
 19         System.out.println(aCat.getName()+","+aCat.getAge());
 20         aCat.eat();
 21         aCat.jump();
 22     }
 23 }
 24 
 25 //接口
 26 public interface Jumpping {
 27     public abstract void jump();
 28 }
 29 
 30 
 31 
 32 //抽象类
 33 public abstract class Animal {
 34     private String name;
 35     private int age;
 36     public Animal() {
 37         // TODO Auto-generated constructor stub
 38     }
 39     
 40     public Animal(String name, int age) {
 41         super();
 42         this.name = name;
 43         this.age = age;
 44     }
 45 
 46     public String getName() {
 47         return name;
 48     }
 49     public void setName(String name) {
 50         this.name = name;
 51     }
 52     public int getAge() {
 53         return age;
 54     }
 55     public void setAge(int age) {
 56         this.age = age;
 57     }
 58     public abstract void eat();
 59 }
 60 
 61 //Cat类
 62 public class Cat extends Animal implements Jumpping {
 63     public Cat() {
 64         // TODO Auto-generated constructor stub
 65     }
 66     
 67     
 68     public Cat(String name, int age) {
 69         super(name, age);
 70         // TODO Auto-generated constructor stub
 71     }
 72 
 73 
 74     @Override
 75     public void jump() {
 76         // TODO Auto-generated method stub
 77         System.out.println("猫可以跳高了");
 78     }
 79 
 80     @Override
 81     public void eat() {
 82         // TODO Auto-generated method stub
 83         System.out.println("猫吃鱼");
 84     }
 85 
 86 }
 87 
 88 //Dog类
 89 public class Dog extends Animal implements Jumpping {
 90     public Dog() {
 91         // TODO Auto-generated constructor stub
 92     }
 93 
 94     
 95     public Dog(String name, int age) {
 96         super(name, age);
 97         // TODO Auto-generated constructor stub
 98     }
 99 
100 
101     @Override
102     public void eat() {
103         // TODO Auto-generated method stub
104         System.out.println("狗啃骨头");
105     }
106 
107     @Override
108     public void jump() {
109         // TODO Auto-generated method stub
110         System.out.println("狗可以跳高了");
111     }
112 
113 }

catAndDog

类和接口的关系

类和类的关系
- 　　继承，只参单继承，但是可以多层继承
类和接口的关系
- 　　实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口的关系
- 　　继承关系，可以单继承，也可以多继承

抽象类和接口的区别

　成员区别
- 　　抽象类变量，常量；有构造方法；有抽象方法，也有非抽象方法
- 接口　　公开静态常量(隐式使用public static final修饰)；公开抽象方法(隐式使用public abstract修饰)
关系区别
- 　　类与类继承，单继承
- 类与接口实现，可以单实现，也可以多实现
- 接口与接口继承，单继承，多继承
设计理念的区别
- 　　抽象类对类抽象，包括属性行为
- 接口对行为抽象，主要是行为

接口存在的必要性：接口的出现解决了什么问题？

　　Java不支持多重继承，一个类只能继承一个父类，事实上，在Java中定义了接口的概念，允许一个类实现多个接口从而实现了比多重继承更强大的能力

课堂案例：运动员和教练

需求：我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，乒乓球相关的人员都需要学习英语。请用所有知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

思路：

定义说英语接口成员方法：说英语();
定义抽象人类成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法，吃饭();
定义抽象教练类，继承人类构造方法：无参，带参；成员方法：教();
定义抽象运动员类，继承人类构造方法：无参，带参；成员方法：学习();
定义具体篮球教练类，继承教练类构造方法：构造方法：无参，带参；成员方法：重写吃饭(){......},重写教(){......}
定义具体乒乓球教练类，继承教练类，实现说英语接口
1. 　　构造方法:无参，带参；成员方法：重写吃饭(){......},重写教(){......}，重写说英语(){......}
定义具体篮球运动员类，继承运动员类构造方法:无参，带参；成员方法：重写吃饭(){......},重写学习(){......}
定义具体乒乓球运动员类，继承运动员类实现说英语接口构造方法:无参，带参；成员方法：重写吃饭(){......},重写学习(){......}，重写说英语
定义测试类，写测试代码

代码如下

  1 //测试类
  2 public class PersonDemo {
  3     public static void main(String[] args) {
  4         //创建对象
  5         PingPangPlayer ppp = new PingPangPlayer();
  6         ppp.setName("邓亚萍");
  7         ppp.setAge(60);
  8         System.out.println(ppp.getName()+","+ppp.getAge());
  9         ppp.eat();
 10         ppp.study();
 11         ppp.speak();
 12         System.out.println("--------");
 13         
 14         BasketBallPlayer bbp = new BasketBallPlayer();
 15         bbp.setName("姚明");
 16         bbp.setAge(35);
 17         System.out.println(bbp.getName()+","+bbp.getAge());
 18         bbp.eat();
 19         bbp.study();
 20     }
 21 }
 22 
 23 //抽象人类
 24 public abstract class Person {
 25     private String name;
 26     private int age;
 27     
 28     public Person() {
 29         // TODO Auto-generated constructor stub
 30     }
 31 
 32     public Person(String name, int age) {
 33         super();
 34         this.name = name;
 35         this.age = age;
 36     }
 37 
 38     public String getName() {
 39         return name;
 40     }
 41 
 42     public void setName(String name) {
 43         this.name = name;
 44     }
 45 
 46     public int getAge() {
 47         return age;
 48     }
 49 
 50     public void setAge(int age) {
 51         this.age = age;
 52     }
 53     public abstract void eat();
 54     
 55 }
 56 
 57 //抽象教练类
 58 public abstract class Coach extends Person {
 59 
 60     public Coach() {
 61         // TODO Auto-generated constructor stub
 62     }
 63 
 64     public Coach(String name, int age) {
 65         super(name, age);
 66         // TODO Auto-generated constructor stub
 67     }
 68     
 69     public abstract void teach();
 70 }
 71 
 72 //抽象运动员类
 73 public abstract class Player extends Person {
 74 
 75     public Player() {
 76         // TODO Auto-generated constructor stub
 77     }
 78 
 79     public Player(String name, int age) {
 80         super(name, age);
 81         // TODO Auto-generated constructor stub
 82     }
 83     
 84     public abstract void study();
 85 }
 86 
 87 
 88 public class BasketballCoach extends Coach {
 89     public BasketballCoach() {
 90         // TODO Auto-generated constructor stub
 91     }
 92 
 93     
 94     public BasketballCoach(String name, int age) {
 95         super(name, age);
 96         // TODO Auto-generated constructor stub
 97     }
 98 
 99 
100     @Override
101     public void teach() {
102         // TODO Auto-generated method stub
103         System.out.println("篮球教练教如何运球和投篮");
104     }
105 
106     @Override
107     public void eat() {
108         // TODO Auto-generated method stub
109         System.out.println("篮球教练吃羊肉，喝羊奶");
110     }
111 
112 }
113 
114 //乒乓球教练类
115 public class PingPangCoach extends Coach implements SpeakEnglish {
116 
117     public PingPangCoach() {
118         // TODO Auto-generated constructor stub
119     }
120     
121     public PingPangCoach(String name, int age) {
122         super(name, age);
123         // TODO Auto-generated constructor stub
124     }
125 
126     @Override
127     public void teach() {
128         // TODO Auto-generated method stub
129         System.out.println("乒乓球教练教如何发球和接球");
130     }
131 
132     @Override
133     public void eat() {
134         // TODO Auto-generated method stub
135         System.out.println("乒乓球教练吃小白菜，喝大米粥");
136     }
137     
138     @Override
139     public void speak() {
140         // TODO Auto-generated method stub
141         System.out.println("乒乓球教练说英语");
142     }
143 
144 }
145 
146 //篮球运动员类
147 public class BasketBallPlayer extends Player {
148     public BasketBallPlayer() {
149         // TODO Auto-generated constructor stub
150     }
151     
152 
153     public BasketBallPlayer(String name, int age) {
154         super(name, age);
155         // TODO Auto-generated constructor stub
156     }
157 
158 
159     @Override
160     public void study() {
161         // TODO Auto-generated method stub
162         System.out.println("篮球运动员学习运球和投篮");
163     }
164 
165     @Override
166     public void eat() {
167         // TODO Auto-generated method stub
168         System.out.println("篮球运动员吃牛肉，喝牛奶");
169     }
170 
171 }
172 
173 
174 //乒乓球运动员类
175 public class PingPangPlayer extends Player implements SpeakEnglish {
176 
177     public PingPangPlayer() {
178         // TODO Auto-generated constructor stub
179     }
180     
181     public PingPangPlayer(String name, int age) {
182         super(name, age);
183         // TODO Auto-generated constructor stub
184     }
185 
186     @Override
187     public void speak() {
188         // TODO Auto-generated method stub
189         System.out.println("乒乓球运动员会说英语");
190     }
191 
192     @Override
193     public void study() {
194         // TODO Auto-generated method stub
195         System.out.println("乒乓球运动员学习如何发球和接球");
196     }
197 
198     @Override
199     public void eat() {
200         // TODO Auto-generated method stub
201         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
202     }
203 
204 }

运动员和教练

课堂案例：USB接口

需求：现有一个标准USB接口，试分析电脑、U盘、USB风扇、鼠标、USB台灯、手机充电线等与接口的关系，并能过代码演示

思路：

　　接口的使用者：电脑

　　接口的实现者：U盘、USB风扇、鼠标、USB台灯、手机充电线

　　1.定义一个Usb接口成员方法：服务();

　　2.定义一个Upan类实现Usb接口，重写服务方法(){...}

　　3.定义一个FengShan类实现Usb接口，重写服务方法(){...}

　　4.定义一个Mouse类实现Usb接口，写服务方法(){...}

　　5.定义一个接口使用者Computer类，成员变量：三个接口；成员方法run(){...}

　　6.测试类测试

代码如下：

 1 package interface2;
 2 //测试类
 3 public class Test {
 4     public static void main(String[] args) {
 5         
 6     /*    Usb usb = new Upan();
 7         usb.service();
 8         usb = new FengShan();
 9         usb.service();
10         usb = new Mouse();
11         usb.service();*/
12         
13         
14         //最终Usb接口的使用者是在电脑上，所以创建一个电脑类去使用Usb接口
15         Computer computer = new Computer();
16         computer.usb1 = new Upan();
17         computer.usb2 = new FengShan();
18         computer.usb3 = new Mouse();
19         computer.run();
20     }
21 }
22 
23 
24 //Usb接口
25 public interface Usb {
26     //提供一个服务的方法
27     void service();
28 }
29 
30 
31 //Upan类
32 public class Upan implements Usb {
33     @Override
34     public void service() {
35         // TODO Auto-generated method stub
36         System.out.println("U盘连接电脑成功，开始工作");
37     }
38 }
39 
40 //风扇类
41 public class FengShan implements Usb {
42     @Override
43     public void service() {
44         // TODO Auto-generated method stub
45         System.out.println("风扇连接电脑成功，开始工作");
46     }
47 }
48 
49 
50 //鼠标类
51 public class Mouse implements Usb {
52     @Override
53     public void service() {
54         // TODO Auto-generated method stub
55         System.out.println("鼠标连接电脑成功，开始工作");
56     }
57 }
58 
59 //电脑类
60 public class Computer {
61     Usb usb1;
62     Usb usb2;
63     Usb usb3;
64     void run() {
65         if(usb1!=null) {
66             usb1.service();
67         }
68         if(usb2!=null) {
69             usb2.service();
70         }
71         if(usb3!=null) {
72             usb3.service();
73         }
74     }
75 }

USB接口案例

接口回调原理

接口回调：先有接口的使用者(Computer)，后有接口的实现(Usb接口的三个实现类)

posted @ 2020-10-19 08:59 单sir 阅读(138) 评论(0) 收藏举报

刷新页面返回顶部

单sir

只争朝夕--不负韶华