JavaOOP04——抽象

目录

一、抽象类与抽象方法

二、final关键字 

三、static关键字 

四、单例模式

一、抽象类与抽象方法

1. 概念介绍

抽象类是一种特殊的类，它不能被实例化，即不能通过new关键字直接创建其对象。抽象类存在的意义是为了被其他类继承，并且抽象类可以包含抽象方法和其他具体实现的方法。

抽象方法是指没有具体实现的方法，即只有方法签名而没有方法体。抽象方法需要由继承了抽象类的子类来具体实现。

2. 使用场景

抽象类通常用来定义一组相关的类的共同特征，而这些特征可能在不同的子类中有不同的实现方式。抽象方法则是在父类中声明需要实现的方法，而具体的实现留给子类去完成。

3. 编码实践

假设我们正在开发一个动物管理系统，其中不同类型的动物有不同的叫声。我们可以创建一个抽象类Animal，其中包含一个抽象方法speak()，以及一些共有的属性和方法。

示例代码

// 定义一个抽象类 Animal
abstract class Animal {
    protected String name;

    // 构造器
    public Animal(String name) {
        this.name = name;
    }

    // 共有方法
    public void eat() {
        System.out.println(name + " is eating.");
    }

    // 抽象方法，由子类实现
    public abstract void speak();
}

// Dog 类继承 Animal 并实现 speak 方法
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void speak() {
        System.out.println(name + " says Woof!");
    }
}

// Cat 类继承 Animal 并实现 speak 方法
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void speak() {
        System.out.println(name + " says Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("Buddy");
        Animal cat = new Cat("Whiskers");

        dog.speak(); // 输出: Buddy says Woof!
        cat.speak(); // 输出: Whiskers says Meow!

        dog.eat();   // 输出: Buddy is eating.
        cat.eat();   // 输出: Whiskers is eating.
    }
}

二、final关键字 

1. 概念介绍

final关键字用于标记类、方法或变量，表示该元素是最终的，即不可更改或重写。

• final类：此类不能被继承。

• final方法：此方法不能被子类覆盖。

• final变量：此变量一旦被赋值，则其值不能被改变。

2. 使用场景

final关键字经常用于保护数据不被修改，或者确保方法的行为不被子类改变。

3. 编码实践

以下代码展示了如何使用final关键字定义一个不可继承的类，并且该类中的方法也不能被重写。

示例代码

// 使用 final 关键字定义不可继承的类
final class FinalClass {
    // 使用 final 关键字定义不可重写的常量
    private final int value = 10;

    // 使用 final 关键字定义不可重写的常量方法
    public final int getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        FinalClass obj = new FinalClass();
        System.out.println(obj.getValue()); // 输出: 10
    }
}

三、static关键字 

1. 概念介绍

static关键字用于定义类的静态成员变量和静态方法。静态成员属于类本身，而不是类的实例。这意味着不需要创建类的实例就可以访问静态成员。

2. 使用场景

• 当我们需要一个共享的数据成员时，可以使用static关键字。

• 当方法的操作不依赖于对象的状态时，可以使用static关键字。

3. 编码实践

以下示例演示了如何使用static关键字定义静态变量和静态方法。

示例代码

public class StaticExample {
    // 静态变量，所有实例共享
    public static int count = 0;

    // 静态方法，可以直接通过类名调用
    public static void incrementCount() {
        count++;
    }

    // 实例方法
    public void printCount() {
        System.out.println("Current count is " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        StaticExample.incrementCount(); // 增加计数器
        StaticExample.incrementCount(); // 再次增加计数器

        StaticExample example1 = new StaticExample();
        example1.printCount(); // 输出: Current count is 2

        StaticExample example2 = new StaticExample();
        example2.printCount(); // 输出: Current count is 2
    }
}

四、单例模式

1. 概念介绍

单例模式是一种创建型模式，它保证一个类仅有一个实例，并提供一个全局访问点。

2. 使用场景

单例模式常用于管理系统中的一些资源，如配置文件、日志记录等，确保这些资源在整个应用中只有一个实例，以避免多次创建导致的问题。

3. 编码实践

以下示例展示了如何使用懒汉式单例模式实现一个日志记录类。

示例代码

public class Logger {
    private static Logger instance;

    // 私有构造函数
    private Logger() {}

    // 提供一个全局访问点
    public static Logger getInstance() {
        if (instance == null) {
                if (instance == null) {
                    instance = new Logger();
                }
        }
        return instance;
    }

    public void log(String message) {
        System.out.println("Logging: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger = Logger.getInstance();
        logger.log("This is a log message.");
    }
}