第十一天接口

接口"/>

第十一天接口

接口：interface

1、语句定义格式：接口使用关键：interface表示

interface 接口名{}

2、接口是如何实现的呢？

接口不能直接实例化

那么接口如何去表示呢？

这里需要另外一个关键字供其他类实现该接口：implements

使用多态的形式进行实现，由具体的子类进行实例化,其实这是多态的一种，叫做接口多态。

3、也可以用一个抽象类去实现

现在我们将猫狗案例加入钻火圈的功能改写。

到目前为止，我们学过了三种多态的表现实现：

1、具体的类中的多态 （最后才是具体类的多态）

2、抽象类中的多态 （其次是抽象多态）

3、接口中的多态 （今后大数据开发最常见的是接口多态）

abstract class Animal{private String name;private int age;
public Animal(){}public Animal(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public abstract void eat();
}
class Cat extends Animal{public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
//定义一个钻火圈接口
interface ZuanHuoQuan{public abstract void zuanHuo();
}
class TrainCat extends Cat implements ZuanHuoQuan{@Overridepublic void zuanHuo() {System.out.println("猫钻火圈");}
}
public class InterfaceDemo1 {public static void main(String[] args) {Cat c = new TrainCat();TrainCat tc=(TrainCat) c;//这里需要向下转型tc.eat();tc.zuanHuo();}
}

接口中成员的特点：

成员变量：

只能是常量，并且是静态的

JVM在真正运行之前会自动补齐修饰符：public static final

建议：在学习阶段手动补齐，在开发阶段，省略不写。

构造方法：

接口中没有构造方法。

成员方法：

接口中的方法只能是抽象方法，没有方法体，连大括号都没有

JVM在真正运行之前会自动补齐修饰符：public abstract

建议：在学习阶段手动补齐，在开发阶段，省略不写。

注意：

1、当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法

2、当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现

3、接口与接口之间什么关系呢？

interface Inter {public static final int a = 10;/*Inter(){};public void sun(){System.out.println("1");}会报错因为接口抽象方法不能带有主体*/public abstract void fun();public abstract void fun2();
}//虽然接口中没有构造方法，但是多态初始化的时候会先初始化父类再初始化子类
//这里其实继承了一个父类
//java中所有的类都有一个父类叫做Object
//每一个class都有Object作为父类
//那么所有继承Object类的子类都拥有了父类Object类中的方法
class Demo extends Object implements Inter {@Overridepublic void fun() {System.out.println("Demo类中实现玩游戏方法");}@Overridepublic void fun2() {System.out.println("Demo类中实现玩游戏方法2");}abstract class Demo2 implements Inter {@Overridepublic void fun() {System.out.println("抽象类中实现玩游戏方法");}}
}public class InterfaceDemo2 {public static void main(String[] args) {Inter i = new Demo();System.out.println(i.a);i.fun();i.fun2();//        java: 无法为最终变量a分配值
//        i.a = 100;}
}

类与类，类与接口，接口与接口的关系

类与类：

存在继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承

类与接口：

实现关系，可以是单实现，也可以是一次性实现多个接口，也可以在继承一个类的同时，实现多个接口

接口与接口：

存在的是继承关系，可以进行单继承，也可以进行多继承

interface inter2{}
interface inter3{}
interface inter4 extends inter2,inter3{}
class Demo3 extends Object implements inter2,inter3{}
public class InterfaceDemo3 {
}

猫狗案例：加入跳高的功能

分析：

猫：

属性：姓名，年龄

行为：吃饭，睡觉

狗：

属性：姓名，年龄

行为：吃饭，睡觉

由于猫和狗存在共性，所以我们提取出来到一个新的类中

动物：（抽象类）

属性：姓名，年龄

行为：吃饭(),睡觉()

猫：继承自动物

狗：继承自动物

由于跳高是一个额外的功能，不是动物特有的，所以我们利用接口的方式去定义

接口：

跳高

部分的猫：实现接口

部分的狗：实现接口

abstract class Animal4{private String name;private int age;
public Animal4(){}public Animal4(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public abstract  void eat();public abstract  void sleep();}
class Cat4 extends Animal4{public Cat4() {}public Cat4(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫趴着睡");}}
class Dog4 extends Animal4{public Dog4() {}public Dog4(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("狗吃肉");}@Overridepublic void sleep() {System.out.println("狗圈着睡");}//定义部分会跳高的猫interface Jump{public abstract void jump();}
}
//定义部分会跳高的猫
class JumpCaat extends Cat4 implements Dog4.Jump{public JumpCaat() {}public JumpCaat(String name, int age) {super(name, age);}@Overridepublic void jump() {System.out.println("猫被训练的会跳高");}
}
//定义部分会跳高的狗
class JumpDog extends Dog4 implements Dog4.Jump{public JumpDog() {}public JumpDog(String name, int age) {super(name, age);}@Overridepublic void jump() {System.out.println("狗被训练的会跳高");}
}
public class InterfaceDemo4 {public static void main(String[] args) {//创建一个不会跳高的猫Animal4 a1= new Cat4("小白",2);a1.eat();a1.sleep();//创建一个会跳高的猫Cat4 cat4=new JumpCaat("小白",2);JumpCaat jumpCaat=(JumpCaat) cat4;jumpCaat.eat();jumpCaat.jump();jumpCaat.sleep();//同理可以创建一个会跳高的狗}
}

老师和学生案例,加入抽烟的额外功能

分析：

老师：

属性：姓名，年龄

行为：吃饭，睡觉

学生：

属性：姓名，年龄

行为：吃饭，睡觉

由于老师和学生有着共性内容，提取出来一个抽象类

人：（抽象类）

属性：姓名，年龄

行为：吃饭(),睡觉()

由于不是所有的老师和学生都抽烟，只有部分的老师和学生会

所以，我们将抽烟定义为一个接口

部分的老师：实现抽烟接口

部分的学生：实现抽烟的接口

abstract class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public abstract void eat();public void sleep() {System.out.println("躺着睡");}
}class Teacher extends Person {public Teacher() {}public Teacher(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("老师吃饭");}
}class Student extends Person {public Student() {}public Student(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("学生吃面");}
}interface Smoke {public abstract void smoke();
}class SmokeTeacher extends Teacher implements Smoke {public SmokeTeacher() {}public SmokeTeacher(String name, int age) {super(name, age);}@Overridepublic void smoke() {System.out.println("老师抽烟");}
}class SmokeStudent extends Student implements Smoke {public SmokeStudent() {}public SmokeStudent(String name, int age) {super(name, age);}@Overridepublic void smoke() {System.out.println("学生抽烟");}
}public class InterfaceDemo5 {public static void main(String[] args) {Person p1=new Teacher("小明",32);p1.eat();p1.sleep();Teacher teacher=new SmokeTeacher("小明",33);SmokeTeacher smokeTeacher=(SmokeTeacher) teacher;smokeTeacher.smoke();smokeTeacher.eat();smokeTeacher.sleep();}
}

将来我们更多的面向接口开发

将代码进行分类开发，会提高我们开发效率和排错效率

通常情况下，常见会4层：

bean: 一般存放的是将来要new的实体类

controller: 一般是数据的入口类

dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的

service: 一般在这里面放的是接口，和实现类。

教练和运动员案例

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

具体内容见idea Days12SportDemo