Java_笔记_抽象类_接口
一、抽象类
1.抽象类
1）定义：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。
2）格式：
public abstract class 类名{}
3）作用：
抽取共性时，无法确定方法体，就把方法定义为抽象的。
强制让子类按照某种格式重写。
抽象方法所在的类，必须是抽象类。
2.抽象方法
1）定义：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容不一样，
所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
2）格式：
public abstract 返回值类型 方法名（参数列表）;
3）代码：
public abstract class Person {
public abstract void work();
}
3.抽象类和抽象方法的注意事项
1）抽象类不能实例化。
2）抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
父类不一定是抽象的。父类里有抽象方法，这个父类才是抽象类。
3）可以有构造方法。
作用：当创建子类对象时，给属性进行赋值。
4）抽象类的子类：重写抽象类中的所有抽象方法（推荐）；或变成抽象类。
4.练习：
编写带有抽象类的标准Javabean类
青蛙frog 属性：名字，年龄 行为：吃虫子，喝水
狗dog 属性：名字，年龄 行为：吃骨头，喝水
绵羊sheep 属性：名字，年龄 行为：吃草，喝水
代码：
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 void drink() {
System.out.println("动物在喝水");
}
public abstract void eat();
}
public class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
public class Frog extends Animal {
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
}
public class Sheep extends Animal {
public Sheep() {
}
public Sheep(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("绵羊在吃草");
}
}
public class Test {
public static void main(String[] args) {
//创建对象
Frog f = new Frog("来福", 1);
System.out.println(f.getName() + "," + f.getAge());//来福,1
f.drink();//动物在喝水
f.eat();//青蛙在吃虫子
}
}
二、接口：一种规则。
1.接口的理解
public interface 运输{
}
public void 搬家（运输的接口 c）{
}
2.接口和抽象类的异同
1）抽象类更多用于父类中。
2）接口是一种规则，是对行为的抽象。
3.接口的定义
1）接口用关键字interface来定义。
2）public interface 接口名{}
4.接口的使用
1）接口不能实例化。
2）接口和类之间是实现关系，通过implements关键字表示。
public class 类名 implements 接口名{}
3）接口的子类（实现类）
重写接口中的所有抽象方法（推荐）；或变成抽象类。
4）注意1：
接口和类的实现关系，可以单实现，也可以多实现。
public class 类名 implements 接口名1，接口名2{}
5） 注意2：
实现类可以在继承一个类的同时，实现多个接口。
public class 类名 extends 父类 implements 接口名1，接口名2{}
5.练习：
编写带有接口和抽象类的标准Javabean类
青蛙 属性：名字，年龄 行为：吃虫子，蛙泳
狗 属性：名字，年龄 行为：吃骨头，汪式游泳
兔子 属性：名字，年龄 行为：吃胡萝卜
代码：
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();
}
public class Dog extends Animal implements Swim {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void swim() {
System.out.println("汪汪游泳");
}
}
public class Frog extends Animal implements Swim {
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
@Override
public void swim() {
System.out.println("青蛙在蛙泳");
}
}
public class Rabbit extends Animal {
public Rabbit() {
}
public Rabbit(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("兔子在吃胡萝卜");
}
}
public interface Swim {
public abstract void swim();
}
public class Test {
public static void main(String[] args) {
//创建青蛙的对象
Frog f = new Frog("绿豆", 2);
System.out.println(f.getName() + "," + f.getAge());//绿豆,2
f.eat();//青蛙在吃虫子
f.swim();//青蛙在蛙泳
//创建兔子的对象
Rabbit r = new Rabbit("白玉", 3);
System.out.println(r.getName() + "," + r.getAge());//白玉,3
r.eat();//兔子在吃胡萝卜
}
}
6.接口中成员的特点
1）成员变量：
只能是常量。
默认修饰符：public static final。
2）构造方法：无。
接口不能创建对象，也不需要给子类的成员变量赋值。
3）成员方法：
只能是抽象方法。
默认修饰符：public abstract。
7.接口和类之间的关系：
1）类和类的关系
继承关系，只能单继承，不能多继承，但是可以多层继承。
2）类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
细节：如果实现多个接口，必须重写里面所有抽象方法。
3）★接口和接口的关系
继承关系，可以单继承，也可以多继承。
细节：如果实现类实现了最下面的子接口，就需要重写这个体系中所有的抽象方法。
8.练习：
编写带有接口和抽象类的标准Javabean类：
现有乒乓球、篮球的运动员和教练。
乒乓球相关人员需要学习英语。
分析具体类、抽象类、接口。
乒乓球运动员：姓名，年龄，学打乒乓球，说英语
篮球运动员：姓名，年龄，学打篮球
乒乓球教练：姓名，年龄，教打乒乓球，说英语
篮球教练：姓名，年龄，教打篮球
代码：
public abstract class Athlete extends Person {
public Athlete() {
}
public Athlete(String name, int age) {
super(name, age);
}
public abstract void study();
}
public class BasketballCoach extends Coach {
public BasketballCoach() {
}
public BasketballCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("篮球教练在教篮球");
}
}
public class BasketballPlayer extends Athlete {
public BasketballPlayer() {
}
public BasketballPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("篮球运动员在学习打篮球");
}
}
public abstract class Coach extends Person {
public Coach() {
}
public Coach(String name, int age) {
super(name, age);
}
public abstract void teach();
}
public interface English {
public abstract void speakEnglish();
}
//不让外界直接创建人的对象。
//因为直接创建顶层父类人的对象是没有意义的。
//所以写成抽象的。
public 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 class PingpongCoach extends Coach implements English {
public PingpongCoach() {
}
public PingpongCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("乒乓球教练在教乒乓球");
}
@Override
public void speakEnglish() {
System.out.println("乒乓球教练在说英语");
}
}
public class PingpongPlayer extends Athlete implements English {
public PingpongPlayer() {
}
public PingpongPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("乒乓球运动员在学习乒乓球");
}
@Override
public void speakEnglish() {
System.out.println("乒乓球运动员在说英语");
}
}
public class Test {
public static void main(String[] args) {
//创建运动员或教练的对象
PingpongCoach c = new PingpongCoach("A", 30);
System.out.println(c.getName() + "," + c.getAge());//A,30
c.teach();//乒乓球教练在教乒乓球
c.speakEnglish();//乒乓球教练在说英语
}
}
9.JDK8开始接口中新增的方法
1）JDK7以前：接口中只能定义抽象方法。
2）JDK8新特性：接口中可以定义有方法体的方法。
1、默认方法：
允许在接口中定义默认方法，需要使用关键字default修饰。
作用：解决接口升级的问题。
接口中默认方法的定义格式：
格式：public default 返回值类型 方法名（参数列表）{}
范例：public default void show(){}
接口中默认方法的注意事项：
默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字。
public可以省略，default不能省略。
如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写。
2、静态方法
允许在接口中定义静态方法，需要用static修饰。
接口中静态方法的定义格式：
格式：public static 返回值类型 方法名（参数列表）{}
范例：public static void show(){}
接口中静态方法的注意事项：
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用。
public可以省略，static不能省略。
3）JDK9新特性：接口中可以定义私有方法。
1、普通的私有方法，给默认方法服务的
格式1：private 返回值类型 方法名（参数列表）{}
范例1：private void show(){}
2、静态的私有方法，给静态方法服务的
格式2：private static 返回值类型 方法名（参数列表）{}
范例2：private static void method(){}
10.接口的应用
1）接口代表规则，是行为的抽象。
想要让类拥有一个行为，就让这个类实现对应的接口。
2）接口多态：方法的参数是接口时，可传递接口所有实现类的对象。
接口类型 j = new 实现类对象（）；
11.适配器设计模式
1）设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解，保证代码可靠性、程序的重用性。
简单理解：设计模式就是各种套路。
2）适配器设计模式目的：解决接口与接口实现类之间的矛盾问题。
3）适配器设计模式时机：当一个接口中抽象方法过多，但是只需要使用其中一部分的时候。
4）书写步骤：
编写中间类XXXAdapter，实现对应的接口。
对接口中的抽象方法进行空实现。
让真正的实现类继承中间类，并重写需要用的方法。
为避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰。