Day 7 面向对象 OOP

公告

View Post

OOP定义

object-orientated programming
编程的本质就是：以类的方式组织代码，以对象的组织封装数据
OOP的特征：1.封装 (将数据包装起来） 2.继承 3.多态

点击查看代码

package OOP;

import java.io.IOException;

public class program01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*修饰符 返回值类型 方法名（方法参数）{
     方法体
     return 返回值
        }
    * */
    public String sayHello(){
        return "hello,World!";
    }
    public void hello(){
        return;
    }
    public int max(int a, int b){
        return a>b? a : b;// a是否大于b?如果是返回a, 否则返回b
    }
                                     //抛出异常
    public void readFile(String file) throws IOException {

    }
}

一般在main方法里输出值，main方法只有一个。
break : 跳出循环。
return ：代表方法结束，返回的值需要和返回类型一致，return 可以返回为空

回顾方法

方法的定义

点击查看代码

package OOP;

import java.io.IOException;

public class program01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*修饰符 返回值类型 方法名（方法参数）{
     方法体
     return 返回值
        }
    * */
    public String sayHello(){
        return "hello,World!";
    }
    public void hello(){
        return;
    }
    public int max(int a, int b){
        return a>b? a : b;// a是否大于b?如果是返回a, 否则返回b
    }
                                     //抛出异常
    public void readFile(String file) throws IOException {

    }
}

方法的调用

1.静态方法：用了 static；Static Method、

i) 适合“和对象无关”的功能，比如计算、工具、统计。
ii) 可以通过类名.方法名() 调用，不需要创建对象
iii) 常用来处理通用功能，或者工具类方法（如 Math.max()）。

点击查看静态方法的代码

class Utils {
    public static int add(int a, int b) {
        return a + b; //返回值
    }
}

public class Demo {
    public static void main(String[] args) {
        int result = Utils.add(3, 5); // 不需要创建对象
        System.out.println(result); // 输出 8
    }
}

2.非静态方法：

i) 属于对象，必须先创建对象才能调用。
ii) 适合“和对象状态相关”的功能，比如修改属性、打印对象信息
iii) 用于描述对象特有的行为。

点击查看非静态方法的代码

class Person {
    String name;

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person(); // 先创建对象
        p.name = "Lily";
        p.sayHello(); // 调用非静态方法
    }
}

注意点
：方法之间是会互相调用的

静态方法调用静态方法 → 直接调用

非静态方法调用非静态方法 → 必须通过对象

静态方法调用非静态方法 → 先创建对象，再调用 (所以静态方法必须先创建对象才能调用非静态方法）

调用流程：

解释：

main 方法是 Java 程序的入口，程序从 main 开始执行。
如果你想让程序在控制台输出结果，最终必须通过 main 方法（或者被 main 方法调用的方法）触发 System.out.println()。

点击查看example代码

class Demo {
    public static void hello() {
        System.out.println("Hello!");
    }

    public static void main(String[] args) {
        hello(); // 通过 main 调用，才会输出
    }
}
//如果写了 hello() 但 没在 main 或其他被执行的方法里调用它，程序运行不会输出任何东西。

实际参数和形式参数

1.形式参数

出现在方法定义中，用来接收调用者传递的值, 用来占位。
是方法内部的局部变量，在方法体内使用。

点击查看代码

public void greet(String name) {  // name 就是形式参数
    System.out.println("Hello, " + name);
}

2.实际参数

出现在方法调用时，传递给方法的具体值。
可以是常量、变量、表达式或方法返回值，用于提供方法所需的数据

点击查看代码

greet("Alice"); // "Alice" 是实际参数
String user = "Bob";
greet(user);    // user 的值 "Bob" 是实际参数

实际参数和形式参数的类型要一一对应。

点击查看代码

package OOP;

public class program04 {
    public static void main(String[] args) {
        program04 Program = new program04();
        System.out.println(Program.add(1,2)); //实际参数
    }

    public int add(int a, int b) { //形式参数
        return a + b;
    }
}

值传递和引用传递

java中实际只有值传递（pass by value) ，但是它对对象类型的传递表现得像“引用传递”

1.值传递

i) 作用于基本类型：拷贝值 → 方法内改不影响外部
ii) 方法拿到的是变量的“拷贝”，改了不会影响原来的变量。

点击查看代码

void addOne(int x) {
    x = x + 1;
}

int num = 5;
addOne(num);
System.out.println(num); // 输出 5，原值没变

2.引用传递

i) 作用于对象类型：引用的值传递
ii) 方法拿到的是对象引用的“拷贝”.

点击查看代码

class Person {
    String name;
}
//写的modify的方法，为了改变名字
void modify(Person p) {
//step 3: person(copy) → [Person对象] name = "Charlie" (被修改)
    p.name = "Charlie";  // 修改对象内容
//step 4: 已经是新对象了，和之前的person完全没关了
    p = new Person();    // 改变引用指向新对象
//step 5: 新对象的名字是 David
    p.name = "David";
}
//step 1: 创建对象
Person person = new Person();
person.name = "Alice"; //内存状态： person → [Person对象] name = "Alice"
// step 2: 调用modify方法
modify(person); // 此时，p是person引用的副本：person(copy) → [Person对象] name = "Alice"

System.out.println(person.name); // 输出原对象"Charlie"，说明对象内容被改了，但引用没变

chatgpt 解释如下：

用房子的比喻来理解
想象一下：

对象 = 一栋真实的房子

引用 = 写有房子地址的纸条

方法参数 = 地址纸条的复印件

你的代码场景

java
Person person = new Person();  // 你建了一栋房子
person.name = "Alice";         // 你在门牌上写"Alice"
现在内存中：

text
你手里有一张纸条：[地址：123 Main St] → 房子[门牌：Alice]

调用方法时

modify(person);  // 你把地址纸条复印一份交给modify方法

现在有两张纸条：

你的原件：[地址：123 Main St]

方法的复印件：[地址：123 Main St] → 都指向同一栋房子

方法内部的操作

void modify(Person p) {      // p拿到的是地址复印件
    p.name = "Charlie";      // ✅ 拿着复印件找到房子，把门牌改成"Charlie"
    
    p = new Person();        // ❌ 方法把复印件上的地址改成了"456 Oak St"
    p.name = "David";        // ❌ 去新地址"456 Oak St"的房子写上门牌"David"
}

方法结束后：方法的复印件被销毁了

你的原件还是原来的地址：[地址：123 Main St]

你去这个地址查看，发现门牌是"Charlie"（因为确实被改过）

那个"456 Oak St"地址和新房子与方法无关了

对于对象参数：方法内可以修改对象的属性，但不能让外部的引用指向新对象 _"引用“传递
对于基本类型参数（int, double等）：方法内修改完全不影响外部，因为传递的是值的副本 —— 值传递

类与对象的创造

类（ Class）：定义了属性（成员变量）和方法（method）

点击查看代码

// 类的定义 - 就像房子的设计图
public class Car {
    // 属性（字段/成员变量）
    String brand;
    String color;
    int maxSpeed;
    
    // 行为（方法）
    void start() {
        System.out.println(brand + "汽车启动了！");
    }
    
    void drive() {
        System.out.println("正在驾驶" + color + "的" + brand + "汽车");
    }
}

对象（Object): 具体的实例

点击查看代码

public class Main {
    public static void main(String[] args) {
        // 创建Car类的对象 - 就像根据设计图建造真实的房子
        Car myCar = new Car();
        
        // 给对象的属性赋值
        myCar.brand = "丰田";
        myCar.color = "红色";
        myCar.maxSpeed = 180;
        
        // 调用对象的方法
        myCar.start();    // 输出：丰田汽车启动了！
        myCar.drive();    // 输出：正在驾驶红色的丰田汽车
    }
}

创建对象的关键词： new

点击查看代码

// 语法：ClassName objectName = new ClassName();
Car myCar = new Car();

// 分解理解：
// Car myCar     - 声明一个Car类型的引用变量
// new Car()     - 在堆内存中创建实际的Car对象
// =             - 将引用变量指向实际对象

4.内存中的情况：

5.创建对象的完整过程

点击查看代码

public class Student {
    // 属性
    String name;
    int age;
    
    // 构造方法 - 用于初始化对象
    public Student(String studentName, int studentAge) {
        name = studentName;
        age = studentAge;
    }
    
    // 方法
    void study() {
        System.out.println(name + "正在学习...");
    }
}

// 创建对象并初始化
public class Main {
    public static void main(String[] args) {
        // 使用构造方法创建对象
        Student student1 = new Student("张三", 20);
        Student student2 = new Student("李四", 22);
        
        student1.study();  // 输出：张三正在学习...
        student2.study();  // 输出：李四正在学习...
    }
}

posted on 2025-09-17 01:29 escapedlili 阅读(8) 评论(0) 收藏举报

刷新页面返回顶部