Java基础(七)： 面向过程与面向对象、类与对象、成员变量与局部变量、值传递与引用传递、方法重载与方法重写

public class ProceduralExample {
    // 数据与函数分离
    public static double calculateArea(double length, double width) {
        return length * width;
    }
    
    public static double calculatePerimeter(double length, double width) {
        return 2 * (length + width);
    }

    public static void main(String[] args) {
        double length = 5.0;
        double width = 3.0;
        // 逐步调用函数
        double area = calculateArea(length, width);
        double perimeter = calculatePerimeter(length, width);
        System.out.println("面积: " + area + ", 周长: " + perimeter);
    }
}

// 封装数据和操作
class Rectangle {
    private double length;
    private double width;

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

    // 方法绑定到对象
    public double calculateArea() {
        return length * width;
    }

    public double calculatePerimeter() {
        return 2 * (length + width);
    }
}

public class OOPExample {
    public static void main(String[] args) {
        // 创建对象并调用方法
        Rectangle rect = new Rectangle(5.0, 3.0);
        System.out.println("面积: " + rect.calculateArea() + ", 周长: " + rect.calculatePerimeter());
    }
}

// 定义一个"Dog"类
public class Dog {
    // 字段（属性）
    String breed;
    int age;
    String color;
    
    // 构造器（初始化对象）
    public Dog(String breed, int age, String color) {
        this.breed = breed;
        this.age = age;
        this.color = color;
    }
    
    // 方法（行为）
    void bark() {
        System.out.println("汪汪！");
    }
    
    void sleep() {
        System.out.println("睡觉中...");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Dog类的对象
        Dog myDog = new Dog("拉布拉多", 3, "黄色");
        
        // 访问对象的字段
        System.out.println("品种: " + myDog.breed); // 输出: 拉布拉多
        
        // 调用对象的方法
        myDog.bark(); // 输出: 汪汪！
    }
}

public class Person {
    // 实例变量（属于对象）
    private String name;   // 无static修饰
    
    // 类变量（属于类）
    public static int count; // 有static修饰
}

public void printInfo(int age) { // age是参数（局部变量）
    String message = "Age: ";   // 方法局部变量
    {
        int temp = 10;          // 代码块局部变量（仅在此块内有效）
    }
    System.out.println(message + age);
}

void modify(int x) {
    x = 20;  // 修改的是副本
}

public static void main(String[] args) {
    int a = 10;
    modify(a);
    System.out.println(a);  // 输出 10（原始值未变）
}

class Person {
    String name;
    Person(String name) { this.name = name; }
}

void changeName(Person p) {
    p.name = "Bob";  // 修改副本指向的对象属性
}

public static void main(String[] args) {
    Person person = new Person("Alice");
    changeName(person);
    System.out.println(person.name);  // 输出 "Bob"（原始对象被修改）
}

void createNewPerson(Person p) {
    p = new Person("Bob");  // 副本指向新对象，原始引用不变
}

public static void main(String[] args) {
    Person person = new Person("Alice");
    createNewPerson(person);
    System.out.println(person.name);  // 输出 "Alice"（原始引用未变）
}

class Calculator {
    // 重载add方法
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(int a, double b) { // 参数类型不同
        return a + b;
    }
    
    public int add(int a, int b, int c) { // 参数个数不同
        return a + b + c;
    }
    
    public double add(double a, int b) { // 参数顺序不同
        return a + b;
    }

    // public double add(int a, int b) { // 只有返回值类型不同，编译失败
    //     return a + b;
    // }
}

Calculator calc = new Calculator();
calc.add(2, 3);       // 调用 int add(int, int)
calc.add(2.5, 3.7);   // 调用 double add(double, double)
calc.add("He", "llo"); // 调用 String add(String, String)

// 子类对象必须能够替代父类对象使用
// 假设父类的方法是 public，那么用户通过父类引用应该可以调用该方法：
class Parent {
    public void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    // 错误写法：降低访问权限
    protected void show() {
        System.out.println("Child");
    }
}

// 在这种情况下：
Parent p = new Child();
p.show(); // 编译器会找 Parent 的 public show()
// ⚠️但如果 Child 中的 show() 是 protected，Java 编译器就无法访问这个方法

// 假设父类方法声明会抛出某个异常，那么你就可以在使用父类引用时，写出对应的异常处理代码
// 如果子类重写方法却抛出了更多或更广泛的异常
// 父类引用将无法预见这些额外的异常，程序可能在运行时出现无法捕获的错误
class Parent {
    public void work() throws IOException {
        // ...
    }
}

class Child extends Parent {
    @Override
    public void work() throws Exception { // ❌ 错误！Exception 比 IOException 范围大
        // ...
    }
}
// ⚠️违反了任何使用父类的地方都应该能透明地替换成子类

class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override // 注解确保正确重写
    public void makeSound() { // 重写父类方法
        System.out.println("Dog barks: Woof!");
    }
}

Animal myDog = new Dog(); // 向上转型
myDog.makeSound(); // 输出 "Dog barks: Woof!"