面向对象_基础

面向对象_基础

学习面向对象内容的三条主线

• Java类及类的成员: 属性、方法、构造器；代码块、内部类
• 面向对象的特征: 封装、继承、多态
• 其他关键字的使用: this、super、package、import、static、final、interface

1. Java语言的基本元素：类和对象

类：具有相同特征的事物的抽象描述，是抽象的、概念上的定义

• 是一组关于 属性/成员变量 和 行为/方法 的集合

对象：实际存在的该类事物的每个个体，是具体的，也成为实例

面向对象程序设计的重点是 类的设计

类的设计 ，其实就是 类的成员的设计

我们可以通过一个简单的Java示例来详细解释面向对象编程（OOP）的三步骤。假设我们要创建一个 “银行账户” 的功能。

2. 通过例子学习OOP完成功能的三步骤

需求分析：

• 我们需要一个银行账户类（BankAccount），它应该包含以下功能：
  • 存储账户的余额。
  • 存款功能（deposit）。
  • 取款功能（withdraw）。
  • 查询余额功能（checkBalance）。

第一步：定义类：

• 根据需求，我们可以定义一个BankAccount类，其中包括以下属性和方法：

public class BankAccount { //public：修饰符
    // 属性（字段）
    private double balance;  // 账户余额
    
    // 构造方法，用于初始化账户。
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
    
    // 方法（行为）
    
    // 存款方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            System.out.println("存款金额必须大于零。");
        }
    }
    
    // 取款方法
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("余额不足或输入金额无效。");
        }
    }
    
    // 查询余额方法
    public double checkBalance() {
        return balance;
    }
}

• 构造方法是类的一种特殊方法，用于在创建对象时初始化对象的状态。构造方法的名称必须与类名相同，输入的initialBalance将传给变量balance

第二步：对象的创建：

实现类：

• 我们已经在上面定义了BankAccount类，并实现了它的属性和方法。现在我们可以使用这个类来创建对象。

创建对象：

• 通过调用类的构造方法，我们可以创建BankAccount对象。

public class Main {
    public static void main(String[] args) {
        // 创建一个初始余额为1000元的银行账户
        BankAccount myAccount = new BankAccount(1000.0);
    }
}

• 创建对象，使用关键字：new

  类名 对象名 = new 类名 （ ）

第三步：调用对象方法：

调用方法：

• 创建了对象后，我们可以通过调用对象的方法来执行特定的功能。例如，存款、取款和查询余额。

public class Main {
    public static void main(String[] args) {
        // 创建一个初始余额为1000元的银行账户
        BankAccount myAccount = new BankAccount(1000.0);
        
        // 存款500元
        myAccount.deposit(500.0);
        System.out.println("存款后余额: " + myAccount.checkBalance());  // 输出: 存款后余额: 1500.0
        
        // 取款200元
        myAccount.withdraw(200.0);
        System.out.println("取款后余额: " + myAccount.checkBalance());  // 输出: 取款后余额: 1300.0
        
        // 尝试取款2000元（超过余额）
        myAccount.withdraw(2000.0);  // 输出: 余额不足或输入金额无效。
    }
}

总结

• 定义类：我们定义了一个BankAccount类，其中包含余额属性和用于存款、取款、查询余额的方法。
• 实现类和对象：我们使用类创建了一个具体的银行账户对象。
• 调用方法：通过调用对象的方法，我们实现了存款、取款和查询余额的功能。

这种面向对象的设计使得代码更模块化、更易于维护，并且能够很好地模拟现实世界中的实体和操作。

在Java编程中，类的成员主要分为两类：成员变量和方法。

3. 类的成员：

3.1 成员变量

成员变量（也称为字段或属性）是定义在类内部的变量，用于存储对象的状态信息。成员变量可以是任何数据类型，包括基本数据类型（如 int, float, boolean）和引用数据类型（如对象、数组等）。

成员变量的特性：

• 作用域：成员变量的作用域是整个类，它们可以在类的任何方法中被访问。
• 默认值：如果没有显式初始化，成员变量会被赋予默认值。比如，int 类型的成员变量默认值为 0，boolean 类型的默认值为 false，对象类型的默认值为 null。
• 访问修饰符：成员变量可以用访问修饰符（如 private, protected, public）来控制它们的可见性。

示例：

public class Car {
    // 成员变量
    private String model;
    private int year;
    private boolean isElectric;
    
    // 构造方法
    public Car(String model, int year, boolean isElectric) {
        this.model = model;
        this.year = year;
        this.isElectric = isElectric;
    }
}

在这个示例中，model, year 和 isElectric 是 Car 类的成员变量。

3.2 方法

方法是类中的函数，定义了对象的行为。方法包含在类中，并用于执行特定的操作或计算。方法可以操作成员变量，接收参数，返回值或什么都不返回。

方法的特性：

• 方法签名：方法的签名包括方法名和参数列表。方法名用于标识方法，而参数列表定义了方法可以接受的输入。
• 返回类型：方法可以返回一个值，返回类型定义了方法返回的值的类型。如果方法不返回任何值，则使用 void 作为返回类型。
• 访问修饰符：方法同样可以使用访问修饰符来控制它们的可见性。

示例：

public class Car {
    private String model;
    private int year;
    private boolean isElectric;

    public Car(String model, int year, boolean isElectric) {
        this.model = model;
        this.year = year;
        this.isElectric = isElectric;
    }
    
    // 方法：获取车型
    public String getModel() {
        return model;
    }
    
    // 方法：设置车型
    public void setModel(String model) {
        this.model = model;
    }
    
    // 方法：显示汽车信息
    public void displayCarInfo() {
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
        System.out.println("Electric: " + isElectric);
    }
}

在这个示例中，getModel, setModel 和 displayCarInfo 是 Car 类中的方法。getModel 返回汽车的型号，setModel 设置型号，而 displayCarInfo 显示汽车的详细信息。

• 访问修饰符（Access Modifiers）是Java中用来控制类、方法、变量和构造函数的访问级别的关键字。它们决定了其他类是否能够访问这些成员。Java中有四种主要的访问修饰符：

1. public
2. protected
3. 默认（包访问权限，不写修饰符）
4. private

访问修饰符的总结表格：

修饰符	类内访问	同包内访问	子类访问	其他包访问
public	是	是	是	是
protected	是	是	是	否
默认（包访问权限）	是	是	否	否
private	是	否	否	否

示例演示：

// 文件: Parent.java
package com.example;

public class Parent {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3; // 默认（包访问权限）
    private int privateVar = 4;

    public void show() {
        System.out.println("Public Variable: " + publicVar);
        System.out.println("Protected Variable: " + protectedVar);
        System.out.println("Default Variable: " + defaultVar);
        System.out.println("Private Variable: " + privateVar);
    }
}

// 文件: Child.java
package com.example;

public class Child extends Parent {
    public void display() {
        System.out.println("Public Variable: " + publicVar); // 可访问
        System.out.println("Protected Variable: " + protectedVar); // 可访问
        System.out.println("Default Variable: " + defaultVar); // 可访问
        // System.out.println("Private Variable: " + privateVar); // 不可访问，会报错
    }
}

// 文件: Other.java
package com.other;

import com.example.Parent;

public class Other {
    public void display() {
        Parent parent = new Parent();
        System.out.println("Public Variable: " + parent.publicVar); // 可访问
        // System.out.println("Protected Variable: " + parent.protectedVar); // 不可访问，会报错
        // System.out.println("Default Variable: " + parent.defaultVar); // 不可访问，会报错
        // System.out.println("Private Variable: " + parent.privateVar); // 不可访问，会报错
    }
}

在这个示例中：

• publicVar 可以被任何地方访问，包括不同包的类。
• protectedVar 可以被同包类和子类访问，但不能被不同包的非子类访问。
• defaultVar 只能被同包内的类访问，其他包的类不能访问。
• privateVar 只能在 Parent 类内部访问，其他地方都不能访问。