黑马程序员全套Java教程_Java基础教程_抽象类与接口（二十）

1、抽象类

1.1 抽象类概述

• 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

1.2 抽象类的特点

• （1）抽象类和抽象方法必须使用abstract关键字修饰，如：
  public abstract class 类名{}
  public abstract void eat();
  （2）抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类。
  （3）实例化的方式：参照多态的方式，通过子类对象实例化，这叫抽象类多态。
  （4）抽象类子类的特点：要么重写抽象类中的所有抽象方法，要么本身同为抽象类。

1.3 抽象类的成员特点

• （1）成员变量：可以是变量，也可以是常量
  （2）构造方法：有构造方法，但是不能实例化。构造方法用于子类访问父类时数据的初始化。
  （3）成员方法
  可以有抽象方法：限定子类必须完成某些动作。
  也可以有非抽象方法：提高代码复用性。

面试题：以下关于抽象的类描述正确的是？

（1）抽象类可以通过new关键字直接实例化。
错误。抽象类不能直接通过new实例化，抽象类实例化要按照多态的方式，通过子类对象实例化，这叫抽象类多态。虽然抽象类有构造方法，但构造方法起到的作用是用于子类访问父类时数据的初始化。
（2）有抽象方法的类一定是抽象类。
正确。“子不教，父之过”。
（3）抽象类没有构造方法。
错误。其构造方法的用于子类访问父类数据时的初始化。
（4）抽象类必须提供抽象方法。
错误。有抽象类中不一定有抽象方法。

案例：猫和狗

• 需求：请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试
• 思路及代码实现：（对比猫和鱼的多态案例，代码有变化的只有父类Animal加了abstract关键字，以及父类的eat方法删除了方法体加了abstract关键字）：
  （1）定义动物类（Animal）
  成员变量：姓名，年龄
  构造方法：无参，带参
  成员方法：get/set方法，吃饭();

public abstract class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal() {
    }

    public abstract void eat();
。。。。。。。。。。。。略set/get方法。。。。。。。。。。。。。。
}

（2）定义猫类（Cat），继承动物类
构造方法：无参，带参
成员方法：重写吃放(){…}

public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    public Cat() {
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

（3）定义狗类（Dog），继承动物类
构造方法：无参，带参
成员方法：重写吃放(){…}

public abstract class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    public Dog() {
    }

    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

（4）定义测试类（AnimalDemo），写代码测试

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setName("Jerry");
        a.setAge(1);
        a.eat();
        Animal b = new Cat("CatKing",2);
        b.eat();
    }
}

2、接口

2.1 接口概述

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

2.2 接口的特点

• （1）接口定义的方式：用关键字interface修饰，如：public interface 接口名{}
  （2）类实现接口的方式：用implements关键字表示实现，如：public class 类名 implements 接口名{}
  （3）接口实例化的方式：通过实现类对象实例化，这叫接口多态。
  （4）接口的实现类，要么重写类中所有的抽象方法，要么本身同为抽象类。

2.3 基于抽象类和接口，得出的多态的形式和前提总结

• 多态的形式：具体类多态，抽象类多态，接口多态
• 多态的前提：
  （1）有继承或者实现关系；
  （2）有方法重写；
  （3）有父（类/接口）引用指向（子/实现）类对象。

2.4 接口的成员特点

• （1）成员变量：只能是常量，默认修饰符为：public static final，所以接口中的变量也称之为常量。
  （2）构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，没有具体存在。而其实现类可以有构造方法，是因为每个类都有一个共同的父类Object类。
  （3）成员方法：只能是抽象方法，默认修饰符：public abstract。
  （4）关于接口中的方法，JDK8和JDK9中有一些新的特性，后面再解释

案例：猫和狗

• 需求：对猫和狗进行训练，他们就可以调高了，这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例。
• 思路：
  （1）定义接口（Jumpping）
  成员方法：跳高();

public interface Jumpping {

    public abstract void jumpping();
}

（2）定义抽象动物类（Animal）
成员变量：姓名，年龄；
构造方法：无参，带参；
成员方法：get/set方法，吃饭()；

public abstract class Animal {
    private String name;
    private int age;

    public abstract void eat();

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    .............................

（3）定义猫类（Cat），继承动物类，实现跳高接口
构造方法：无参，带参；
成员方法：重写吃饭方法(){…}，重写跳高方法(){…}

public class Cat extends Animal implements Jumpping{

    @Override
    public void jumpping() {
        System.out.println("猫跳");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
}

（4）定义狗类（Dog），继承动物类，实现跳高接口
构造方法：无参，带参；
成员方法：重写吃饭方法(){…}，重写跳高方法(){…}

public class Dog extends Animal implements Jumpping{

    @Override
    public void jumpping() {
        System.out.println("狗跳");
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
}

（5）定义测试类（AnimalDemo），写代码测试

public class AnimalDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jumpping();
        System.out.println("----------");

        Animal a = new Cat();
        a.setName("Jerry");
        a.setAge(3);
        a.eat();
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
//        a.jump不可使用
        System.out.println("----------");

        a = new Cat("Jerry", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        System.out.println("----------");

        Cat c = new Cat("Tom", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        j.jumpping();
    }
}

2.5 类和接口的关系

• 类和类的关系：继承关系，只能单继承，不能多继承，但是可以多层继承。
• 类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
• 接口和接口的关系：继承关系，可以单继承，也可以多继承。

2.6 抽象类和接口的区别

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

//抽象类
public abstract class Door{
	public abstract void open();
	public abstract void close();
}

//接口
public interface Door{
	void open();
	void close();
}

随着时代的发展，有些门具备了警报的功能，有两种实现方式：
（1）将三种方法都放在抽象类里面，但是这样一来，所有继承抽象类的子类都具备了警报功能，但问题是并不是所有的门都有警报功能。
（2）将三种方法都放在接口里面，需要报警功能的类就实现这个接口中方法，但问题是这个时候要连带实现方法中的open方法和close方法，也许这个类根本就不具备开门关门的功能（比如火灾报警器）。
由此可见两种方式都不好。

//抽象类
public abstract class Door{
	public abstract void open();
	public abstract void close();
	public abstract void alarm();
}

//接口
public interface Door{
	void open();
	void close();
	void alarm();
}

怎么解决呢？我们知道，open和close是门必须附带的功能， 而alarm是属于附加的行为，所以最简单的方法就是将alarm单独设计为一个接口，而将open和close放到一个抽象类里面，将来我们的报警门继承抽象类的门并且实现报警接口就可以了，如下：

public interface Alarm{
	void alarm();
}

public abstract class Door{
	public abstract void open();
	public abstract void close();
}

public class AlarmDoor extends Door implements Alarm{
	public void open(){
		.......
	}
	public void close(){
		.......
	}
	public void alarm(){
		.......
	}
}

面试题：以下对接口描述错误的有？

• 接口没有提供构造方法。
  正确。接口没有构造方法，因为接口主要是对行为进行抽象的，没有具体存在。
• 接口中的属性默认使用public static final修饰。
  正确。接口的成员变量默认修饰符为public static final；成员方法只能是抽象方法，默认修饰符为public abstract。
• 接口不允许多继承。
  错误。接口和接口之间是可以多继承的。
• 接口中的方法默认使用public abstract修饰。
  正确。

案例：运动员和教练

• 需求：我们现在有乒乓球和篮球运动员，乒乓球和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。
• 此类问题的分析方法：从具体到抽象，因为我们最终要提取出共性的内容。
  在本题中，具体的事物有：乒乓球运动员、篮球运动员、乒乓球教练、篮球教练，他们都是具体的类。
  运动员和教练这两个整体是有自己的共性的，所以我们提取出运动员和教练两个抽象类，他们分别有学习()和教()这两个抽象方法。教练和运动员也是有共性的，提取出人这一个类，他有吃饭这一抽象方法。
  另外跟乒乓球相关的人员都需要学习英语，所以我们定义一个学习英语的接口，让乒乓球相关的具体类去实现这个接口即可。
  
• 此类问题的实现：从抽象到具体；使用：使用的是具体类的对象
  实现思路：
  （1）定义说英语接口
  成员方法：说英语()。

public interface SpeakEnglish {
    void speakEnglish();
}

（2）定义抽象人类
成员变量：姓名，年龄；
构造方法：无参，带参；
成员方法：get/set方法，吃饭()。

public abstract class Person {
    private String name;
    private int age;

    public abstract void eat();

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    .............................................

（3）定义抽象教练类，继承人类
构造方法：无参，带参；
成员方法：教()。

public abstract class Coach extends Person{

    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

（4）定义抽象运动员类，继承人类
构造方法：无参，带参；
成员方法：学习()。

public abstract class Athletes extends Person {

    public abstract void study();

    public Athletes() {
    }

    public Athletes(String name, int age) {
        super(name, age);
    }
}

（5）定义具体篮球教练类，继承教练类
构造方法：无参，带参；
成员方法：重写吃饭(){…}，重写教(){…}。

public class BasketballCoach extends Coach{
    @Override
    public void eat() {
        System.out.println("篮球教练吃大篮球");
    }

    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("教练开始教篮球");
    }
}

（6）定义具体乒乓球教练类，继承教练类，实现说英语接口
构造方法：无参，带参；
成员方法：重写吃饭(){…}，重写教(){…}，重写说英语(){…}。

public class PingpongCoach extends Coach implements SpeakEnglish {
    @Override
    public void eat() {
        System.out.println("乒乓球教练吃大乒乓球");
    }

    public PingpongCoach() {
    }

    public PingpongCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练说英语");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练开始教乒乓球");
    }
}

（7）定义具体篮球运动员类，继承运动员类
构造方法：无参，带参；
成员方法：重写吃饭(){…}，重写教(){…}。

public class BasketballPlayer extends Athletes{
    @Override
    public void eat() {
        System.out.println("篮球运动员吃小篮球");
    }

    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("运动员打篮球");
    }
}

（8）定义具体乒乓球教练类，继承教练类，实现说英语接口
构造方法：无参，带参；
成员方法：重写吃饭(){…}，重写教(){…}，重写说英语(){…}。

public class PingpongPlayer extends Athletes implements SpeakEnglish {
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃小乒乓球");
    }

    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("乒乓球运动员说英语");
    }
}

（9）定义测试类，写代码测试

public class PersonDemoTest {
    public static void main(String[] args) {
        PingpongCoach pc = new PingpongCoach("pc",22);
        pc.eat();
        pc.speakEnglish();
        pc.teach();
        PingpongPlayer pp =new PingpongPlayer("pp",11);
        pp.eat();
        pp.speakEnglish();
        pp.study();

        BasketballCoach bc = new BasketballCoach("bb",23);
        bc.eat();
        bc.teach();
        BasketballPlayer bp = new BasketballPlayer("bp",13);
        bp.eat();
        bp.study();
    }
}

3、面向对象中的形参和返回值

1.1 类名作为形参和返回值

• （1）方法的形参是类名，其实需要的是该类的对象
  （2）方法的返回值是类名，其实返回的是该类的对象

1.2 抽象类名作为形参和返回值

• （1）方法的形参是抽象类名，其实需要的是该抽象类的子类对象。
  （2）方法的返回值是抽象类名，其实返回的是该抽象类的子类对象。

1.3 接口名作为形参和返回值

• （1）方法的参数是接口名，其实需要的是该接口的实现类对象。
  （2）方法的返回值是接口名，其实返回的应该是接口的实现类对象。