Java面向对象编程基础

# 1. Java面向对象编程概述

## 1.1 什么是面向对象编程

面向对象编程是一种编程范式，通过定义和组织对象之间的交互来构建程序。在面向对象编程中，将数据和方法封装在一个对象中，通过对象之间的消息传递来实现程序的功能。

面向对象编程的核心思想是将现实世界中的事物抽象成对象，并通过对象之间的关系和交互来描述问题的解决方案。每个对象都有自己的属性和方法，在程序中可以通过调用方法来实现对象之间的交互和数据处理。

## 1.2 Java语言的面向对象特性

Java是一种面向对象的编程语言，具有以下特性：

- 封装性：通过将数据和方法封装在对象中，实现了对数据的保护和隔离，外部只能通过对象提供的接口访问和修改数据。
- 继承性：允许一个类继承另一个类的属性和方法，实现代码的复用和扩展。
- 多态性：同一类型的对象可以在不同的情境下具有不同的行为，提高代码的灵活性和可扩展性。
- 抽象性：通过抽象类和接口定义一种共同的行为标准，提供了一种规范化的设计模式。
- 封装性：通过将数据和方法封装在对象中，实现了对数据的保护和隔离，外部只能通过对象提供的接口访问和修改数据。

## 1.3 面向对象编程的优势和应用

面向对象编程具有以下优势和应用：

- 代码重用性：通过类和对象的复用，减少了代码的重复编写，提高了开发效率。
- 程序结构清晰：通过将功能相似的代码封装在对象中，使程序结构清晰，易于维护和扩展。
- 提高代码的可读性：通过将代码封装在对象中，使代码易于理解和阅读。
- 降低了代码的耦合性：通过对象之间的消息传递来实现交互，降低了代码的耦合性，提高了系统的可维护性和可扩展性。
- 提高了代码的重用性和可扩展性：通过继承和多态等特性，实现了代码的重用和扩展，减少了开发成本。

总结：本章介绍了面向对象编程的概念、Java语言的面向对象特性以及面向对象编程的优势和应用。下一章将详细介绍Java类和对象的定义和使用。

# 2. Java类和对象

### 2.1 类的定义和属性

在Java中，类是一种用来描述对象特征的模板。通过关键字`class`可以定义一个类，而类中的属性则描述了对象的特征和状态。属性可以是各种数据类型，如int、String等，也可以是其他类的对象。

public class Car {
    // 定义汽车类
    String brand;  // 汽车品牌
    int price;     // 汽车价格
}

上面的例子中，`Car`类包含了两个属性，分别是汽车的品牌和价格。接下来，我们来看如何创建对象并访问这些属性。

### 2.2 对象的创建和实例化

通过关键字`new`可以创建一个类的对象，也称为类的实例化。创建对象后，就可以使用`.`来访问对象的属性和方法。

public class Main {
    public static void main (String[] args) {
        // 创建Car类的对象
        Car car1 = new Car();
        // 访问对象的属性并赋值
        car1.brand = "Toyota";
        car1.price = 20000;
        // 输出对象的属性值
        System.out.println("Car brand: " + car1.brand);
        System.out.println("Car price: " + car1.price);
    }
}

在上面的例子中，我们创建了一个`Car`类的对象`car1`，并为它的品牌和价格属性赋值，然后输出这些属性值。

### 2.3 构造方法和析构方法

构造方法是一种特殊的方法，用于在创建对象时进行初始化操作。在Java中，构造方法的名称与类名相同，并且没有返回类型。如果没有显式地定义构造方法，Java会提供一个默认的构造方法。

public class Car {
    String brand;
    int price;

    // 构造方法
    public Car(String brand, int price) {
        this.brand = brand;
        this.price = price;
        System.out.println("A car object is created.");
    }
    // 析构方法（在Java中没有对应的析构方法，可使用finalize()方法进行类似操作）
    protected void finalize() {
        System.out.println("A car object is destroyed.");
    }
}

在上面的例子中，我们定义了一个带有参数的构造方法来初始化对象的属性，并且演示了类似析构方法的操作。接下来，我们将看到类和对象之间的更多关系。

### 2.4 类和对象之间的关系

类是对象的模板，对象则是类的实例。一个类可以创建多个对象，每个对象都有自己的属性值。通过封装、继承和多态等特性，类和对象之间可以建立更加复杂的关系，从而实现更加灵活和可复用的代码结构。

通过本节的学习，读者可以了解到Java中类和对象的定义、创建和关系，以及构造方法和析构方法的概念。接下来的章节将继续介绍Java面向对象编程的其他基础知识，让读者对面向对象编程有更深入的了解。

# 3. Java封装性和继承性

#### 3.1 封装性的概念和用法
封装是面向对象编程的核心特性之一，它将数据和操作封装在一个类中，以实现对数据的保护和隐藏。通过封装，我们可以控制对数据的访问权限，并确保数据的一致性和完整性。

在Java中，封装性可以通过使用访问修饰符来实现。常用的访问修饰符有public、protected、private和默认（即不使用任何修饰符）。public修饰符表示对外公开，任何地方都可以访问；protected修饰符表示只允许子类访问；private修饰符表示只允许当前类内部访问；默认修饰符表示只允许同一个包中的类访问。

下面是一个示例代码，演示了封装的用法：

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        this.age = age;
    }
}

在上面的例子中，我们定义了一个Person类，该类有两个私有属性name和age。通过getName和getAge方法可以获取name和age的值，而通过setName和setAge方法可以设置name和age的值。这样一来，外部代码就不能直接访问name和age，只能通过公开的方法来间接操作。在setAge方法中加入了合法性检查，确保了age的取值范围合法。

#### 3.2 继承性的概念和用法
继承是面向对象编程中一种重要的关系，它允许我们创建一个新的派生类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。

在Java中，使用关键字extends来表示一个类继承另一个类。子类继承了父类的属性和方法，同时可以根据需要添加新的属性和方法，或重写父类的方法。父类也称为基类或超类，子类也称为派生类。

下面是一个示例代码，演示了继承的用法：

public class Animal {
    protected String name;

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

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

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

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

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

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

在上面的例子中，Animal类是一个基类，它有一个属性name和一个eat方法。Cat类和Dog类都是Animal类的子类，它们继承了name属性和eat方法，并可以添加自己的方法。Cat类有一个meow方法，Dog类有一个bark方法。

#### 3.3 类之间的继承关系
在Java中，类之间的继承关系可以是单继承或多继承。单继承表示一个子类只能继承一个父类，而多继承表示一个子类可以同时继承多个父类。在Java中，由于单继承的局限性和多继承的复杂性，只支持单继承。

除了直接继承，Java还支持多层继承的概念。多层继承表示一个子类可以继承自一个父类的子类。例如，类A继承自类B，类B继承自类C，那么类A就直接继承自类B，间接继承自类C。

下面是一个示例代码，演示了继承关系：

public class Vehicle {
    protected String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println(brand + " is starting");
    }
}

public class Car extends Vehicle {
    public Car(String brand) {
        super(brand);
    }

    public void accelerate() {
        System.out.println(brand + " is accelerating");
    }
}

public class ElectricCar extends Car {
    public ElectricCar(String brand) {
        super(brand);
    }

    public void charge() {
        System.out.println(brand + " is charging");
    }
}

在上面的例子中，Vehicle类是一个基类，Car类继承自Vehicle类，ElectricCar类继承自Car类。ElectricCar类直接继承自Car类，间接继承自Vehicle类。

#### 3.4 继承的优缺点和设计原则
继承带来了一些优势和缺点，我们需要根据具体的场景来考虑是否使用继承。

继承的优势：
- 代码重用：子类可以继承父类的属性和方法，避免重复编写相同的代码。
- 扩展性：子类可以添加新的属性和方法，实现对父类的扩展。
- 多态性：通过继承，可以实现多态性，提高代码的灵活性和可维护性。

继承的缺点：
- 耦合性增强：子类与父类之间存在紧密的关联，一旦父类发生变化，子类也需要进行相应的修改。
- 继承层次过深：当继承层次过深时，类与类之间的关系复杂，增加系统的复杂性。
- 难以理解和维护：当类之间的继承关系复杂时，代码可读性和可维护性会降低。

在设计中，我们可以采用以下原则来合理应用继承：
- 单一职责原则：一个类只应该有一个单一的功能，不要让一个类承担过多的责任。
- 里氏替换原则：子类必须能够替换父类并且能够正常工作，不破坏程序的正确性。
- 开闭原则：对扩展开放，对修改关闭，通过继承来实现对父类的扩展而不修改父类的代码。

通过合理应用封装性和继承性，可以提高代码的可复用性、可维护性和可扩展性，从而使系统更加稳定和易于开发。

# 4. Java多态性

#### 4.1 多态性的定义和实现
在面向对象编程中，多态性是指通过子类对象来调用父类的方法，实现不同形态的表现。多态性实现的关键是方法的重写和接口的实现。通过多态性可以提高代码的灵活性和可扩展性。

// 父类
class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

// 子类1
class Dog extends Animal {
    public void sound() {
        System.out.println("狗汪汪叫");
    }
}

// 子类2
class Cat extends Animal {
    public void sound() {
        System.out.println("猫喵喵叫");
    }
}

// 多态性实现
public class PolymorphismExample {
    public static void main(String[] args) {
        Animal dog = new Dog(); // 多态
        Animal cat = new Cat(); // 多态
        dog.sound(); // 输出：狗汪汪叫
        cat.sound(); // 输出：猫喵喵叫
    }
}

**代码总结：** 上述代码展示了多态性的实现方法，通过将不同子类的对象赋值给父类的引用变量，实现了不同形态的调用。

**结果说明：** 程序运行结果会分别输出狗汪汪叫和猫喵喵叫，实现了不同子类对象的动态调用。

#### 4.2 抽象类和接口的应用
在Java中，抽象类和接口是实现多态性的重要手段。抽象类是具有抽象方法的类，不能被实例化，需要子类实现其中的抽象方法；接口则是定义了一组抽象方法的引用类型，可以被类实现。通过抽象类和接口，可以实现不同类对同一方法的不同实现，从而实现多态性。

// 抽象类
abstract class Shape {
    abstract void draw();
}

// 子类1
class Circle extends Shape {
    void draw() {
        System.out.println("画圆形");
    }
}

// 子类2
class Rectangle extends Shape {
    void draw() {
        System.out.println("画矩形");
    }
}

// 多态性实现
public class PolymorphismExample2 {
    public static void main(String[] args) {
        Shape circle = new Circle(); // 多态
        Shape rectangle = new Rectangle(); // 多态
        circle.draw(); // 输出：画圆形
        rectangle.draw(); // 输出：画矩形
    }
}

**代码总结：** 上述代码展示了抽象类和接口的应用，通过多态性实现了不同子类对抽象方法的不同实现。

**结果说明：** 程序运行结果会分别输出画圆形和画矩形，实现了抽象类和接口的多态性应用。

#### 4.3 方法的重写和重载
在Java中，方法的重写指子类实现了父类的方法，覆盖了父类的方法实现；方法的重载指在一个类中出现了多个同名方法，但参数列表不同。通过方法的重写和重载，可以实现相同方法在不同类中的不同实现，从而实现多态性。

// 父类
class Shape {
    public void draw() {
        System.out.println("绘制形状");
    }
}

// 子类
class Circle extends Shape {
    public void draw() { // 方法重写
        System.out.println("绘制圆形");
    }
    public void draw(String color) { // 方法重载
        System.out.println("用" + color + "颜色绘制圆形");
    }
}

// 多态性实现
public class PolymorphismExample3 {
    public static void main(String[] args) {
        Shape circle = new Circle(); // 多态
        circle.draw(); // 输出：绘制圆形
        ((Circle) circle).draw("红色"); // 输出：用红色颜色绘制圆形
    }
}

**代码总结：** 上述代码展示了方法的重写和重载，通过多态性实现了不同形式的方法调用。

**结果说明：** 程序运行结果会分别输出绘制圆形和用红色颜色绘制圆形，实现了方法的重写和重载的多态性应用。

#### 4.4 多态性的优势和使用场景
多态性的优势在于增加了程序的灵活性和扩展性，可以更加方便地进行代码的维护和扩展。多态性的使用场景包括需要将同一操作作用于不同类型的对象时，以及需要统一接口对不同实现进行调用时，都可以使用多态性来实现。

多态性是面向对象编程中重要的特性，通过合理使用多态性，可以使程序结构更加清晰灵活，减少代码的重复性，提高代码的可维护性和可扩展性。

# 5. Java异常处理
异常处理是处理程序中出现的错误或异常情况的机制。Java提供了丰富的异常类和异常处理机制，使开发人员能够更好地处理异常情况，保证程序的稳定性和可靠性。

### 5.1 异常的分类和常见异常
在Java中，异常分为检查异常（Checked Exception）和非检查异常（Unchecked Exception）。检查异常是在编译时期需要进行处理的异常，而非检查异常是指不需要在编译时期强制处理的异常。

常见的异常包括：
- NullPointerException（空指针异常）：当试图访问null对象或调用null对象的方法时，会抛出空指针异常。
- ArrayIndexOutOfBoundsException（数组下标越界异常）：当访问数组时，如果下标超出了数组的范围，就会抛出数组下标越界异常。
- ArithmeticException（算术异常）：当进行除法操作时，若除数为0，就会抛出算术异常。
- FileNotFoundException（文件未找到异常）：当试图打开一个不存在的文件时，会抛出文件未找到异常。

### 5.2 异常处理机制
Java提供了try-catch语句来处理异常。try块中包含可能出现异常的代码，catch块用于捕获并处理异常。

try {
    // 可能会抛出异常的代码块
    // ...
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
    // ...
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
    // ...
} finally {
    // 不管是否发生异常，都会执行的代码块
    // ...
}

catch块可以包含多个，用于处理不同类型的异常。如果某个catch块捕获到了异常，就会执行对应的处理逻辑。finally块中的代码无论是否发生异常，都会被执行。

### 5.3 try-catch语句的使用
以下是一个简单的示例，演示了try-catch语句的使用：

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } finally {
            System.out.println("程序执行完毕");
        }
    }
    public static int divide(int num1, int num2) {
        return num1 / num2;
    }
}

在上述示例中，我们调用了一个自定义的divide方法，此方法用于执行除法操作。在main方法中，我们传入10和0作为参数调用了divide方法，在执行除法操作时会抛出算术异常（除数为0），catch块捕获到了该异常并打印出相应的提示信息。无论是否发生异常，finally块中的代码都会被执行，其中我们打印了程序执行完毕的提示信息。

### 5.4 异常的抛出和捕获
除了在方法内部使用try-catch语句处理异常外，还可以在方法声明中使用throws关键字抛出异常，让调用该方法的地方来处理异常。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }
    }
    public static void divide(int num1, int num2) throws ArithmeticException {
        if (num2 == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        System.out.println("结果：" + num1 / num2);
    }
}

在上述示例中，我们将divide方法的声明中抛出了算术异常，即如果方法内部发生了除数为0的情况，就会抛出算术异常。在main方法中调用divide方法时，我们使用try-catch语句捕获并处理了这个异常。

通过合理使用try-catch语句和抛出异常，可以提高程序的健壮性和可维护性，更好地处理异常情况，保证程序的正确运行。

# 6. Java面向对象编程实例

#### 6.1 实例：图书管理系统

// 代码示例
public class Book {
    private String title;
    private String author;
    private int pages;

    // 构造方法
    public Book(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
    }

    // Getter和Setter方法
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getPages() {
        return pages;
    }

    public void setPages(int pages) {
        this.pages = pages;
    }

    // 其他方法
    public void displayInfo() {
        System.out.println("Title: " + title + ", Author: " + author + ", Pages: " + pages);
    }
}

public class Library {
    private ArrayList<Book> books;

    public Library() {
        books = new ArrayList<>();
    }

    public void addBook(Book book) {
        books.add(book);
    }

    public void displayAllBooks() {
        for (Book book : books) {
            book.displayInfo();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Book book1 = new Book("Java Programming", "John Smith", 350);
        Book book2 = new Book("Python for Beginners", "Alice Johnson", 280);

        Library library = new Library();
        library.addBook(book1);
        library.addBook(book2);

        library.displayAllBooks();
    }
}

代码总结：上述代码实现了一个简单的图书管理系统。Book类表示图书，包含书名、作者和页数属性，以及相应的构造方法和显示信息方法。Library类表示图书馆，包含了一个用于存储图书的ArrayList，以及添加图书和展示所有图书的方法。Main类为程序入口，创建图书对象并加入图书馆，然后展示所有图书信息。

结果说明：运行Main类的main方法将输出两本图书的信息，包括书名、作者和页数。

在这个实例中，读者可以学习到如何创建和使用类、对象以及类之间的关系，加深对Java面向对象编程的理解。

#### 6.2 实例：学生选课系统

// 代码示例
public class Student {
    private String name;
    private int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // Getter和Setter方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void enrollCourse(String courseName) {
        System.out.println(name + " enrolled in the course: " + courseName);
    }
}

public class Course {
    private String courseName;
    private int courseId;

    public Course(String courseName, int courseId) {
        this.courseName = courseName;
        this.courseId = courseId;
    }

    // Getter和Setter方法

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public int getCourseId() {
        return courseId;
    }

    public void setCourseId(int courseId) {
        this.courseId = courseId;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("Alice", 1001);
        Course course1 = new Course("Java Programming", 101);
        Course course2 = new Course("Python for Beginners", 102);

        student1.enrollCourse(course1.getCourseName());
        student1.enrollCourse(course2.getCourseName());
    }
}

代码总结：上述代码实现了一个简单的学生选课系统。Student类表示学生，包含姓名和学号属性，以及选课方法。Course类表示课程，包含课程名和课程编号属性。Main类为程序入口，创建学生对象和课程对象，然后学生选择课程并输出选择结果。

结果说明：运行Main类的main方法将输出学生选择的课程信息。

这个实例中展示了如何使用面向对象的思想来设计学生选课系统，包括学生和课程的类的设计，以及类之间的交互。

#### 6.3 实例：银行账户管理系统

// 代码示例
public class BankAccount {
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // 存款
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited " + amount + " dollars, new balance is " + balance);
    }

    // 取款
    public void withdraw(double amount) {
        if (amount > balance) {
            System.out.println("Insufficient funds");
        } else {
            balance -= amount;
            System.out.println("Withdrawn " + amount + " dollars, new balance is " + balance);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456", 1000.0);
        account.deposit(500.0);
        account.withdraw(200.0);
        account.withdraw(1500.0);
    }
}

代码总结：上述代码实现了一个简单的银行账户管理系统。BankAccount类表示银行账户，包含账号和余额属性，以及存款和取款方法。Main类为程序入口，创建银行账户对象，并进行存款和取款操作。

结果说明：运行Main类的main方法将输出存款和取款操作的结果，包括存款后的余额、成功取款后的余额以及取款超出余额的提示。

这个实例展示了如何使用类和对象来实现银行账户的管理，通过具体的存款和取款操作，加深对面向对象编程的理解。

#### 6.4 实例：汽车租赁管理系统

// 代码示例
public class Car {
    private String carNumber;
    private boolean isAvailable;

    public Car(String carNumber, boolean isAvailable) {
        this.carNumber = carNumber;
        this.isAvailable = isAvailable;
    }

    // 出租车辆
    public void rentCar() {
        if (isAvailable) {
            isAvailable = false;
            System.out.println("Car " + carNumber + " has been rented");
        } else {
            System.out.println("Car " + carNumber + " is not available for rent");
        }
    }

    // 归还车辆
    public void returnCar() {
        isAvailable = true;
        System.out.println("Car " + carNumber + " has been returned");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("001", true);
        Car car2 = new Car("002", false);

        car1.rentCar();
        car2.rentCar();
        car2.returnCar();
        car1.rentCar();
    }
}

代码总结：上述代码实现了一个简单的汽车租赁管理系统。Car类表示汽车，包含车牌号和是否可租赁属性，以及出租和归还方法。Main类为程序入口，创建汽车对象，进行汽车的出租和归还操作。

结果说明：运行Main类的main方法将输出汽车的出租和归还操作的结果。

这个实例展示了如何使用类和对象来实现汽车租赁管理，包括汽车的出租和归还操作，有助于读者理解面向对象编程的实际应用场景。