Java基础——抽象类

一、基本概念：

1.定义：

       抽象类是一种特殊的类，它不能被直接实例化，只能被继承。抽象类通常用于定义一组相关的类的共同特性和行为。它们可以包含抽象方法和具体方法。

2.特点：

1. abstract修饰的类是抽象类，修饰的方法是抽象方法
2. abstract修饰的抽象方法必须在子类中实现，前提是子类不是抽象类
3. 抽象类一定是父类
4. 只有抽象类中才能有抽象方法，普通方法里不能有抽象方法
5. 抽象类当中也可以写普通方法
6. 抽象类不能被创建对象，有构造器，但是构造器不能创建对象
7. final和abstract不能同时使用，final修饰的类不能被继承，final修饰的方法不能被重写
8. abstract修饰的方法不能被static修饰，因为static修饰的方法叫做类方法，属于类，abstract必须要在对象当中
9. 抽象方法不能使用private修饰符进行修饰访问。因为private修饰的方法只能在本类当中进行使用，子类是访问不到的，而abstract需要访问子类。

 3.抽象类的定义和使用示例：

1.定义抽象类：

// 定义一个抽象类
abstract class Animal {
    // 抽象方法
    abstract void makeSound();

    // 具体方法
    void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

2.继承抽象类并实现抽象方法：

// 继承抽象类并实现抽象方法
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }
}

3.使用抽象类和其子类：

public class Main {
    public static void main(String[] args) {
        // 创建具体子类的实例
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // 调用抽象方法和具体方法
        dog.makeSound(); // 输出: Woof!
        dog.sleep();     // 输出: This animal is sleeping.
        
        cat.makeSound(); // 输出: Meow!
        cat.sleep();     // 输出: This animal is sleeping.
    }
}

二、抽象类与接口的比较：

1. 继承方式：

   • 抽象类：可以继承其他类（包括抽象类），且一个类只能继承一个抽象类（单继承）。

   • 接口：可以实现多个接口（多继承），一个类可以实现多个接口。

2. 方法实现：

   • 抽象类：可以包含方法的实现，也可以包含抽象方法。

   • 接口：Java 8 及以后版本，接口可以有默认方法和静态方法，但接口方法通常是抽象的（Java 9 及以后，接口中也可以包含私有方法）。

3. 构造函数：

   • 抽象类：可以有构造函数。

   • 接口：不能有构造函数。

4. 字段：

   • 抽象类：可以有实例字段。

   • 接口：只能包含常量（public static final字段）。

三、抽象方法：

1.定义：

        抽象类可以包含抽象方法，这些方法在抽象类中没有具体的实现，只有方法的声明。子类必须实现这些抽象方法，才能成为一个具体的类。抽象方法的声明通常以 abstract 关键字开头。

2.特性

1. 没有方法体： 抽象方法只有方法签名（返回类型、方法名和参数列表），没有方法体（即没有大括号）。

2. 必须在抽象类中定义： 抽象方法只能在抽象类中定义。如果一个类包含抽象方法，那么这个类必须声明为抽象类。

3. 子类必须实现： 任何继承抽象类的非抽象子类必须实现所有的抽象方法。如果子类没有实现这些抽象方法，它也必须声明为抽象类。

例：

abstract class Animal {
    // 抽象方法
    abstract void makeSound();

    // 具体方法
    void sleep() {
        System.out.println("This animal is sleeping.");
    }

    // 构造方法
    Animal() {
        System.out.println("An animal is created.");
    }
}

四、抽象类：

1.定义：

        抽象类是一种不能被直接实例化的类。它的主要目的是提供一个基类，供其他类继承和扩展。抽象类可以包含抽象方法和具体方法，也可以有构造方法、字段（属性）和静态方法。

2.特性：

1. 不能实例化： 抽象类不能用new关键字直接创建实例。

2. 包含抽象方法： 抽象类可以包含抽象方法，这些方法没有实现，只定义了方法签名。具体的实现必须在子类中提供。

3. 可以包含具体方法： 抽象类可以包含有实现的方法。子类可以选择重写这些方法，也可以直接使用它们。

4. 可以包含字段和构造方法： 抽象类可以包含字段（属性）和构造方法，这些可以被子类继承和使用。

5. 可以继承其他类： 抽象类可以继承其他类（包括其他抽象类）。一个类只能继承一个抽象类（单继承）。

例：

abstract class Animal {
    // 抽象方法
    abstract void makeSound();
}

class Dog extends Animal {
    // 实现抽象方法
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    // 实现抽象方法
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }
}
--------------------------------------
public class Main {
    public static void main(String[] args) {
        // 创建具体子类的实例
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // 调用抽象方法
        dog.makeSound(); // 输出: Woof!
        cat.makeSound(); // 输出: Meow!

        // 调用具体方法
        dog.sleep();     // 输出: This animal is sleeping.
        cat.sleep();     // 输出: This animal is sleeping.
    }
}

 五、实例：

 //描述雇员。
 abstract class Employee{
        private String name ;
        private String id ;
        private double pay ;

       Employee(String name,String id, double pay){
              this.name = name;
              this.id = id;
              this.pay = pay;
       }

        public abstract void work();
 }

 //描述程序员
 class Programmer extends Employee{
       Programmer(String name,String id, double pay){
              super(name,id,pay);
       }

        public void work(){
             System.out.println("code..." );
        }
 }

 //描述经理
 class Manager extends Employee{
       private int bonus ;

       Manager(String name,String id, double pay,int bonus){
              super(name,id,pay);
              this.bonus = bonus;
       }

       public void work(){
             System.out.println("manage" );
       }
 }

1. 抽象类 Employee:

   • 字段: name, id, pay—这些字段用来存储员工的基本信息。
   • 构造方法: 用于初始化name, id, pay。
   • 抽象方法 work(): 定义了一个抽象方法work()，强制所有继承Employee的子类实现这个方法。

2. 具体类 Programmer:

   • 继承: 继承自Employee。
   • 构造方法: 调用父类构造方法来初始化基本信息。
   • 方法实现: 实现work()方法，输出 "code..."，表示程序员的工作内容。

3. 具体类 Manager:

   • 继承: 继承自Employee。
   • 字段: 增加了一个bonus字段来存储奖金信息。
   • 构造方法: 除了初始化name, id, pay外，还初始化了bonus字段。
   • 方法实现: 实现work()方法，输出 "manage"，表示经理的工作内容。