Java abstract抽象类

抽象类是面向对象编程中的概念，它是一种不能被实例化的类，只能被用作其他类的父类。抽象类通常包含了一些抽象方法，这些方法没有具体的实现，而是留给子类去实现。

1.1 抽象类的好处包括：

1.定义了类的模板：抽象类可以定义一些通用的属性和方法，作为其他具体子类的模板，提高了代码的复用性。

2.强制实现规范：通过定义抽象方法，抽象类可以强制子类去实现特定的方法，确保了子类的一致性。

1.2 什么是抽象类：

1.声明抽象类：使用关键字 abstract 来声明一个抽象类。具体语法可能会有所不同，以下是一般形式的示例：

public abstract class AbstractClass {
    // 抽象方法和普通方法的声明
}

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

2.定义抽象方法：在抽象类中声明抽象方法，但不提供具体的实现。抽象方法以分号结尾，没有方法体。示例如下：

abstract class Shape{
   /* public String name;
    public int age;
    public void func(){
        System.out.println("ada");
    }
    public static void func2(){
        System.out.println("akjdhkjasd");
    }*/
    public abstract void draw();//抽象方法
}

3.继承抽象类：创建一个子类并继承抽象类，子类必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。示例如下：

public class ConcreteClass extends AbstractClass {
    @Override
    public void abstractMethod() {
        // 提供具体的实现
    }
}

1.3 抽象类需要注意的点：

• 使用abstract 修饰的类，就是抽象类

• 使用abstract 修饰的方法，就是抽象方法

• 抽象类不能用来创建对象，即抽象类不能被直接实例化，要通过其普通子类进行实例化。

• 里面的成员变量和成员方法都是和普通类是一样的，只不过就是不能进行实例化了

• 当一个普通的类，继承这个抽象类之后，那么这个普通类，必须重写这个抽象类当中所有的抽象方法。

• 抽象类存在的最大的意义就是为了被继承

• 抽象类也可以发生向上转型进一步发生多态

• 如果一个普通子类继承于一个抽象父类，则该类一定要重写实现该父类的抽象方法。如果该子类仍然是一个抽象类，这也是允许的，就不必重写实现该父类的抽象方法，但必须用abstract修饰。

• final不能修饰抽象方法和抽象类

• 其修饰符必须为 public 或者protected，不能是private，因为创建抽象类，就是要被其他类继承，用private修饰了，则不能被子类继承，子类便无法实现该方法。

• 抽象类当中不一定有抽象方法，但是如果这个方法是抽象方法，那么这个类一定是抽象类

代码展示：

package com.zsh.java;

public abstract class Person {
    //私有数据成员
    private String name;
    //构造方法
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
    //setter,getter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eating(String food){
        System.out.println(this.getName() + "正在吃" + food);
    }
    abstract public void workOn();
}

package com.zsh.java;

public class Teacher extends Person{
    //私有数据成员
    private String classRoom;
    //构造方法
    public Teacher() {
    }

    public Teacher(String name, String classRoom) {
        super(name);
        this.classRoom = classRoom;
    }
    //setter,getter方法
    public String getClassRoom() {
        return classRoom;
    }

    public void setClassRoom(String classRoom) {
        this.classRoom = classRoom;
    }

    @Override
    public void workOn() {//覆写父类Person的抽象方法workOn()
        System.out.println(this.getName() + "在" + this.classRoom + "教书");
    }
    public void sleepCheck(int time){
        System.out.println(this.getName() + "今晚查寝在" + time + "点");
    }
}

package com.zsh.java;

public class Student extends Person{
    //私有数据成员
    private int id;
    //构造方法
    public Student() {
    }

    public Student(String name, int id) {
        super(name);
        this.id = id;
    }
    //setter,getter方法
    public int getId() {
        return id;
    }

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

    @Override
    public void workOn() {//覆写父类的抽象方法workOn()
        System.out.println("学号：" + this.id + ",姓名" + this.getName() +" " + "在认真上课");
    }
    public void sleep(){
        System.out.println("姓名：" + this.getName() +" "+ "上课睡觉");
    }
}

package com.zsh;

import com.zsh.java.Person;
import com.zsh.java.Student;
import com.zsh.java.Teacher;

public class Demo001 {
    public static void main(String[] args) {
        Person p = new Teacher("王五","11班");
        p.eating("午饭");
        p.workOn();

        Teacher t =new Teacher("李四","12班");
        t.eating("晚饭");
        t.workOn();
        t.sleepCheck(10);
        Person p1 = new Student("书书",1032);
        p1.eating("炸鸡");
        p1.workOn();

        Student s = new Student() ;
        s.setId(1012);
        s.setName("张三");
        s.eating("烤红薯");
        s.sleep();
        s.workOn();
    }
}

结果展示：