JAVA——抽象类

抽象类

Java中的抽象类是一种特殊的类，它不能被实例化，即不能直接创建对象，只能作为其他类的基类（父类）来使用。抽象类主要用于定义一些通用的属性和方法，这些方法可以在子类中得到具体的实现。

抽象类使用abstract关键字进行修饰。它可以有构造方法，用于初始化抽象类的实例变量。同时，抽象类可以包含抽象方法，这些抽象方法只有方法的签名，没有具体的实现，需要在子类中实现。子类在继承抽象类时，必须实现抽象类中的所有抽象方法，除非子类自身也被声明为抽象类。

抽象类的主要作用有：

1. 类型隐藏：抽象类可以作为类型使用，将具体实现细节隐藏起来，只暴露必要的接口给使用者。
2. 代码复用：通过继承抽象类，子类可以复用抽象类中定义的方法和属性，避免重复编写相同的代码。
3. 强制子类实现特定方法：抽象类中的抽象方法要求子类必须实现，这可以确保子类具有某些必要的功能或行为。

下面是一个简单的抽象类定义示例：

public abstract class Animal {  
    // 抽象方法，没有方法体  
    public abstract void eat();  
    public abstract void sleep();  
  
    // 非抽象方法，有具体实现  
    public void makeSound() {  
        System.out.println("The animal makes a sound.");  
    }  
}

在这个例子中，Animal是一个抽象类，它定义了两个抽象方法eat和sleep，以及一个非抽象方法makeSound。任何继承Animal类的子类都必须实现eat和sleep方法，但可以直接使用makeSound方法，因为它已经有了具体的实现。

抽象类和普通类在面向对象编程中存在明显的区别

首先，普通类是可以被实例化的类，它们具有具体的实体，可以直接创建为对象，并且包含完整的实现细节。普通类可以定义属性、方法和构造函数等，并且可以被其他类继承。一旦普通类被实例化，其对象可以直接调用类中的方法和访问属性。普通类存在的意义就是为了实例化。

而抽象类则是一种特殊的类，它不能被实例化，即不能创建对象。抽象类主要用于定义一些通用的属性和方法，这些通用方法可以是具体的，也可以是抽象的。抽象方法使用abstract关键字进行修饰，只有方法的签名，没有具体的实现，需要由其子类提供具体的实现。一个含有抽象方法的类必须声明为抽象类。子类在继承抽象类时，必须实现抽象类中的所有抽象方法，除非子类自身也被声明为抽象类。抽象类存在的意义就是为了被继承，其子类可以重写父类的方法，或者为父类的抽象方法提供实现。抽象类的构造方法作用为初始化子类对象。

因此，普通类和抽象类的主要区别在于其是否可以实例化、是否有抽象方法的定义、以及它们在类层次结构中的使用方式。普通类更注重具体实现，而抽象类则更注重定义通用属性和方法，并强制子类实现特定的行为。

抽象类和接口

抽象类和接口在Java等面向对象编程语言中都是重要的概念，但它们之间存在一些关键的区别。

首先，抽象类和接口都不能被直接实例化，它们都是用于被其他类实现或者继承的。抽象类是对类的抽象，它表示的是“这个对象是什么”，而接口是对动作的抽象，表示的是“这个对象能做什么”。因此，抽象类主要关注一个事物的本质，而接口关注一个操作。

其次，抽象类和接口在包含的方法类型上有所不同。抽象类既可以包含抽象方法，也可以包含普通方法，提供部分实现。而接口只能包含抽象方法，不能包含普通方法。这意味着接口完全是对方法的声明，不提供任何实现，而抽象类则可以提供部分实现。

再者，抽象类和接口在定义属性方面也有所区别。接口中只能定义静态常量属性，不能定义普通属性。而抽象类既可以定义普通属性，也可以定义静态常量属性。

此外，抽象类可以有构造器，但接口中不包含构造器。抽象类中的构造器不是用于创建对象，而是让子类调用这些构造器来完成属于抽象类的初始化工作。

最后，从使用角度来看，一个类只能继承一个抽象类（单继承），但可以实现多个接口（多继承）。这意味着抽象类的功能要远超过接口，但定义抽象类的代价也相对较高，因为需要编写和继承出所有子类的共性。而接口则提供了更灵活的扩展性，通过实现多个接口，一个类可以具有多种不同的行为。

 

举例看看：

// 定义一个抽象类  
abstract class Animal {  
    // 抽象类中的普通成员变量  
    private String name;  
  
    // 抽象类中的普通方法  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    // 抽象方法，子类必须实现  
    public abstract void makeSound();  
}  
  
// 定义一个接口  
interface Movable {  
    // 接口中的方法默认是抽象的  
    void move();  
}  
  
// 定义一个类，继承抽象类Animal并实现接口Movable  
class Dog extends Animal implements Movable {  
    // 实现抽象类Animal中的抽象方法  
    @Override  
    public void makeSound() {  
        System.out.println("The dog barks.");  
    }  
  
    // 实现接口Movable中的方法  
    @Override  
    public void move() {  
        System.out.println("The dog runs.");  
    }  
}  
  
// 主类，用于测试  
public class Main {  
    public static void main(String[] args) {  
        // 创建Dog类的实例  
        Dog dog = new Dog();  
          
        // 设置名字  
        dog.setName("Buddy");  
          
        // 调用继承自Animal的getName方法  
        System.out.println("Dog's name: " + dog.getName());  
          
        // 调用实现自Animal的makeSound方法  
        dog.makeSound();  
          
        // 调用实现自Movable的move方法  
        dog.move();  
    }  
}

在这个例子中，Animal 是一个抽象类，它有一个普通成员变量 name 和一个普通方法 setName/getName，还有一个抽象方法 makeSound。Movable 是一个接口，它定义了一个抽象方法 move。

Dog 类继承了 Animal 类，并实现了 Movable 接口。因此，Dog 类必须实现 Animal 类中定义的抽象方法 makeSound 和 Movable 接口中定义的 move 方法。

在 Main 类的 main 方法中，我们创建了 Dog 类的实例，并调用了它的方法。这展示了如何在一个类中同时继承抽象类和实现接口，并提供了这些方法的具体实现。

这个例子清晰地展示了抽象类和接口在Java中的区别和用法：抽象类可以包含普通方法和抽象方法，而接口只能包含抽象方法；一个类可以继承一个抽象类，但可以实现多个接口。

总的来说，Java中的抽象类是一种强大的工具，它允许我们定义通用的属性和方法，并在子类中实现具体的行为，从而提高了代码的复用性和可维护性。