Java面向对象编程进阶

# 1. Java面向对象编程回顾

### 1.1 面向对象编程概述

面向对象编程 (Object-Oriented Programming，简称OOP) 是一种程序设计的方法。它将现实世界中的事物抽象为对象，通过定义对象之间的关系和交互来模拟现实世界的情景。

在Java中，面向对象编程是其核心特性之一。通过类与对象的概念，Java允许我们使用面向对象的思维方式来构建程序。面向对象编程的三大特点是封装、继承和多态。

### 1.2 Java中的类与对象

在Java中，类是一种用于定义对象的模板。通过类可以描述对象所具有的属性和行为。对象是类的具体实例，它拥有类所定义的属性和行为。

下面是一个简单的Java类的示例：

public class Person {
    // 属性
    private String name;
    private int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

在这个示例中，`Person`类定义了两个属性 `name` 和 `age`，以及一个方法 `sayHello`。我们可以创建 `Person` 类的对象，并调用其方法来实现具体的功能。

### 1.3 封装、继承和多态的重要性

封装 (Encapsulation) 是面向对象编程的重要特性之一。封装将对象的属性和行为封装在类的内部，外部程序无法直接访问和修改类的内部状态，通过提供公共方法来操作对象的内部状态。

继承 (Inheritance) 是指一个类可以继承另一个类的属性和方法。通过继承，子类可以拥有父类的属性和行为，并可以在此基础上进行扩展和修改。

多态 (Polymorphism) 是指同一个类型的对象，在不同的情况下具有不同的行为。它通过继承和接口的机制来实现。多态提高了代码的灵活性和可扩展性。

### 1.4 类与对象的创建和使用示例

下面是一个使用 `Person` 类的示例：

public class Main {
    public static void main(String[] args) {
        // 创建Person对象
        Person person = new Person("John Doe", 25);
        // 调用对象的方法
        person.sayHello();
    }
}

在这个示例中，我们先创建了一个 `Person` 对象，然后调用了其 `sayHello` 方法来输出一句问候语。

代码执行结果：

Hello, my name is John Doe and I am 25 years old.

通过以上示例，我们回顾了Java面向对象编程的基础知识，介绍了类与对象的概念，并展示了如何创建和使用类。在接下来的章节中，我们将进一步深入学习Java中面向对象编程的进阶内容。

# 2. Java中的继承与多态

### 2.1 继承的概念和实现

继承是面向对象编程中的重要概念之一，它允许我们创建一个新的类，通过继承已有的类，从而获取已有类的属性和方法。在Java中，使用关键字`extends`来实现继承。

示例代码如下：

// 基类Animal
class Animal {
    public void eat() {
        System.out.println("Animal is eating...");
    }
}

// 派生类Dog
class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking...");
    }
}

// 派生类Cat
class Cat extends Animal {
    public void meow() {
        System.out.println("Cat is meowing...");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自Animal类的方法
        dog.bark();  // Dog类自己的方法

        Cat cat = new Cat();
        cat.eat();  // 继承自Animal类的方法
        cat.meow();  // Cat类自己的方法
    }
}

### 2.2 多态的概念和实现

多态是面向对象编程中的另一个重要特性，它允许我们使用父类的引用指向子类的对象。多态使得我们可以以统一的方式处理不同类的对象，提高代码的灵活性和可维护性。

示例代码如下：

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

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

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Cat is meowing...");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound();  // 输出：Dog is barking...
        animal2.makeSound();  // 输出：Cat is meowing...
    }
}

### 2.3 抽象类与接口

抽象类和接口是Java中实现多态的两种方式，它们都可以定义抽象方法，但在使用方式上有一些不同。

抽象类使用关键字`abstract`来定义，它不能被实例化，只能被继承。抽象类可以包含普通方法的实现，并且可以有成员变量。

接口使用关键字`interface`来定义，它不能被实例化，只能被实现。接口中只能定义抽象方法和常量，不能有成员变量。

// 抽象类
abstract class Shape {
    private String color;

    public Shape(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public abstract double getArea();  // 抽象方法
}

// 实现抽象类的派生类
class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    public double getArea() {
        return 3.14 * radius * radius;
    }
}

// 实现抽象类的派生类
class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    public double getArea() {
        return length * width;
    }
}

// 接口
interface Soundable {
    void makeSound();  // 抽象方法
}

// 实现接口的类
class Dog implements Soundable {
    public void makeSound() {
        System.out.println("Dog is barking...");
    }
}

// 实现接口的类
class Cat implements Soundable {
    public void makeSound() {
        System.out.println("Cat is meowing...");
    }
}

### 2.4 实例演示：使用继承和多态实现一个案例

下面通过一个案例来展示继承和多态的应用。

class Animal {
    protected String name;

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

    public void sound() {
        System.out.println("Animal is making sound...");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void sound() {
        System.out.println(name + " is barking...");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void sound() {
        System.out.println(name + " is meowing...");
    }
}

public class InheritanceAndPolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog("Tom")