跳转至

面向对象编程

📖 章节简介

本章将介绍Java的面向对象编程（OOP），包括类与对象、封装、继承和多态等核心概念。

Java OOP核心四要素

上图展示了封装、继承、多态与抽象四大核心能力之间的关系。

🏷️ 类与对象

1. 类的定义

Java
// 类的定义
public class Person {
    // 成员变量（属性）
    private String name;
    private int age;

    // 构造方法
    public Person() {
        this.name = "匿名";
        this.age = 0;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }

    // Getter和Setter方法
    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) {
            this.age = age;
        }
    }

    @Override  // @Override 标注重写父类方法，编译器会校验
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

2. 对象的创建和使用

Java
// 对象的创建和使用
public class ObjectCreation {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person();
        Person person2 = new Person("张三", 25);

        // 调用方法
        person1.introduce();
        person2.introduce();

        // 访问属性（通过getter/setter）
        System.out.println("\n姓名: " + person2.getName());
        System.out.println("年龄: " + person2.getAge());

        // 修改属性
        person2.setName("李四");
        person2.setAge(30);
        System.out.println("\n修改后: " + person2);

        // 对象数组
        Person[] people = {
            new Person("张三", 25),
            new Person("李四", 30),
            new Person("王五", 28)
        };

        System.out.println("\n遍历对象数组：");
        for (Person person : people) {
            person.introduce();
        }
    }
}

🔒 封装

1. 访问修饰符

Java
// 访问修饰符
public class AccessModifiers {
    // public：任何地方都可以访问
    public int publicVar = 1;

    // protected：同包或子类可以访问
    protected int protectedVar = 2;

    // default（无修饰符）：同包可以访问
    int defaultVar = 3;

    // private：只有本类可以访问
    private int privateVar = 4;

    // Getter方法
    public int getPrivateVar() {
        return privateVar;
    }

    // Setter方法
    public void setPrivateVar(int privateVar) {
        this.privateVar = privateVar;
    }
}

class TestAccess {
    public void test() {
        AccessModifiers am = new AccessModifiers();

        // 可以访问public
        System.out.println(am.publicVar);

        // 可以访问protected（如果是子类）
        // System.out.println(am.protectedVar);

        // 可以访问default（同包）
        // System.out.println(am.defaultVar);

        // 不能访问private
        // System.out.println(am.privateVar);

        // 通过getter访问private
        System.out.println(am.getPrivateVar());
    }
}

2. 封装示例

Java
// 封装示例
public class BankAccount {
    private String accountNumber;
    private double balance;

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

    // 存款
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，余额: " + balance);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }

    // 取款
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，余额: " + balance);
        } else if (amount > balance) {
            System.out.println("余额不足");
        } else {
            System.out.println("取款金额必须大于0");
        }
    }

    // 查询余额
    public double getBalance() {
        return balance;
    }

    // 账户信息
    public String getAccountNumber() {
        return accountNumber;
    }
}

🧬 继承

1. 继承基础

Java
// 父类
public class Animal {
    protected String name;
    protected int age;

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

    public void eat() {
        System.out.println(name + "在吃东西");
    }

    public void sleep() {
        System.out.println(name + "在睡觉");
    }

    public void makeSound() {
        System.out.println(name + "发出声音");
    }
}

// 子类
public class Dog extends Animal {  // extends 继承父类
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);  // 调用父类构造方法
        this.breed = breed;
    }

    // 重写父类方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }

    // 子类特有方法
    public void fetch() {
        System.out.println(name + "去捡球");
    }

    public String getBreed() {
        return breed;
    }
}

// 使用继承
public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", 3, "金毛");

        // 调用父类方法
        dog.eat();
        dog.sleep();

        // 调用重写的方法
        dog.makeSound();

        // 调用子类方法
        dog.fetch();
    }
}

2. super关键字

Java
// super关键字
public class Vehicle {
    protected String brand;
    protected String model;

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

    public void start() {
        System.out.println("车辆启动");
    }
}

public class Car extends Vehicle {
    private int numberOfDoors;

    public Car(String brand, String model, int numberOfDoors) {
        super(brand, model);  // 调用父类构造方法
        this.numberOfDoors = numberOfDoors;
    }

    @Override
    public void start() {
        super.start();  // 调用父类方法
        System.out.println("汽车引擎启动");
    }

    public void displayInfo() {
        System.out.println("品牌: " + brand);
        System.out.println("型号: " + model);
        System.out.println("车门数: " + numberOfDoors);
    }
}

🎭 多态

1. 方法重写

Java
// 方法重写
public class Shape {
    public void draw() {
        System.out.println("绘制形状");
    }

    public double getArea() {
        return 0;
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

// 使用多态
public class PolymorphismExample {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6)
        };

        for (Shape shape : shapes) {
            shape.draw();
            System.out.println("面积: " + shape.getArea());
        }
    }
}

2. 方法重载

Java
// 方法重载
public class Calculator {
    // 加法 - 两个整数
    public int add(int a, int b) {
        return a + b;
    }

    // 加法 - 三个整数
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 加法 - 两个小数
    public double add(double a, double b) {
        return a + b;
    }

    // 加法 - 数组
    public int add(int[] numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}

// 使用方法重载
public class OverloadingExample {
    public static void main(String[] args) {
        Calculator calc = new Calculator();

        System.out.println("2 + 3 = " + calc.add(2, 3));
        System.out.println("2 + 3 + 4 = " + calc.add(2, 3, 4));
        System.out.println("2.5 + 3.5 = " + calc.add(2.5, 3.5));

        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("数组求和: " + calc.add(numbers));
    }
}

💡 最佳实践

1. 类设计

Java
// 类设计最佳实践
public class ClassDesign {
    // ✅ 好的设计
    private String name;  // 私有属性
    private int age;

    public ClassDesign(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    // ❌ 不好的设计
    public String name2;  // 公开属性
    public int age2;
}

2. 继承使用

Java
// 继承使用最佳实践
public class InheritanceBestPractices {
    // ✅ 好的做法：使用抽象类
    public abstract class Animal {
        public abstract void makeSound();
    }

    public class Dog extends Animal {
        @Override
        public void makeSound() {
            System.out.println("汪汪");
        }
    }

    // ❌ 不好的做法：滥用继承
    public class BadDog extends Animal {
        @Override
        public void makeSound() { }
        public void eat() { }  // 应该在父类中
        public void sleep() { }  // 应该在父类中
    }
}

📝 练习题

基础题

  1. 什么是类和对象？
  2. 封装、继承、多态是什么？
  3. 如何实现方法重写和重载？

进阶题

  1. 设计一个合理的类层次结构。
  2. 实现多态的应用场景。
  3. 使用抽象类和接口。

实践题

  1. 设计一个学生管理系统。
  2. 实现一个图形计算器。
  3. 创建一个简单的游戏角色系统。

📚 推荐阅读

🔗 下一章

异常处理 - 学习Java的异常处理机制。