一、面向对象思想简介

面向过程：以“步骤”为中心，注重解决问题的“过程”。
面向对象：以“对象”为中心，注重通过对象之间的“协作”解决问题。

核心思想：

“万物皆对象”。程序中的一切，都可以抽象为具有属性和行为的对象。

例如：
学生对象（Student） → 属性：姓名、年龄 → 行为：学习、吃饭、考试。

---

二、类（Class）与对象（Object）

1. 类的定义

类是对象的模板或蓝图，用于描述某一类事物的共同特征。

public class Person {
    String name;   // 属性（成员变量）
    int age;

    void speak() { // 行为（方法）
        System.out.println("我叫 " + name + "，今年 " + age + " 岁。");
    }
}

2. 创建对象

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(); // 创建对象
        p1.name = "Alice";
        p1.age = 20;
        p1.speak(); // 调用方法
    }
}

输出：

我叫 Alice，今年 20 岁。

3. 成员变量与局部变量

区别	成员变量	局部变量
定义位置	类中、方法外	方法中、形参、代码块中
生命周期	对象存在即存在	方法调用结束即销毁
是否有默认值	有（如0、false、null）	无，必须显式赋值

---

三、构造方法（Constructor）

用于创建对象并初始化成员变量。

class Student {
    String name;
    int age;

    // 无参构造
    public Student() {
        System.out.println("创建一个学生对象");
    }

    // 有参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

使用：

Student s1 = new Student();
Student s2 = new Student("Tom", 18);

关键点：

• 构造方法名与类名相同；
• 没有返回值类型；
• 可重载多个；
• 若未定义构造方法，系统会自动生成一个无参构造。

---

四、封装（Encapsulation）

封装是隐藏对象的内部实现细节，仅暴露必要的接口。

做法：

1. 将属性定义为 private；
2. 提供 public 的 getter / setter 方法。

public class Account {
    private double balance;

    public void setBalance(double balance) {
        if (balance >= 0) {
            this.balance = balance;
        }
    }

    public double getBalance() {
        return balance;
    }
}

好处：

• 提高代码安全性；
• 便于维护；
• 防止数据被随意修改。

---

五、继承（Inheritance）

通过 extends 关键字实现，让子类继承父类的属性和方法。

1. 基本语法

class Animal {
    void eat() {
        System.out.println("吃东西");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("汪汪汪");
    }
}

使用：

Dog d = new Dog();
d.eat();  // 继承自父类
d.bark(); // 自己的

2. 继承特性

• Java 只支持单继承（一个子类只能有一个父类）。
• 可以通过多层继承形成继承链。
• 所有类默认继承自 Object 类。
• 子类不能直接访问父类的 private 成员。

3. super关键字

• super 调用父类构造器；
• super.属性 或 super.方法 调用父类成员。

class Animal {
    Animal(String name) {
        System.out.println("Animal 构造：" + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // 调用父类构造器
        System.out.println("Dog 构造：" + name);
    }
}

---

六、多态（Polymorphism）

多态：同一个方法在不同对象上表现出不同的行为。

1. 实现条件

• 必须有继承关系；
• 必须有方法重写；
• 父类引用指向子类对象。

class Animal {
    void speak() {
        System.out.println("动物叫");
    }
}

class Cat extends Animal {
    void speak() {
        System.out.println("喵喵喵");
    }
}

class Dog extends Animal {
    void speak() {
        System.out.println("汪汪汪");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a1 = new Cat();
        Animal a2 = new Dog();

        a1.speak(); // 喵喵喵
        a2.speak(); // 汪汪汪
    }
}

2. 向上转型与向下转型

Animal a = new Dog();  // 向上转型
Dog d = (Dog) a;       // 向下转型

判断类型：

if (a instanceof Dog) {
    ((Dog) a).bark();
}

---

七、方法重写（Override）与重载（Overload）

重写（Override）：子类重新定义父类方法。
重载（Overload）：同类中同名方法参数不同。

比较项	重写	重载
位置	父子类之间	同一个类中
参数列表	必须相同	必须不同
返回类型	相同或子类型	无要求
修饰符	不可更严格	无要求

---

八、抽象类（Abstract Class）

当父类方法无法明确具体实现时，可以定义为抽象方法，让子类去实现。

abstract class Shape {
    abstract double area(); // 抽象方法
}

class Circle extends Shape {
    double r;

    Circle(double r) { this.r = r; }

    @Override
    double area() {
        return Math.PI * r * r;
    }
}

注意：

• 抽象类不能实例化；
• 可以包含普通方法；
• 子类必须实现所有抽象方法，除非自己也是抽象类。

---

九、接口（Interface）

接口定义了一组“能力”规范，没有具体实现。

interface USB {
    void connect();
    void disconnect();
}

class Mouse implements USB {
    public void connect() {
        System.out.println("鼠标连接");
    }

    public void disconnect() {
        System.out.println("鼠标断开");
    }
}

特点：

• interface 关键字定义；
• 默认方法是 public abstract；
• 变量默认是 public static final；
• 一个类可实现多个接口；
• 支持接口继承接口。

Java 8+ 扩展：
接口中可以定义：

• 默认方法：default void method() {}
• 静态方法：static void method() {}

---

十、内部类（Inner Class）

内部类是定义在类内部的类，用于逻辑关联紧密的对象。

1. 成员内部类

class Outer {
    private String msg = "Hello";

    class Inner {
        void show() {
            System.out.println(msg);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

2. 静态内部类

class Outer {
    static class StaticInner {
        void say() {
            System.out.println("我是静态内部类");
        }
    }
}

3. 局部内部类 & 匿名内部类

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名内部类执行");
    }
};
r.run();

---

十一、访问修饰符

修饰符	同类	同包	子类	其他包
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
默认（无修饰）	✅	✅	❌	❌
private	✅	❌	❌	❌

例：

public class Test {
    private int a;
    protected int b;
    public int c;
}

---

十二、包（Package）与导入（import）

1. 定义包

package com.example.demo;

2. 导入类

import java.util.Scanner;

包的作用：

• 避免命名冲突；
• 提高代码可维护性；
• 控制访问权限。

---

十三、Object 类

所有类的父类，常用方法：

方法	说明
toString()	返回对象字符串表示
equals()	比较两个对象是否相等
hashCode()	获取哈希值
clone()	对象克隆
finalize()	对象销毁前调用

示例：

@Override
public String toString() {
    return "Student{name='" + name + "', age=" + age + "}";
}

---

十四、小结

核心概念	说明
封装	隐藏实现细节，对外提供接口
继承	复用父类属性和方法
多态	同一操作作用于不同对象产生不同结果
抽象	提取共性，定义规范
接口	行为规范的集合

面向对象的思想让代码更具：

• 可复用性
• 可扩展性
• 可维护性