3分钟教你学会Java抽象类

遥夜何漫漫

空歌白石烂

---

目录

 抽象类的概念

抽象类的场景 

抽象类的定义

 抽象类的语法

抽象类不能实例化

抽象类中的抽象方法不能有方法体

有抽象方法的类必须是抽象类

抽象类的子类必须实现抽象类定义的方法

抽象类的运用场景

（1）抽象类能被多个子类复用

（2）抽象类能够实现子类扩展

总结：

 

 抽象类的概念

抽象类的场景 

我们知道所以对象都是类描述出来的，但并不是所有的类都是用来描述对象的。这里举个例子：比如说你有女朋友了，你知道了对方的姓名、年龄、身高等等，但是你不知道她的爱好。这个时候你就琢磨不定，这个 “爱好” 的方法该怎么写？如果你还没有那么快发觉，可以将她的爱好 抽象 化，并在知道后再将其写上即可 ~

抽象类的定义

定义抽象类的时候需要用到关键字  abstract，放在 class 关键字前，就像下面这样

abstract class 类名{
    //类体
}

 抽象类的语法

抽象方法和抽象类必须使用 abstract 修饰符来定义，有抽象方法的类只能定义成抽象类，而抽象类中可以没有抽象方法（一般我们不这么做，因为没有意义）。所谓的抽象类就是只声明方法的存在而不去实现它的类，抽象类不能进行实例化（也就是不能创建其对象）

抽象类不能实例化

错误示范：

abstract class AmieHobby {
    abstract void hobby();
}

class  Teat {
    public static void main(String[] args) {
        new AmieHobby();
    }
}

抽象类是不能实例化的，如果你不小心用抽象类 new 了一个对象，编译器就会报错 ~ 

抽象类既然不能实例化对象，那是用来干嘛的呢？ -- 抽象的作用只有一个（被继承）

class Amie extends AmieHobby {}

抽象类中的抽象方法不能有方法体

有抽象方法的类必须是抽象类

当我们尝试在一个普通类中定义抽象方法的时候，编译器就会有错误提示

提示这个类必须通过 abstract 关键字定义

 当然抽象类中也可以定义普通方法，也可以没有抽象方法（像下面一样）

abstract class AmieHobby {
    abstract void hobby();
    public void sound(){
        System.out.println("甜美~");
    }
}

抽象类的子类必须实现抽象类定义的方法

俗话说得好，出来混早晚都要还的 ~ 你之前定义抽象类没有实现抽象方法编译器会让你的继承者来实现 ~

如果没有实现的话，编译器会提示子类必须实现抽象方法，见下图：

abstract class AmieHobby {
    abstract void hobby();
    public void sound(){
        System.out.println("甜美~");
    }
}

class Amie extends AmieHobby {
    private String name;
    public int age;

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

    public void PrintAmie(){
        System.out.println(this.name + " " + this.age);
    }

    public void hobby() {
        System.out.println("弹钢琴");
    }
}

class  Teat {
    public static void main(String[] args) {
        Amie amie = new Amie("小美",18);
        amie.PrintAmie();
        amie.hobby();
    }
}

 学到这里，我想你已经懂了抽象类到底是干什么的了，接下来谈谈运用场景

抽象类的运用场景

 

（1）抽象类能被多个子类复用

abstract class A{
    abstract int add();
}

class B extends A{
    private int b;
    private int c;

    public B(int b, int c) {
        this.b = b;
        this.c = c;
    }

    public int add(){
        return c+b;
    }
}

class C extends B{
    public C(int b, int c) {
        super(b, c);
    }
}

class Test{
    public static void main(String[] args) {
        B b = new B(10,20);
        System.out.println(b.add());
        C c = new C(1,2);
        System.out.println(c.add());
    }
}

这里用相对简单的代码举例 ~

class B extends A{
    private int b;
    private int c;

    public B(int b, int c) {
        this.b = b;
        this.c = c;
    }

这里 B 已经继承了 抽象类A 并且已经实现了方法，这个时候调用这个方法是没有问题的

        B b = new B(10,20);
        System.out.println(b.add());

 但 C 继承了 B 时，不仅 B 类的成员能被继承，而且 B 中实现的抽象方法也可以被继承

class C extends B{
    public C(int b, int c) {
        super(b, c);
    }
}

        C c = new C(1,2);
        System.out.println(c.add());

如此 C 的对象也就能使用 add 抽象方法了 

这样是不是就实现了代码的复用呢？ 

（2）抽象类能够实现子类扩展

当我们需要在抽象类中定义好 API，然后在子类中扩展实现的时候就可以使用抽象类。比如说，Person 抽象类中定义了一个抽象方法 eat()，表明所有人都要吃东西，但需要对应子类去扩展实现，拿我之前多态的例子来讲就是：教师吃教师餐，学生吃学生餐

abstract class Person {
    abstract void eat();
}

class Student extends Person {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void eat() {
        System.out.println(this.name+"吃学生餐~");
    }
}

class Teacher extends Person {
    private String name;
    private int age;
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void eat(){
        System.out.println( this.name+"吃教师餐~");
    }

}

class Test {
    public static void eat(Person a){
        a.eat();
    }
    public static void main(String[] args) {
        Student student = new Student("张三",18);
        student.eat();
        Teacher teacher = new Teacher("李四",38);
        teacher.eat();
    }
}

这里相当于拿抽象类实现多态 ~也证明抽象方法是可以向上转型的

抽象类是从多个具体类中抽象出来的父类，它具有更高层次的意义：从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的目标，从而避免了子类设计的随意性。Java 抽象类体现的是一种模板模式的设计，抽象类作为多个子类的通用模板，子类可以在抽象类的基础上进行扩展、改造，但是子类总体上会保留抽象类的行为方式

 

总结：

抽象类不能被实例化

抽象方法必须要在抽象类中

抽象类中的抽象方法没有方法体

抽象类的子类必须给出父类中的抽象方法的具体实现，除非该子类也是抽象类