JAVA学习笔记XV --接口

接口

1.1 接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
Java中的接口更多的是体现在对行为的抽象，规范实力类

1.2 接口的特点

1、接口用关键字interface 接口名{}
public interface 接口名{}
2、类实现接口用implements表示
public class 类名 implements 接口名{}
3、接口不能实例化
接口实例化方法：通过多态的形式，实现类对象实例化，该方法叫接口多态
多态的形式有：具体类多态，抽象类多态，接口多态
多态的前提：有继承或者实现关系；有方法重写；有父(类/接口)指向(子/实现)类对象
4、接口的实现类
要么重写接口中的所有抽象方法
要么是抽象类

1.3 接口的成员特点

1、成员变量
只能是常量
默认修饰符：public static final
2、构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，没有具体存在
如果一个类没有父类，默认继承总类Object类
3、成员方法
只能是抽象方法
默认修饰符：public abstract
// 定义一个接口
public interface Inter {
// 访问修饰符public 为灰色意思是接口中的成员变量只能是常量
// 默认修饰符public static final
public int num = 10;
public final int num1 = 20;
// public static final int num3 = 30等同于int num = 30;
int num3 = 30;
// 接口中没有构造方法public Inter(){} 接口对行为抽象，不具体存在
// 接口里面不能有非抽象方法，不能有方法体public void show(){ }
public abstract void show();
// 接口的成员方法默认为抽象方法带有public abstract 修饰符
void method(); }
// 定义一个实现类继承接口
// 创建实现类实现接口等价于 public class InterImpl extends Object implements Inter
public class InterImpl implements Inter {
// Object是所有类的父类，每个类都将Object作为超类，定义一个接口默认继承Object类
// 虽然接口类没有直接构造函数,但是默认继承Object类所以子类可以访问父类初始数据
public InterImpl(){ _super(); }
@Override
public void show() { }
@Override
public void method() { } }
// 测试类
public class InterfaceDemo {
public static void main(String[] args) {
// 多态的方式实现接口
Inter inter = new InterImpl();
System._out.println(_inter._num);
// inter.num1 = 40; 报错：因为接口类的num1被final修饰
System.out.println(_inter._num1);
System.out.println(_Inter._num); } }

案例：猫和狗

需求：对猫和狗进行训练，训练后他们就可以跳高，加入了跳高功能
请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试
// 定义一个接口
public interface Jumpping {
// 接口中只能含有常量或者不带方法体的抽象方法，默认修饰public abstract
public abstract void jump(); }
// 定义一个公共抽象类
public 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(); }
// 定义一个子类Cat继承Animal的eat()方法 并实现接口Jumpping的jump()方法
public class Cat extends Animal implements Jumpping{
// 继承父类的构造方法一键生成无参和带参方法
public Cat() { }
public Cat(String name, int age) { super(name, age); }
@Override
public void eat() { System._out.println(“猫吃鱼”); }
@Override
public void jump() { _System._out.println(“猫跳高”); } }
// 定义测试类
public class AnimalDemo {
_public static void main(String[] args) {
// 创建对象，调用方法，使用多态的父类引用指向子类对象
// 接口多态只能调接口的方法
Jumpping jumpping = new Cat();
jumpping.jump();
System._out.println(“————————-“);
// 抽象类多态只能调抽象类的方法
Animal animal = new Cat();
animal.eat();
animal.setName(“奥利”);
animal.setAge(_1);
System._out.println(_animal.getName() + “,” + animal.getAge());
animal.eat();
// animal.jump(); 报错:因为Animal父类中没有跳高的方法，跳高的方法在接口类中
System._out.println(“————————“);
Animal animal1 = new Cat(“胖胖”, 1);
System.out.println(_animal.getName() + “,” + animal.getAge());
animal.eat();
System._out.println(“————————“);
// 使用具体的子类（实现类）同时实现父类的方法和借口类的方法
Cat cat = new Cat();
cat.setName(“老虎”);
cat.setAge(_3);
System._out.println(_cat.getName() + “,” + cat.getAge());
cat.eat();
cat.jump(); } }_

1.4 类和接口的关系

1、类和类关系
继承关系，只能单继承，但是可以多层继承
// 类和类的关系:
public class demo1 extends demo2{ }
public class demo2 extends demo3{ }
public class demo1 extends demo3{ }
2、类和接口的关系
实现关系，可以单实现，也可以多实现，还可以继承一类的同时实现多个接口
// 类和接口的关系:
public interface Inter1 { }
public interface Inter2 { }
public interface Inter3 { }
// 类同时实现多个接口
public class InterImpl implements Inter1,Inter2,Inter3{ }
// 类继承一类的同时实现多个接口
public class InterImpl extends Object implements Inter1,Inter2,Inter3{ }
3、接口和接口的关系
继承关系，可以单继承，也可以多继承
// 接口和接口的关系:
public interface Inter1 { }
public interface Inter2 { }
public interface Inter3 { }
// 单继承
public interface Inter3 extends Inter1{ }
// 多继承
public interface Inter3 extends Inter1,Inter2,Inter3{ }

1.5 抽象类和接口的区别

1、成员区别：
抽象类： 常量，变量；有构造方法，有抽象方法，也有非抽象方法
接口： 常量；抽象方法
2、关系区别：
类与类 继承，单继承
类与接口 实现，可以单实现，可以多实现
接口与接口 继承，单继承，多继承
3、设计理念区别：
抽象类 对类抽象，包括属性、行为
接口 对行为抽象，主要是行为
案例：门和警报的例子
门：都有open()和close()两个动作，这个时候，我们可以分别使用抽象类和接口来定义这个抽象概念

// 抽象类 // 接口
public abstract class Door { public interface Door{
public abstract void open(); void open();
public abstract void close(); void close();
// 门要添加报警功能，但添加后所有子类都添加 // 添加报警功能，在接口层实现，但是会和其他方法一起实现
public abstract void alarm(); } void alarm(); }

//两种添加额外方法都不好，所以将报警alarm()；单独放在接口类，去调用实现
// 含有alarm()；的接口类
public interface Alram(){ void alarm(); }
// 门的抽象类含有open()和close()方法
public abstract class Door{
public abstract void open();
public abstract void close(); }
// 定义一个含有报警门AlarmDoor的类继承父类Door的方法并单独实现接口类报警方法
public class AlarmDoor extends Door implements Alarm{
public void open(){…}
public void close{…}
public void alarm{….} }
Tips：抽象类是对事物的抽象，接口是对行为的抽象

案例：运动员和教练

需求：我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球人员需要学习英语，利用所学知识先分析，有那些类，哪些抽象类，哪些接口，并用代码实现。
分析：从具体到抽象
具体类 具体类
乒乓球运动员 篮球运动员 乒乓球教练 篮球教练

抽象类 接口 抽象类
运动员 学习英语 教练
学习()；方法 教()；方法

    抽象类<br />     人<br />     姓名，年龄<br />   吃饭();<br />实现：从抽象到具体<br />使用：使用的是具体的类的对象

思路：
① 定义说英语接口 成员方法：说英语();
② 定义抽象人类 成员变量：姓名，年龄，构造方法：无参，带参；成员方法：get/set方法，吃饭();
③ 定义抽象教练类，继承人类 构造方法：无参，带参；成员方法：教();
④ 定义抽象运动员类，继承人类 构造方法：无参，带参；成员方法：学习();
⑤ 定义抽象乒乓球教练类，继承教练类，实现说英语接口
构造方法：无参，带参；成员方法：重写吃饭(); 重写教();
⑥ 定义抽象篮球教练类，继承教练类
构造方法：无参，带参；成员方法：重写吃饭(); 重写教();重写英语();
⑦ 定义抽象篮球运动员类，继承运动员类
构造方法：无参，带参；成员方法：重写吃饭(); 重写教();
⑧ 定义抽象乒乓运动员类，继承运动员类，实现说英语接口
构造方法：无参，带参；成员方法：重写吃饭(); 重写学习();重写英语();
⑨ 定义测试类