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的高级面向对象概念有所帮助！如果有任何问题，欢迎讨论。
原文链接: https://blog.csdn.net/2302_80084329/article/details/140882292