Java——面向对象编程

面向对象编程（Object-Oriented Programming, OOP）是Java的核心特性之一。它通过将现实世界中的事物抽象为对象，使程序更易于理解、维护和扩展。以下是Java面向对象编程的详细介绍：

---

1. 面向对象编程的四大特性

Java的面向对象编程基于以下四大特性：

1.1 封装（Encapsulation）

• 定义：将数据（属性）和行为（方法）封装在一个类中，并对外隐藏内部实现细节。
• 目的：提高代码的安全性和可维护性。
• 实现方式：
  • 使用private修饰属性，限制外部直接访问。
  • 提供public的getter和setter方法，控制对属性的访问和修改。

示例：

public class Person {
    private String name; // 私有属性
    private int age;

    // Getter方法
    public String getName() {
        return name;
    }

    // Setter方法
    public void setName(String name) {
        this.name = name;
    }

    // 其他方法
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

---

1.2 继承（Inheritance）

• 定义：一个类可以继承另一个类的属性和方法，从而实现代码复用。
• 目的：减少重复代码，提高代码的可扩展性。
• 实现方式：
  • 使用extends关键字实现继承。
  • 子类可以访问父类的非私有成员（属性和方法）。
  • Java支持单继承，即一个类只能有一个直接父类。

示例：

// 父类
public class Animal {
    private String name;

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

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("Woof! Woof!");
    }
}

---

1.3 多态（Polymorphism）

• 定义：同一个方法在不同情况下具有不同的行为。
• 目的：提高代码的灵活性和可扩展性。
• 实现方式：
  • 方法重写（Override）：子类可以重写父类的方法，提供不同的实现。
  • 方法重载（Overload）：同一个类中可以有多个同名方法，但参数列表不同。
  • 向上转型（Upcasting）：父类引用可以指向子类对象。

示例：

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

// 子类
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

// 测试多态
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.makeSound(); // 输出: Woof! Woof!
    }
}

---

1.4 抽象（Abstraction）

• 定义：将复杂的现实世界抽象为简单的模型，只关注核心特性。
• 目的：简化复杂性，提高代码的可读性和可维护性。
• 实现方式：
  • 抽象类（Abstract Class）：用abstract关键字定义，不能实例化，可以包含抽象方法和具体方法。
  • 接口（Interface）：用interface关键字定义，只能包含抽象方法（Java 8以后可以包含默认方法和静态方法）。

示例：

// 抽象类
public abstract class Shape {
    public abstract double getArea(); // 抽象方法

    public void display() {
        System.out.println("This is a shape.");
    }
}

// 接口
public interface Drawable {
    void draw(); // 抽象方法
}

// 实现类
public class Circle extends Shape implements Drawable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

---

2. 类与对象

• 类（Class）：类是对象的模板，定义了对象的属性和行为。
• 对象（Object）：对象是类的实例，具有类定义的属性和行为。

示例：

// 定义类
public class Car {
    private String brand;
    private String color;

    // 构造器
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    // 方法
    public void drive() {
        System.out.println("Driving a " + color + " " + brand + " car.");
    }
}

// 创建对象
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Red");
        myCar.drive(); // 输出: Driving a Red Toyota car.
    }
}

---

3. 其他重要概念

3.1 静态成员（Static Members）

• 用static关键字修饰的成员（属性和方法）属于类，而不是对象。
• 静态成员可以通过类名直接访问。

示例：

public class Counter {
    private static int count = 0; // 静态属性

    public static void increment() { // 静态方法
        count++;
    }

    public static int getCount() {
        return count;
    }
}

// 使用静态成员
public class Main {
    public static void main(String[] args) {
        Counter.increment();
        System.out.println("Count: " + Counter.getCount());
    }
}

3.2 final关键字

• final修饰的类不能被继承。
• final修饰的方法不能被子类重写。
• final修饰的变量是常量，值不能被修改。

示例：

public final class Constants {
    public static final double PI = 3.14159; // 常量
}

---

4. 总结

Java的面向对象编程通过封装、继承、多态和抽象四大特性，使代码更模块化、可复用和易于维护。掌握这些概念是成为一名优秀Java开发者的基础。