11.抽象类和接口

抽象类

抽象类概述

java中,一个没有方法体的方法应该定义为抽象方法, 二类中如果有抽象方法, 该类必须定义为抽象类.

特点:

• 抽象类和抽象方法必须使用abstract关键字修饰
  • public abstract class 类名{}
  • public abstract void eat();
• 抽象类中不一定有抽象方法, 有抽象方法的类一定是抽象类
• 抽象类不能直接实例化, 可以参照多态的方式, 通过子类对象实例化, 这叫抽象类多态
• 抽象类的子类: 要么重写抽象类的所有抽象方法, 要么是抽象类

Animal

package abstractClass.abstractDemo;

// 定义抽象类
public abstract class Animal {
    // 定义抽象方法
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }

    // 有抽象方法,一定是抽象类, 但是抽象类中不一定有抽象方法
}

Cat

package abstractClass.abstractDemo;

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

Dog

package abstractClass.abstractDemo;

public abstract class Dog extends Animal {

}

Demo

package abstractClass.abstractDemo;

public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

抽象类成员特点

成员变量:

• 可以是变量
• 可以是常量

构造方法:

• 有构造方法, 但不能实例化
• 用于子类访问父类数据的初始化

成员方法:

• 可以有抽象方法: 限定子类必须完成某些动作
• 也可以有非抽象方法: 提高代码复用性

Animal

package abstractClass.member;

public abstract class Animal {
    private int age = 20;
    private final String city = "北京";

    public Animal() {}

    public void show() {
        age = 40;
        System.out.println(age);
        System.out.println(city);
    }

    public abstract void eat();
}

Cat

package abstractClass.member;

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

Demo

package abstractClass.member;

public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

接口

概述

接口是一种公共的规范, 只要符合规范标准,大家都可以通用

java的接口更多的体现在对行为的抽象.

接口特点

接口用关键字interface修饰

• public interface 接口名 {}

类实现接口用implements表示

• public class 类名 implements 接口名 {}

接口不能直接实例化

• 实例化需要参照多台方式, 通过实现类对象实例化, 称为接口多态
• 多态的形式: 具体类多态, 抽象类多态, 接口多态
• 多态前提: 有继承或者实现关系; 有方法重写; 有父(类/接口)引用指向(子/实现)类对象

接口的实现类:

• 要么重写接口中的所有抽象方法
• 要么是抽象类

Jumpping

package javaInterface.interfaceDemo;

public interface Jumpping {
    public abstract void jump();
}

Cat

package javaInterface.interfaceDemo;

public class Cat implements Jumpping {  // 接口的继承使用inplements关键字
    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}

Dog

package javaInterface.interfaceDemo;

public abstract class Dog implements Jumpping {
    // 抽象类继承接口,可以不重写方法
}

Demo

package javaInterface.interfaceDemo;

public class Demo {
    public static void main(String[] args) {
        // Jumpping j = new Jumpping();  // 接口是一个抽象类, 不能被实例化
         Jumpping j = new Cat();  // 接口实例化采用多态方式
         j.jump();
    }
}

接口成员的特点

成员变量:

• 只能是常量
• 默认修饰父: public static final

构造方法:

• 接口没有构造方法, 因为接口主要是对行为进行抽象的, 没有具体存在
• 一个类如果没有父类, 默认继承自Object类

成员方法:

• 只能是抽象方法
• 默认修饰符: public abstract
• 关于接口中的方法, JDK8和JDK9有一些新特性

Inter

package javaInterface.member;

public interface Inter {
    // 成员变量
    public int num = 10;
    public final int num2 = 20;
    int num3 = 30; // 等价于 public static final int num3 = 30;

    // 构造方法
    // public Inter(){}  // 接口中没有构造方法

    // 成员方法
    // public void show() {}  // 接口中没有非抽象方法

    public abstract void method();  // 只能是抽象方法

    void show();  // 默认也是抽象方法

}

InterImpl

package javaInterface.member;

// public class InterImpl implements Inter {
// 上述等价于 public class InterImpl extends Object implements Inter,
// 也就是访问父类构造方法的时候, 访问的是object的无参构造方法, 而不是Inter的
public class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }

    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}

Demo

package javaInterface.member;

public class Demo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        // i.num = 15;  // 接口中的变量默认为final修饰的
        System.out.println(i.num);
        // i.num2 = 30; // 常量不能赋值
        System.out.println(i.num2);
        System.out.println(Inter.num2);  // 接口中的变量默认是静态的
    }
}

猫和狗案例接口板

Jumpping

package javaInterface.catAndDog;

public interface Jumpping {
    public abstract void jump();
}

Animal

package javaInterface.catAndDog;

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

package javaInterface.catAndDog;

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("猫可以跳高");
    }
}

Demo

package javaInterface.catAndDog;

public class Demo {
    public static void main(String[] args) {
        // 创建对象,调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("--------");

        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        // a.jump();

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

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName() + "," + c.getAge());
        c.eat();
        c.jump();
    }
}

类和接口的关系

类和类的关系

• 继承关系, 只能单继承, 但是可以多层继承

类和接口的关系

• 实现关系, 可以单实现, 也可以多实现, 还可以在继承一个类的同时实现多个接口

接口和接口的关系

• 继承关系, 可以单继承, 也可以多继承

inter1

package javaInterface.interfaceAndClass;

public interface Inter1 {
}

Inter2

package javaInterface.interfaceAndClass;

public interface Inter2 {
}

Inter3

package javaInterface.interfaceAndClass;

public interface Inter3 extends Inter1, Inter2 {
    // 接口和接口可以多继承
}

InterImpl

package javaInterface.interfaceAndClass;

public class InterImpl extends Object implements Inter1, Inter2, Inter3 {
    // 类可以实现多个接口
}

抽象类和接口的区别

成员区别

• 抽象类: 变量,常量; 有构造方法; 有抽象方法, 也有非抽象方法
• 常量; 抽象方法

关系区别

• 类与类: 继承, 单继承
• 类与接口: 实现, 单实现, 多实现
• 接口与接口: 继承, 单继承, 多继承

设计理念

• 抽象类: 对类抽象, 包括属性,行为
• 接口: 对行为抽象, 主要是行为

使用案例:门和报警器

Alarm

package javaInterface.doorAndAlarm;

public interface Alarm {
    void alarm();
}

Door

package javaInterface.doorAndAlarm;

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

AlarmDoor

package javaInterface.doorAndAlarm;

public class AlarmDoor extends Door implements Alarm {
    @Override
    public void open() {
        System.out.println("开门");
    }

    @Override
    public void close() {
        System.out.println("关门");
    }

    @Override
    public void alarm() {
        System.out.println("报警");
    }
}

抽象是对事物的抽象, 接口是对行为的抽象.

形参和返回值

抽象类作为形参和返回值

方法的形参是抽象类名, 其实需要的抽象类的子类对象

方法的返回值是抽象类名, 其实返回的是该抽象类的子类对象

Animal

package paramAndReturn.abstractAndReturn;

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

Cat

package paramAndReturn.abstractAndReturn;

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

AnimalOperator

package paramAndReturn.abstractAndReturn;

public class AnimalOperator {
    public void useAnimal(Animal a) {
        a.eat();
    }

    public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}

Demo

package paramAndReturn.abstractAndReturn;

public class Demo {
    public static void main(String[] args) {
        // 创建对象
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);

        Animal a2 = ao.getAnimal();
        a2.eat();
    }
}

接口作为形参和返回值

方法的形参是接口名, 其实需要的接口的实现类对象

方法的返回值是接口名, 其实返回的是该接口类的实现类对象

Jumpping

package paramAndReturn.interfaceAndReturn;

public interface Jumpping {
    void jump();
}

Cat

package paramAndReturn.interfaceAndReturn;

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳跃");
    }
}

JumppingOperator

package paramAndReturn.interfaceAndReturn;

public class JumppingOperator {
    public void useJumpping(Jumpping j) {
        j.jump();
    }

    public Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }
}

Demo

package paramAndReturn.interfaceAndReturn;

public class Demo {
    public static void main(String[] args) {
        // 创建操作类, 调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j);

        Jumpping j2 = jo.getJumpping();
        j2.jump();
    }
}