Java面向对象——抽象类和接口-CFANZ编程社区

一、抽象类

1.抽象类的由来

2.抽象类的定义

3.抽象类的规定

//解释第四点
public abstract class Sharp {
    public abstract void print();
}
class Test{
    public static void main(String[] args) {
        Sharp sharp = new Sharp();//error
    }
}
//报错
java: interface_test.Sharp是抽象的; 无法实例化

//第三点
abstract class A {
    abstract void printA();
}
// B是抽象类，可以选择性的覆写父类的抽象方法
abstract class B extends A{
    abstract void printB();
}
// C 是普通类，必须覆写B中的所有抽象方法(包括继承来的抽象方法)
//c要覆写所有父类的抽象方法，所以这里要写两个
public class C extends B{
    void printB() {}
    void printA() {}
}

abstract class A {
    abstract void printA();
}
// B是抽象类，可以选择性的覆写父类的抽象方法
abstract class B extends A{
    abstract void printB();
    void printA(){}
}
public class C extends B{
    void printB() {}
}

4.抽象方法的定义

//抽象类
public abstract class Sharp {
    //抽象方法
    public abstract void print();
}

5.抽象类的特点

abstract class BaseTest {
    //抽象类的构造方法
    public BaseTest() {  
        this.print();  //第一步
    }
    abstract void print();
}
public class Fun extends BaseTest{
    private int num = 10;
    void print() {
        System.out.println("num = " + num); //第二步
    }
    public static void main(String[] args) {
        new Fun();
    }
}
输出：
num = 0

二、接口

1.抽象类和接口的使用

2.接口表示标准的使用

举例：实现USB接口

声明USB接口

public interface USB {
    // 插入
    public abstract void plugIn();
    // 工作
    public abstract void work();
}

创建USB的子类

//鼠标
class Mouse implements USB{
    @Override
    public void plugIn() {
        System.out.println("安装鼠标驱动~");
    }

    @Override
    public void work() {
        System.out.println("鼠标开始正常工作~");
    }
}
//键盘
class KeyBoard implements USB{
    @Override
    public void plugIn() {
        System.out.println("安装键盘驱动中~");
    }

    @Override
    public void work() {
        System.out.println("键盘正常工作了~");
    }
}
//相机
 class Camera implements USB{
    @Override
    public void plugIn() {
        System.out.println("安装相机驱动中~");
    }

    @Override
    public void work() {
        System.out.println("相机正常工作了~");
    }
}

创建一个电脑类，他不是USB的子类，而是USB的载体，使用者

public class Computer{
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse mouse = new Mouse();
        // 插入鼠标 
        computer.fun(mouse);
        KeyBoard keyBoard = new KeyBoard();
        // 插入键盘 
        computer.fun(keyBoard);
        Camera camera = new Camera();
        computer.fun(camera);
    }
    //这里接收的是USB类的所有子类，只要满足USB接口的，都可以插入到电脑里，不关心具体是哪一个设备，只要满足了这个接口，电脑就可以用。体现了多态性
    //兼容所有USB子类对象
    //向上转型
    public void fun(USB usb) {
        //调用子类覆写的两个方法
        usb.plugIn();
        usb.work();
    }
}

4.输出

安装鼠标驱动~
鼠标开始正常工作~
安装键盘驱动中~
键盘正常工作了~
安装相机驱动中~
相机正常工作了~

3.接口表示能力的使用

游泳的能力——实现游泳接口

public interface ISWim {
    //public abstract void swim();
    void swim();
}

跑的能力——实现跑接口

public interface IRun {
    void run();
}

飞的能力——实现飞接口

public interface IFly {
    void fly();
}

创建子类，兔子——只能实现跑接口

public class Rabbit implements IRun{
    @Override
    public void run() {
        System.out.println("兔子在跑~~~");
    }
}

创建狗子类——实现跑和游泳接口

public class Dog implements IRun,ISWim{
    @Override
    public void run() {
        System.out.println("狗娃子在跑~~~");
    }

    @Override
    public void swim() {
        System.out.println("狗娃子在狗刨~~~");
    }
}

创建鸭子类——实现跑，游泳，飞接口

public class Duck implements IRun,ISWim,IFly{
    @Override
    public void fly() {
        System.out.println("鸭子在飞~~~");
    }

    @Override
    public void run() {
        System.out.println("鸭子在跑~~~");
    }

    @Override
    public void swim() {
        System.out.println("鸭子在游泳~~~");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 接口也不能直接实例化对象，需要向上转型
        IRun run = new Rabbit();
        IRun run1 = new Dog();
        ISWim sWim = new Dog();
        IFly fly = new Duck();
        run.run();
        run1.run();
        sWim.swim();
        fly.fly();
    }
}
输出：
兔子在跑~~~
狗娃子在跑~~~
狗娃子在狗刨~~~
鸭子在飞~~~