Java面向对象——抽象类和接口

- 一、抽象类
- - 1.抽象类的由来
  - 2.抽象类的定义
  - 3.抽象类的规定
  - 4.抽象方法的定义
  - 5.抽象类的特点
- 二、接口
- - 1.抽象类和接口的使用
  - 2.接口表示标准的使用
  - 3.接口表示能力的使用

一、抽象类 1.抽象类的由来

在有继承关系的类中，子类重写父类的方法是可以选择写或不写的，不写的话创建子类对象时就会向上寻找父类的方法。

若需要强制要求子类重写父类方法，可以用抽象类。

2.抽象类的定义

这个类是概念化的，没办法具体到某个实例，描述这一类对象共同属性和行为。

举例：人类，有很多种族的人，这些人的属性是相似的，行为是形似的，但没有办法具体化到一个点，这种就是抽象的。

抽象类是普通类的升级版，比普通类多了些抽象的方法。

3.抽象类的规定

抽象方法所在的类一定是抽象类[0…N]
子类若继承了抽象类，必须覆写所有抽象方法，这里的子类是普通类。若子类也是抽象类，可以选择性覆写抽象方法
Java中定义抽象类或者抽象方法使用abstract关键字
一个抽象类，是无法直接通过该类实例化对象的，这个类是一个抽象的概念，只能通过子类向上转型变为抽象父类的引用

//解释第四点
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() {}
}

上述代码若B类覆写了A类的抽象方法，C类就只要写B类的抽象方法就可以了,代码如下

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.抽象方法的定义

使用abstract关键字声明，只有函数声明，没有方法体，称为抽象方法。

//抽象类
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

创建一个Fun的对象，因为Fun继承了BaseTest，所以先调用父类的构造方法
父类的构造方法调用了print方法，因为子类覆写了这个方法，并且new的是子类的对象，所以调用子类的print方法
这时候还没初始化完成，还是默认值，所以输出 num = 0

二、接口 1.抽象类和接口的使用

总结：当一个类既可以用抽象类，也可以用接口。优先使用接口，因为抽象类时单继承的，有局限性。

接口的使用：

接口表示具备了某种能力/行为，子类实现接口不是因为is a，而是具备这种行为或者能力

比如吃这个行为，人，鸭子，狗狗都有这种能力，他们都能实现这个接口。但人不是狗！！！！

接口表示一种规范或者标准

比如USB接口（是一个标准），所有满足这个接口的东西都可以插入。

2.接口表示标准的使用

接口只有全局常量和抽象方法，其他都没有

接口使用关键字interface声明接口，子类使用implement实现接口

举例：实现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 abstract这些关键字都不用写，只要保留方法返回值，方法参数列表，名称就可以了

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

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();
    }
}
输出：
兔子在跑~~~
狗娃子在跑~~~
狗娃子在狗刨~~~
鸭子在飞~~~

Java面向对象——抽象类和接口

Java相关栏目本月热门文章