第九章 抽象类与接口

抽象类(重点)

抽象类：是一种特殊的父类

特殊在哪里呢?

内部允许编写抽象方法

什么是抽象方法呢?

当我们将共性的方法，抽取到父类之后，发现这个方法在父类中无法给出具体明确(描述不清楚)，而且这个方法，还是子类必须要有的方法，就可以设计为抽象方法

abstract class Animal{
    public abstract void eat();
}
class Cat extends Animal{

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

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

抽象方法(重点)

​ 抽象方法：将共性的行为(方法)抽取到父类之后，由于每个子类执行的内容是不一样的，所以，在父类中不能确定具体的方法体，该方法就可以定义为抽象方法

​ 抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象类和抽象方法的定义格式（重点）

抽象方法的定义格式：

public abstract 返回值类型 方法名(参数列表);

	//摆烂：不去写明确的方法体
    public abstract void eat();

抽象类的定义格式:

public abstract class 类名{}

public abstract class Animal{
    //摆烂：不去写明确的方法体
    public abstract void eat();
}

抽象类和抽象方法的注意事项（重点）

抽象类不能实例化

• 如果抽象类允许创建对象，就可以调用内部没有方法体的抽象方法了

可以有构造方法

• 交给子类，通过super进行访问

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 普通方法可以让子类继承继续使用

抽象类的子类

• ​ 要么重写抽象类中的所有抽象方法

• ​ 要么是抽象类

abstract class A{
    public abstract void showA();
}
abstract class B extends A{

    @Override
    public void showA() {

    }
    public abstract void showB();
}
class C extends B{

    @Override
    public void showB() {

    }
}

abstract关键字的冲突(了解)

final:被abstract修饰的方法，强制要求子类重写，被final修饰的方法子类不能重写

private:被abstract修饰的方法，强制要求子类重写，被private修饰的方法子类不能重写

static：被static修饰的方法可以类名调用，类名调用抽象方法没有意义

练习：编写带有抽象类的标准Javabean类

总结

1.抽象类的作用是什么样的？

抽取共性时，无法确定方法体，就把方法定义为抽象的

强制让子类按照某种格式重写

抽象方法所在的类，必须是抽象类

2.抽象类和抽象方法的格式？

public abstract 返回值类型 方法名(参数列表);

public abstract 类名{}

3.继承抽象类需要注意些什么？

要么重写抽象类中的所有抽象方法

要么是抽象类

接口（重点）

接口的定义与特点（重点）

接口的格式如下:

//接口用关键字interface来定义
public interface 接口名{
	//常量
	//抽象方法（常用）
}

public interface InterfaceDemo{
	//接口中的成分特点：JDK8之前接口中只能有抽象方法和常量
	public static final String CLASS_NAME = "大数据3班";
	public abstract String run();
	public abstract void sleep();
}

什么是接口（重点）

接口也是一种规范,约定人家只能干些什么事情，规范一定是公开的

所以在代码层面，public abstract可以省略不写

接口的基本使用：被实现（重点）

接口的用法：

接口是用来被类实现(implements)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

修饰符 class 实现类 implements 接口1，接口2，接口3....{
	
}

public interface SportMan{
    void run();
    void competiton();
}

package d3_interface.impl;

import d3_interface.SportMan;

public class Soccer implements SportMan {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Soccer(String name) {
        this.name = name;
    }

    public Soccer() {
    }

    @Override
    public void run() {
        System.out.println(name +"必须跑步训练");
    }

    @Override
    public void competiton() {
        System.out.println(name+"必须参加比赛");
    }
}

package d3_interface;

import d3_interface.impl.Soccer;

public class Test {
    public static void main(String[] args) {
        Soccer soccer = new Soccer();
        soccer.setName("梅西");
        soccer.competiton();
        soccer.run();
    }
}

从上面可以看出来，接口可以被类单实现，也可以被类多实现

接口实现的注意事项:

• 一个类实现接口，必须重写接口里面所有的全部抽象方法，否则这个类需要定义为抽象类

接口与接口的关系：多继承（重点）

类和类的关系：单继承

类和接口的关系：多实现

接口和接口的关系：多继承，一个接口可以同时继承多个接口

public interface SportMan{
	void run();
	void competiton();
}

public interface Law{
	void rule();
}

public interface People{
	void eat();
	void sleep();
}

接口多继承的作用

• 规范合并，整合多个接口为同一个接口，便于子类实现

练习：编写带有接口和抽象类标准的Javabean类

练习：编写带有接口和抽象类的标准Javabean类