Java-抽象类-概念介绍与细节总结

抽象类概念

• 当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类

源码举例

package com.tao.abstract_;

/**
 * Create By 刘鸿涛
 * 2021/12/25 9:36
 */
public class Abstract01 {   //父债子还方法

}
abstract class Animal {
    private String name;

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

    //思考：这里eat 实现了，其实没有意义
    //即：父类方法不确定性的问题
    //===> 考虑该方法设计为抽象（abstract）方法
    //===> 所谓抽象方法就是没有实现的方法
    //===> 所谓的没有实现就是指，没有方法体
    //===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
    //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法。


//    public void eat(){
//        System.out.println("这是一个动物，但是不知道吃什么...");
//    }

    public abstract void eat();
}

抽象类的介绍

1. 用abstract 关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 abstract 类名{
}

2. 用abstract 关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型 方法名（参数列表）；//没有方法体

3. 抽象类的价值更多作用在于设计，是设计者设计好后，让子类继承并实现抽象类（）
4. 抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

抽象类的细节注意（一）

1. 抽象类不能被实例化【举例】
2. 抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法【举例】
3. 一旦包含了abstract方法，则这个类必须声明为abstract【思考理解】
4. abstract只能修饰类和方法，不能修饰属性和其他的【思考理解】

源码举例（一）

package com.tao.abstract_;

/**
 * Create By 刘鸿涛
 * 2021/12/25 9:57
 */
public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类不能被实例化【举例】
//        AA aa = new AA();
    }

}

abstract class AA{

    //抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
    //还可以有实现的方法
    public void eat(){
        System.out.println("吃");
    }
}

抽象类的细节注意（二）

1. 抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等【举例】
2. 抽象方法不能有主体，即不能实现

abstract void aaa(); //不能用大括号写方法体

3. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。【举例】
4. 抽象方法不能使用private、final 和static 来修饰，因为这些关键字都是和重写相违背的。

源码举例（二）

package com.tao.abstract_;

/**
 * Create By 刘鸿涛
 * 2021/12/25 10:04
 */
public class AbstractDetail02 {
    public static void main(String[] args) {

    }

}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D{
    public int ni = 10;
    public static String name = "涛涛";
    public void hi(){
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok(){
        System.out.println("ok");
    }
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。【举例】
abstract class E{
    public abstract void hi();

}
abstract class F extends E{ //继承后必须声明抽象类，或实现所有抽象方法

}
class G extends E{
    public void hi(){   //这里的G类实现了父类E的抽象方法

    }
}

抽象类简单练习

package com.tao.abstract_;

/**
 * Create By 刘鸿涛
 * 2021/12/25 11:44
 */
public class AbstractExercise01 {
    public static void main(String[] args) {
        Manager 李经理 = new Manager("李经理");
        CommonEmployee 张普工 = new CommonEmployee("张普工");

        李经理.work();
        张普工.work();
    }
}
abstract class Employee{
    private String name;
    private String id;
    private double salary;

    public Employee(String name) {
        this.name = name;

    }
    public abstract void work();

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

class Manager extends Employee{
    private double bonus;   //奖金
    public Manager(String name){
        super(name);
    }

    public void work(){
        System.out.println("经理\t" + super.getName() + "\t工作中...");
    }
}
class CommonEmployee extends Employee{
    public CommonEmployee(String name) {
        super(name);
    }
    public void work(){
        System.out.println("普通员工\t" + super.getName() + "\t工作中...");
    }
}