《Java 简易速速上手小册》第2章：面向对象的 Java（2024 最新版）

江帅帅2024-02-19 15:44

文章目录

  • [2.1 类和对象 - 构建你的小宇宙](#2.1 类和对象 - 构建你的小宇宙)
    • [2.1.1 基础知识](#2.1.1 基础知识)
    • [2.1.2 重点案例：设计一个简单的图书类](#2.1.2 重点案例：设计一个简单的图书类)
    • [2.1.3 拓展案例 1：学生管理系统](#2.1.3 拓展案例 1：学生管理系统)
    • [2.1.4 拓展案例 2：账户管理系统](#2.1.4 拓展案例 2：账户管理系统)
  • [2.2 继承与多态 - 让一切变得更有趣](#2.2 继承与多态 - 让一切变得更有趣)
    • [2.2.1 基础知识](#2.2.1 基础知识)
    • [2.2.2 重点案例：动物园管理系统](#2.2.2 重点案例：动物园管理系统)
    • [2.2.3 拓展案例 1：图形界面组件](#2.2.3 拓展案例 1：图形界面组件)
    • [2.2.4 拓展案例 2：支付系统](#2.2.4 拓展案例 2：支付系统)
  • [2.3 封装与抽象 - 保持秘密的艺术](#2.3 封装与抽象 - 保持秘密的艺术)
    • [2.3.1 基础知识](#2.3.1 基础知识)
    • [2.3.2 重点案例：银行账户管理系统](#2.3.2 重点案例：银行账户管理系统)
    • [2.3.3 拓展案例 1：员工管理系统](#2.3.3 拓展案例 1：员工管理系统)
    • [2.3.4 拓展案例 2：图形界面组件库](#2.3.4 拓展案例 2：图形界面组件库)

2.1 类和对象 - 构建你的小宇宙

在 Java 的宇宙中，一切都围绕着类和对象展开。理解这个概念是迈向 Java 大师之路的关键一步。让我们深入挖掘这个概念，探索如何利用它来构建我们自己的编程宇宙。

2.1.1 基础知识

  • 类（Class）：类是一个蓝图，定义了创建对象（实例）时所需的状态和行为。状态由属性（变量）表示，行为由方法（函数）表示。想象你正在设计一个机器人，你需要决定它有哪些功能（方法）和属性（变量）。

  • 对象（Object）：对象是根据类的定义创建的实例。如果类是蓝图，那么对象就是根据这个蓝图建造的房子。每个对象都拥有自己的状态，能够执行定义在其类中的操作。

  • 实例化 ：创建对象的过程称为实例化。通过使用 new 关键字和类的构造器（Constructor）来实现。

  • 构造器（Constructor）：构造器是一种特殊的方法，用于在创建对象时初始化对象的状态。构造器的名称必须与类名完全相同。

2.1.2 重点案例：设计一个简单的图书类

假设我们要在一个图书管理系统中管理图书，我们需要创建一个 Book 类来代表每本图书。

java 复制代码 
class Book {
    String title;
    String author;
    int yearPublished;

    // 构造器
    public Book(String title, String author, int yearPublished) {
        this.title = title;
        this.author = author;
        this.yearPublished = yearPublished;
    }

    // 显示图书信息的方法
    public void displayInfo() {
        System.out.println(title + " by " + author + ", published in " + yearPublished);
    }
}

public class Library {
    public static void main(String[] args) {
        // 创建 Book 对象
        Book myBook = new Book("Effective Java", "Joshua Bloch", 2008);
        // 调用方法显示图书信息
        myBook.displayInfo();
    }
}

2.1.3 拓展案例 1：学生管理系统

在一个学生管理系统中，我们需要处理学生的信息，如姓名、学号和成绩。

java 复制代码 
class Student {
    String name;
    String studentID;
    double grade;

    public Student(String name, String studentID, double grade) {
        this.name = name;
        this.studentID = studentID;
        this.grade = grade;
    }

    public void displayStudentInfo() {
        System.out.println("Student: " + name + " (ID: " + studentID + "), Grade: " + grade);
    }
}

public class School {
    public static void main(String[] args) {
        Student student1 = new Student("Alice", "S001", 3.5);
        student1.displayStudentInfo();
    }
}

2.1.4 拓展案例 2：账户管理系统

在一个账户管理系统中，我们可能需要管理用户的账户，包括账户名、余额和密码。

java 复制代码 
class Account {
    String accountName;
    double balance;
    String password;

    public Account(String accountName, double balance, String password) {
        this.accountName = accountName;
        this.balance = balance;
        this.password = password;
    }

    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposit successful. New balance: " + balance);
    }

    public void withdraw(double amount, String password) {
        if (this.password.equals(password)) {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("Withdrawal successful. New balance: " + balance);
            } else {
                System.out.println("Insufficient funds.");
            }
        } else {
            System.out.println("Invalid password.");
        }
    }
}

public class Bank {
    public static void main(String[] args) {
        Account myAccount = new Account("JohnDoe", 1000, "password123");
        myAccount.deposit(500);
        myAccount.with

draw(200, "password123");
    }
}

通过这些案例，我们可以看到类和对象如何成为构建 Java 应用程序的基础。每个案例都展示了如何定义类，创建对象，以及如何使用对象的状态和行为来执行具体的任务。随着你对这些概念的深入了解，你将能够创建更复杂、功能更强大的 Java 程序。

2.2 继承与多态 - 让一切变得更有趣

在 Java 的奇妙世界里，继承和多态是两个让编程变得更加有趣和强大的概念。通过这两个特性，你可以编写出更简洁、更灵活且易于维护的代码。让我们深入探讨这些概念，并通过一些实际案例来展示它们的威力。

2.2.1 基础知识

  • 继承（Inheritance）：继承允许一个类（子类）继承另一个类（父类）的属性和方法。这意味着你可以创建一个通用的类，然后通过继承来扩展或修改这个类的功能，而不需要从头开始编写。

  • 多态（Polymorphism）：多态允许你使用一个统一的接口来操作不同类型的对象。在运行时，Java 虚拟机（JVM）会确定对象的实际类型，调用相应类的方法。这使得你可以编写更通用和灵活的代码。

2.2.2 重点案例：动物园管理系统

假设我们正在为一个动物园创建一个管理系统。在这个系统中，我们需要处理各种类型的动物，比如狮子、老虎和鹦鹉。

基类：Animal

java 复制代码 
abstract class Animal {
    String name;

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

    abstract void makeSound();
}

子类：Lion

java 复制代码 
class Lion extends Animal {
    public Lion(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Roar");
    }
}

子类：Parrot

java 复制代码 
class Parrot extends Animal {
    public Parrot(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Squawk");
    }
}

演示多态

java 复制代码 
public class Zoo {
    public static void main(String[] args) {
        Animal myLion = new Lion("Leo");
        Animal myParrot = new Parrot("Polly");
        
        myLion.makeSound();
        myParrot.makeSound();
    }
}

在这个案例中，Animal 类是一个抽象基类，定义了一个抽象方法 makeSound()。Lion 和 Parrot 类继承自 Animal 类，并提供了 makeSound() 方法的具体实现。这个例子展示了如何通过继承和多态来处理不同类型的动物，同时保持代码的简洁和灵活性。

2.2.3 拓展案例 1：图形界面组件

在创建图形用户界面（GUI）时，我们可能需要处理各种类型的组件，比如按钮、文本框和复选框。我们可以定义一个通用的 Component 类，然后让所有具体的组件类继承自这个类。

java 复制代码 
abstract class Component {
    abstract void draw();
}

class Button extends Component {
    @Override
    void draw() {
        System.out.println("Drawing a button");
    }
}

class TextBox extends Component {
    @Override
    void draw() {
        System.out.println("Drawing a text box");
    }
}

使用多态来处理不同的组件：

java 复制代码 
public class GUI {
    public static void main(String[] args) {
        Component button = new Button();
        Component textBox = new TextBox();
        
        button.draw();
        textBox.draw();
    }
}

2.2.4 拓展案例 2：支付系统

在一个电子商务平台的支付系统中，我们需要处理不同类型的支付方式，比如信用卡支付、PayPal 支付和银行转账。

java 复制代码 
abstract class PaymentMethod {
    abstract void pay(double amount);
}

class CreditCard extends PaymentMethod {
    @Override
    void pay(double amount) {
        System.out.println("Paying $" + amount

 + " with credit card");
    }
}

class PayPal extends PaymentMethod {
    @Override
    void pay(double amount) {
        System.out.println("Paying $" + amount + " with PayPal");
    }
}

使用多态进行支付：

java 复制代码 
public class ECommerce {
    public static void main(String[] args) {
        PaymentMethod myCreditCard = new CreditCard();
        PaymentMethod myPayPal = new PayPal();
        
        myCreditCard.pay(100.0);
        myPayPal.pay(75.0);
    }
}

通过这些案例，我们可以看到继承和多态如何使得 Java 编程变得更加灵活和强大。通过使用这些特性，你可以编写出既简洁又易于维护的代码，轻松应对各种编程挑战。

2.3 封装与抽象 - 保持秘密的艺术

在 Java 的世界中，封装和抽象是保持代码整洁、安全和灵活的两个基石。通过这两种机制，我们可以隐藏实现细节，只暴露必要的接口给外界使用。这不仅可以防止数据被不当访问，还能使得代码更易于理解和维护。

2.3.1 基础知识

  • 封装（Encapsulation） ：封装是通过将数据（属性）和操作数据的方法捆绑在一起的编程技术。在 Java 中，通过将类的成员变量设为 private，然后通过 public 方法（getter 和 setter）来访问和修改这些变量，实现封装。

  • 抽象（Abstraction）：抽象是一种将复杂性隐藏起来，只显示最关键的信息的方法。在 Java 中，抽象类和接口是实现抽象的两种主要方式。抽象类可以包含抽象方法（没有实现的方法），而接口则可以定义一组方法规范，由其他类来实现。

2.3.2 重点案例：银行账户管理系统

假设我们要设计一个银行账户管理系统，这个系统需要处理各种类型的账户，如储蓄账户和支票账户，同时保护账户信息并提供账户操作。

抽象类：Account

java 复制代码 
abstract class Account {
    private String accountNumber;
    private double balance;

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

    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    abstract void withdraw(double amount); // 抽象方法

    @Override
    public String toString() {
        return "Account{" +
               "accountNumber='" + accountNumber + '\'' +
               ", balance=" + balance +
               '}';
    }
}

具体类：SavingsAccount 和 CheckingAccount

java 复制代码 
class SavingsAccount extends Account {
    private double interestRate;

    public SavingsAccount(String accountNumber, double balance, double interestRate) {
        super(accountNumber, balance);
        this.interestRate = interestRate;
    }

    @Override
    void withdraw(double amount) {
        if (getBalance() >= amount) {
            System.out.println("Withdrawing from Savings Account");
        }
    }
}

class CheckingAccount extends Account {
    private double overdraftLimit;

    public CheckingAccount(String accountNumber, double balance, double overdraftLimit) {
        super(accountNumber, balance);
        this.overdraftLimit = overdraftLimit;
    }

    @Override
    void withdraw(double amount) {
        if (getBalance() + overdraftLimit >= amount) {
            System.out.println("Withdrawing from Checking Account");
        }
    }
}

2.3.3 拓展案例 1：员工管理系统

在一个公司的员工管理系统中，我们需要处理不同种类的员工，如正式员工和临时员工，同时管理他们的基本信息和薪资。

抽象类：Employee

java 复制代码 
abstract class Employee {
    private String id;
    private String name;

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

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    abstract double calculateSalary(); // 计算薪资的抽象方法
}

具体类：RegularEmployee 和 TemporaryEmployee

java 复制代码 
class RegularEmployee extends Employee {
    private double annualSalary;

    public RegularEmployee(String id, String name, double annualSalary) {
        super(id, name);
        this.annualSalary = annualSalary;
    }

    @Override
    double calculateSalary() {
        return annualSalary / 12;
    }
}

class TemporaryEmployee extends Employee {
    private double hourlyRate;
    private int hoursWorked;

    public TemporaryEmployee(String id, String name, double hourlyRate, int hoursWorked) {
        super(id, name);
        this.hourlyRate = hourly

Rate;
        this.hoursWorked = hoursWorked;
    }

    @Override
    double calculateSalary() {
        return hourlyRate * hoursWorked;
    }
}

2.3.4 拓展案例 2：图形界面组件库

在开发图形用户界面（GUI）时，我们可能需要创建一套组件库，如按钮、文本框等，同时保证这些组件的接口一致，以便于使用和扩展。

接口：Component

java 复制代码 
interface Component {
    void draw();
    void resize();
}

具体实现：Button 和 TextBox

java 复制代码 
class Button implements Component {
    @Override
    public void draw() {
        System.out.println("Drawing a Button");
    }

    @Override
    public void resize() {
        System.out.println("Resizing a Button");
    }
}

class TextBox implements Component {
    @Override
    public void draw() {
        System.out.println("Drawing a TextBox");
    }

    @Override
    public void resize() {
        System.out.println("Resizing a TextBox");
    }
}

通过这些案例，我们可以看到封装和抽象如何使得代码更加安全、清晰和易于维护。封装保护了数据和实现细节，而抽象则提供了一种高层次的方式来操作对象，使得我们可以轻松地扩展和修改系统，而不会影响到使用这些系统的代码。

相关推荐
ROBIN__dyc7 分钟前
表达式
算法
无限大.8 分钟前
c语言200例 067
java·c语言·开发语言
余炜yw9 分钟前
【Java序列化器】Java 中常用序列化器的探索与实践
java·开发语言
攸攸太上10 分钟前
JMeter学习
java·后端·学习·jmeter·微服务
无限大.10 分钟前
c语言实例
c语言·数据结构·算法
Kenny.志13 分钟前
2、Spring Boot 3.x 集成 Feign
java·spring boot·后端
六点半88814 分钟前
【C++】速通涉及 “vector” 的经典OJ编程题
开发语言·c++·算法·青少年编程·推荐算法
不修×蝙蝠15 分钟前
八大排序--01冒泡排序
java
@haihi23 分钟前
冒泡排序，插入排序，快速排序，选择排序
数据结构·算法·排序算法
quaer26 分钟前
Open-Sora全面开源?
开发语言·算法·机器学习·matlab·矩阵
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CTF网络安全大赛简单的web抓包题目：HEADache08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10springer 在线投稿编译踩坑