面向对象进阶：static、单例、代码块、继承

 Java面向对象进阶

在本篇博客中，我们将深入探讨Java中的几个重要概念：`static`关键字、单例模式、代码块、以及继承。这些概念是构建稳健和高效Java程序的基础。每个主题都附有代码示例来帮助理解其应用。

 static关键字

`static`关键字用于修饰类的成员（变量和方法）。静态成员属于类本身，而不是类的实例。

静态变量

静态变量（类变量）在内存中只占用一份空间，并且被类的所有实例共享。

 示例：在线人数统计

```java
public class User {
    static int onlineCount = 0; // 静态变量
    String name;

    public User(String name) {
        this.name = name;
        onlineCount++;
    }

    public static void main(String[] args) {
        User u1 = new User("Alice");
        User u2 = new User("Bob");
        System.out.println("Online count: " + User.onlineCount); // 输出：Online count: 2
    }
}
```

 静态方法

静态方法可以直接通过类名调用，无需创建类的实例。它们常用于实现工具类。

 示例：工具类

```java
public class MathUtils {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    public static void main(String[] args) {
        System.out.println("Max: " + MathUtils.max(10, 20)); // 输出：Max: 20
    }
}
```

 单例模式

单例模式确保一个类在应用中只有一个实例，通常用于管理系统资源，如数据库连接池、日志对象等。

 饿汉式单例

饿汉式单例在类加载时就创建实例。

#### 示例

```java
public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 私有构造器
    }

    public static Singleton getInstance() {
        return instance;
    }
}
```

 懒汉式单例

懒汉式单例在首次使用时创建实例。

 示例

```java
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造器
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
```

 代码块

代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法之外。

 静态代码块

静态代码块在类加载时执行一次，通常用于静态资源的初始化。

#### 示例

```java
public class Game {
    static {
        System.out.println("Loading game resources...");
    }

    public static void main(String[] args) {
        System.out.println("Game started");
    }
}
```

 构造代码块

构造代码块在每次创建对象时执行，优先于构造器。

#### 示例

```java
public class Person {
    {
        System.out.println("A new person is being created");
    }

    public Person() {
        System.out.println("Constructor called");
    }

    public static void main(String[] args) {
        new Person();
    }
}
```

 继承

继承允许一个类获取另一个类的属性和方法，从而提高代码复用性。

### 基本概念

子类继承父类后，可以直接使用父类的属性和方法，但不能继承父类的构造器。

 示例：继承的使用

```java
public class Animal {
    protected String name;

    public void eat() {
        System.out.println(name + " is eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat(); // 调用父类方法
        dog.bark(); // 调用子类方法
    }
}
```

方法重写

子类可以重写父类的方法，以提供不同的实现。

 示例

```java
public class OldPhone {
    public void call() {
        System.out.println("Making a call...");
    }
}

public class NewPhone extends OldPhone {
    @Override
    public void call() {
        System.out.println("Making a video call...");
    }

    public static void main(String[] args) {
        NewPhone phone = new NewPhone();
        phone.call(); // 输出：Making a video call...
    }
}
```

 this和super关键字

- `this`：指向当前对象的引用。
- `super`：指向父类对象的引用。

 示例

```java
public class Animal {
    protected String name;

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

public class Cat extends Animal {
    public Cat(String name) {
        super(name); // 调用父类构造器
    }

    public void display() {
        System.out.println("This is a cat named " + this.name);
    }

    public static void main(String[] args) {
        Cat cat = new Cat("Whiskers");
        cat.display();
    }
}

```

通过这些示例，我们可以看到Java中的高级面向对象编程概念如何应用于实际开发中，提高代码的灵活性和可维护性。

---

希望这篇文章对您理解Java的高级面向对象概念有所帮助！如果有任何问题，欢迎讨论。