Java从入门到精通-类和对象（三）

1.6实践与练习

1.1 面向对象概述

基础练习题：

1.创建一个类Person，具有姓名和年龄两个成员变量，以及一个方法displayInfo()用于显示姓名和年龄。然后创建一个Person对象并调用displayInfo()方法。

public class Person {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法用于显示姓名和年龄
    public void displayInfo() {
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
    }

    public static void main(String[] args) {
        // 创建Person对象并初始化
        Person person1 = new Person("Alice", 25);

        // 调用displayInfo()方法来显示信息
        System.out.println("个人信息：");
        person1.displayInfo();
    }
}

代码释义：

1. 我们创建了一个名为Person的类，该类具有两个成员变量name（姓名）和age（年龄）。

2. 在构造方法中，我们接受两个参数，用于初始化成员变量name和age。

3. 类中有一个名为displayInfo()的成员方法，它用于显示姓名和年龄。

4. 在main方法中，我们创建了一个Person对象person1，并通过构造方法初始化了该对象的姓名和年龄。

5. 最后，我们调用person1对象的displayInfo()方法，显示了姓名和年龄信息。

代码总结：

在这个示例中，我们创建了一个Person类，演示了如何定义成员变量、构造方法和成员方法。通过创建一个Person对象，并调用displayInfo()方法，我们成功地显示了对象的姓名和年龄信息。这个示例帮助您理解了类和对象的基本概念，以及如何使用它们来组织和操作数据。

综合练习题：

2.创建一个类Rectangle，具有长度和宽度两个成员变量，以及一个方法calculateArea()用于计算矩形的面积。然后创建多个Rectangle对象，并计算它们的面积。

public class Rectangle {
    // 成员变量
    private double length;
    private double width;

    // 构造方法
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // 计算矩形的面积
    public double calculateArea() {
        return length * width;
    }

    public static void main(String[] args) {
        // 创建多个Rectangle对象并初始化
        Rectangle rectangle1 = new Rectangle(5.0, 4.0);
        Rectangle rectangle2 = new Rectangle(3.0, 7.0);
        Rectangle rectangle3 = new Rectangle(6.0, 2.5);

        // 计算并打印矩形的面积
        System.out.println("矩形1的面积：" + rectangle1.calculateArea());
        System.out.println("矩形2的面积：" + rectangle2.calculateArea());
        System.out.println("矩形3的面积：" + rectangle3.calculateArea());
    }
}

代码释义：

1. 我们创建了一个名为Rectangle的类，该类有两个成员变量length（长度）和width（宽度）。

2. 在构造方法中，我们接受两个参数，用于初始化成员变量length和width。

3. 类中有一个名为calculateArea()的成员方法，用于计算矩形的面积，即length * width。

4. 在main方法中，我们创建了三个Rectangle对象，并通过构造方法初始化了它们的长度和宽度。

5. 最后，我们调用每个矩形对象的calculateArea()方法来计算并打印矩形的面积。

代码总结：

这个示例演示了如何创建一个Rectangle类，定义成员变量和方法，以及如何创建多个对象并使用它们的方法来计算矩形的面积。这有助于理解如何在面向对象编程中使用类和对象来组织和操作数据。

1.2 类

基础练习题：

3.创建一个类Car，具有品牌和型号两个成员变量，以及一个方法startEngine()用于启动汽车引擎。然后创建一个Car对象并调用startEngine()方法。

public class Car {
    // 成员变量
    private String brand;
    private String model;

    // 构造方法
    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    // 启动汽车引擎
    public void startEngine() {
        System.out.println("启动" + brand + " " + model + "的引擎");
    }

    public static void main(String[] args) {
        // 创建Car对象并初始化
        Car myCar = new Car("Toyota", "Camry");

        // 调用startEngine()方法来启动汽车引擎
        myCar.startEngine();
    }
}

代码释义：

1. 创建一个名为Car的类，该类有两个成员变量brand（品牌）和model（型号）。

2. 在构造方法中，接受两个参数，用于初始化成员变量brand和model。

3. 类中有一个名为startEngine()的成员方法，用于启动汽车引擎，并在控制台上显示启动信息。

4. 在main方法中，创建一个Car对象myCar，并通过构造方法初始化了它的品牌和型号。

5. 最后，调用myCar对象的startEngine()方法来启动汽车引擎。

代码总结：

示例演示了如何创建一个Car类，定义成员变量和方法，以及如何创建一个对象并调用其方法来执行操作。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

综合练习题：

4.创建一个类Circle，具有半径成员变量和一个方法calculateArea()用于计算圆的面积。然后创建多个Circle对象，并计算它们的面积。

public class Circle {
    // 成员变量
    private double radius;

    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

    // 计算圆的面积
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        // 创建多个Circle对象并初始化
        Circle circle1 = new Circle(3.0);
        Circle circle2 = new Circle(5.0);
        Circle circle3 = new Circle(2.5);

        // 计算并打印圆的面积
        System.out.println("圆1的面积：" + circle1.calculateArea());
        System.out.println("圆2的面积：" + circle2.calculateArea());
        System.out.println("圆3的面积：" + circle3.calculateArea());
    }
}

代码释义：

1. 创建一个名为Circle的类，该类有一个成员变量radius（半径）。

2. 在构造方法中，接受一个参数，用于初始化成员变量radius。

3. 类中有一个名为calculateArea()的成员方法，用于计算圆的面积，即Math.PI * radius * radius。

4. 在main方法中，创建三个Circle对象，分别代表不同半径的圆，并通过构造方法初始化它们的半径。

5. 最后，调用每个圆对象的calculateArea()方法来计算并打印圆的面积。

代码总结：

示例演示了如何创建一个Circle类，定义成员变量和方法，以及如何创建多个对象并调用其方法来执行操作。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

1.3 类的构造方法

基础练习题：

4.创建一个类Book，具有书名和作者两个成员变量，以及一个带参数的构造方法用于初始化这两个成员变量。然后创建多个Book对象，并初始化它们的属性。

public class Book {
    // 成员变量
    private String title;
    private String author;

    // 带参数的构造方法
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public static void main(String[] args) {
        // 创建多个Book对象并初始化
        Book book1 = new Book("Java Programming", "John Smith");
        Book book2 = new Book("Python Basics", "Alice Johnson");
        Book book3 = new Book("C++ Fundamentals", "David Brown");

        // 打印书籍信息
        System.out.println("书籍1：" + book1.title + "，作者：" + book1.author);
        System.out.println("书籍2：" + book2.title + "，作者：" + book2.author);
        System.out.println("书籍3：" + book3.title + "，作者：" + book3.author);
    }
}

代码释义：

1. 创建一个名为Book的类，该类有两个成员变量title（书名）和author（作者）。

2. 在构造方法中，接受两个参数，用于初始化成员变量title和author。

3. 在main方法中，创建三个Book对象，每个对象代表一本书，并通过构造方法初始化了它们的书名和作者。

4. 最后，打印每本书的信息，包括书名和作者。

代码总结：

示例演示了如何创建一个Book类，定义成员变量和带参数的构造方法，以及如何创建多个对象并初始化它们的属性。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

综合练习题：

1. 创建一个类Employee，具有姓名、工号和薪水三个成员变量，以及一个带参数的构造方法用于初始化这些成员变量。然后创建多个Employee对象，并初始化它们的属性。

public class Employee {
    // 成员变量
    private String name;
    private int employeeId;
    private double salary;

    // 带参数的构造方法
    public Employee(String name, int employeeId, double salary) {
        this.name = name;
        this.employeeId = employeeId;
        this.salary = salary;
    }

    public static void main(String[] args) {
        // 创建多个Employee对象并初始化
        Employee employee1 = new Employee("John Smith", 101, 50000.0);
        Employee employee2 = new Employee("Alice Johnson", 102, 60000.0);
        Employee employee3 = new Employee("David Brown", 103, 55000.0);

        // 打印员工信息
        System.out.println("员工1：" + employee1.name + "，工号：" + employee1.employeeId + "，薪水：" + employee1.salary);
        System.out.println("员工2：" + employee2.name + "，工号：" + employee2.employeeId + "，薪水：" + employee2.salary);
        System.out.println("员工3：" + employee3.name + "，工号：" + employee3.employeeId + "，薪水：" + employee3.salary);
    }
}

代码释义：

1. 创建一个名为Employee的类，该类有三个成员变量name（姓名）、employeeId（工号）和salary（薪水）。

2. 在构造方法中，接受三个参数，用于初始化成员变量name、employeeId和salary。

3. 在main方法中，创建三个Employee对象，每个对象代表一个员工，并通过构造方法初始化了他们的姓名、工号和薪水。

4. 最后，打印每个员工的信息，包括姓名、工号和薪水。

代码总结：

示例演示了如何创建一个Employee类，定义成员变量和带参数的构造方法，以及如何创建多个对象并初始化它们的属性。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

1.4 静态变量和静态方法

基础练习题：

7.创建一个类MathOperations，具有静态方法add()和subtract()，用于执行加法和减法操作。然后在main方法中调用这些静态方法。

public class MathOperations {
    // 静态方法：加法
    public static int add(int a, int b) {
        return a + b;
    }

    // 静态方法：减法
    public static int subtract(int a, int b) {
        return a - b;
    }

    public static void main(String[] args) {
        // 调用add()方法进行加法操作
        int sum = MathOperations.add(10, 5);
        System.out.println("10 + 5 = " + sum);

        // 调用subtract()方法进行减法操作
        int difference = MathOperations.subtract(20, 8);
        System.out.println("20 - 8 = " + difference);
    }
}

代码释义：

1. 创建一个名为MathOperations的类，该类具有两个静态方法：add()用于加法操作，subtract()用于减法操作。

2. 静态方法add()接受两个整数参数a和b，执行加法并返回结果。

3. 静态方法subtract()接受两个整数参数a和b，执行减法并返回结果。

4. 在main方法中，调用了MathOperations类的静态方法add()和subtract()来执行加法和减法操作，并将结果打印到控制台。

代码总结：

示例演示了如何创建一个MathOperations类，定义静态方法来执行加法和减法操作，以及如何在main方法中调用这些静态方法。静态方法可以在不创建对象的情况下使用，用于执行通用的操作。这有助于理解如何使用静态方法来组织和执行代码。

综合练习题：

7.创建一个类Product，具有商品名称、价格和库存数量三个成员变量，以及静态变量totalProducts用于跟踪总商品数量。编写构造方法来初始化成员变量，并在每次创建新对象时更新totalProducts。

public class Product {
    // 成员变量
    private String productName;
    private double price;
    private int quantity;

    // 静态变量：总商品数量
    private static int totalProducts = 0;

    // 带参数的构造方法
    public Product(String productName, double price, int quantity) {
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
        totalProducts++; // 每次创建新对象时更新总商品数量
    }

    public static void main(String[] args) {
        // 创建多个Product对象并初始化
        Product product1 = new Product("Laptop", 899.99, 10);
        Product product2 = new Product("Smartphone", 499.99, 20);

        // 打印商品信息和总商品数量
        System.out.println("商品1：" + product1.productName + "，价格：" + product1.price + "，库存数量：" + product1.quantity);
        System.out.println("商品2：" + product2.productName + "，价格：" + product2.price + "，库存数量：" + product2.quantity);

        System.out.println("总商品数量：" + Product.totalProducts);
    }
}

代码释义：

1. 创建一个名为Product的类，该类有三个成员变量productName（商品名称）、price（价格）和quantity（库存数量）。

2. 静态变量totalProducts用于跟踪总商品数量，并在每次创建新对象时更新。

3. 带参数的构造方法接受商品名称、价格和库存数量，用于初始化成员变量，并在构造方法中递增totalProducts来更新总商品数量。

4. 在main方法中，我们创建了两个Product对象，每个对象代表一种商品，并通过构造方法初始化它们的属性。

5. 最后，打印每种商品的信息和总商品数量。

代码总结：

示例演示了如何创建一个Product类，定义成员变量和静态变量，以及如何在构造方法中更新静态变量以跟踪总商品数量。这有助于理解如何使用静态变量来共享数据和状态。

综合练习题：

设计一个简单的学生管理系统，包括以下要求：

1. 创建一个Student类，包括学生的姓名、年龄和成绩作为成员变量。

2. 为Student类创建构造方法，用于初始化学生的姓名、年龄和成绩。

3. 创建一个School类，用于管理学生信息。School类应该包括一个存储学生对象的数组（或集合）。

4. School类应该提供以下功能：

   • 添加学生：能够向学校中添加新的学生信息。
   • 查找学生：能够根据学生的姓名查找学生信息并显示。
   • 显示所有学生信息：能够列出学校中所有学生的姓名、年龄和成绩。

5. 在main方法中，创建一个School对象，并模拟添加多个学生信息，然后测试查找学生和显示所有学生信息的功能。

提示：

• 需要创建Student类和School类，以及适当的成员变量和方法。
• 使用数组或集合来存储学生信息。
• 在main方法中，创建School对象并模拟添加学生信息，然后测试您的功能。

import java.util.ArrayList;

// 学生类
class Student {
    private String name;
    private int age;
    private double score;

    // 构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    // 获取学生姓名
    public String getName() {
        return name;
    }

    // 显示学生信息
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age + ", 成绩: " + score);
    }
}

// 学校类
class School {
    private ArrayList<Student> students = new ArrayList<>();

    // 添加学生
    public void addStudent(Student student) {
        students.add(student);
    }

    // 查找学生
    public Student findStudentByName(String name) {
        for (Student student : students) {
            if (student.getName().equals(name)) {
                return student;
            }
        }
        return null; // 如果找不到返回null
    }

    // 显示所有学生信息
    public void displayAllStudents() {
        System.out.println("学校所有学生信息：");
        for (Student student : students) {
            student.displayInfo();
        }
    }
}

public class StudentManagementSystem {
    public static void main(String[] args) {
        // 创建学校对象
        School school = new School();

        // 模拟添加学生信息
        school.addStudent(new Student("Alice", 18, 95.5));
        school.addStudent(new Student("Bob", 19, 88.0));
        school.addStudent(new Student("Charlie", 20, 92.5));

        // 测试查找学生和显示所有学生信息功能
        Student foundStudent = school.findStudentByName("Bob");
        if (foundStudent != null) {
            System.out.println("查找到的学生信息：");
            foundStudent.displayInfo();
        } else {
            System.out.println("未找到该学生！");
        }

        school.displayAllStudents();
    }
}

解释：

1. 创建了一个Student类，其中包括学生的姓名、年龄和成绩作为成员变量，并提供了构造方法和显示学生信息的方法。

2. 创建了一个School类，该类使用ArrayList来存储学生对象，并提供了添加学生、查找学生和显示所有学生信息的方法。

3. 在main方法中，我们创建了一个School对象，并模拟添加了多个学生信息。然后，我们测试了查找学生和显示所有学生信息的功能。