《Java 简易速速上手小册》第2章:面向对象的 Java(2024 最新版)

简介: 《Java 简易速速上手小册》第2章:面向对象的 Java(2024 最新版)

c431a108708a1289278ce7da1f31c0b.png

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

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

2.1.1 基础知识

  • 类(Class):类是一个蓝图,定义了创建对象(实例)时所需的状态和行为。状态由属性(变量)表示,行为由方法(函数)表示。想象你正在设计一个机器人,你需要决定它有哪些功能(方法)和属性(变量)。
  • 对象(Object):对象是根据类的定义创建的实例。如果类是蓝图,那么对象就是根据这个蓝图建造的房子。每个对象都拥有自己的状态,能够执行定义在其类中的操作。
  • 实例化:创建对象的过程称为实例化。通过使用 new 关键字和类的构造器(Constructor)来实现。
  • 构造器(Constructor):构造器是一种特殊的方法,用于在创建对象时初始化对象的状态。构造器的名称必须与类名完全相同。

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

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

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:学生管理系统

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

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:账户管理系统

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

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

abstract class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    abstract void makeSound();
}

子类:Lion

class Lion extends Animal {
    public Lion(String name) {
        super(name);
    }
    @Override
    void makeSound() {
        System.out.println(name + " says: Roar");
    }
}

子类:Parrot

class Parrot extends Animal {
    public Parrot(String name) {
        super(name);
    }
    @Override
    void makeSound() {
        System.out.println(name + " says: Squawk");
    }
}

演示多态

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()LionParrot 类继承自 Animal 类,并提供了 makeSound() 方法的具体实现。这个例子展示了如何通过继承和多态来处理不同类型的动物,同时保持代码的简洁和灵活性。

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

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

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");
    }
}

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

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 支付和银行转账。

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");
    }
}

使用多态进行支付:

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

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

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

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

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

interface Component {
    void draw();
    void resize();
}

具体实现:Button 和 TextBox

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");
    }
}

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

目录
相关文章
|
15天前
|
存储 安全 Java
Java面向对象最新超详细总结版!
Java面向对象最新超详细总结版!
29 7
Java面向对象最新超详细总结版!
|
3天前
|
安全 Java 编译器
Java面向对象之——多态
Java面向对象之——多态
|
3天前
|
Java 程序员 编译器
Java面向对象之——继承
Java面向对象之——继承
|
3天前
|
存储 Java 编译器
Java面向对象之——封装
Java面向对象之——封装
|
3天前
|
Java
Java程序设计实验3 | 面向对象(上)(二)
分数的分子和分母用两个整型数表示,类所拥有的方法包括对分数进行加、减、乘、除等运算,以及输出分数的方法,输出分数的格式应该是:分子/分母。
12 0
|
3天前
|
Java
Java程序设计实验3 | 面向对象(上)(一)
实验目的是理解和掌握面向对象编程的基本概念,包括类的声明、实例化和调用,方法及构造方法的定义,方法重载,值传递和地址传递,以及使用this关键字和static关键字。
15 0
|
15天前
|
Java
java面向对象——包+继承+多态(一)-2
java面向对象——包+继承+多态(一)
22 3
|
15天前
|
SQL Java 编译器
java面向对象——包+继承+多态(一)-1
java面向对象——包+继承+多态(一)
20 2
|
15天前
|
存储 Java 开发工具
【Java探索之旅】用面向对象的思维构建程序世界
【Java探索之旅】用面向对象的思维构建程序世界
12 0
|
15天前
|
Java
java使用面向对象实现图书管理系统
java使用面向对象实现图书管理系统