Java基础(八)：封装、继承、多态与关键字this、super详解

public class Person {
    // 私有属性（隐藏内部实现）
    private String name;
    private int age;

    // Getter/Setter方法（暴露受控接口）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name == null || name.trim().isEmpty()) { // 校验逻辑
            throw new IllegalArgumentException("姓名不能为空");
        }
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 150) { // 年龄合理性校验
            throw new IllegalArgumentException("年龄不合法");
        }
        this.age = age;
    }
}

public class Person {
    private String name; // 成员变量
    
    public void setName(String name) { // 局部变量
        this.name = name; // 用 this 指代成员变量
    }
}

public class Rectangle {
    private int width, height;
    
    public Rectangle() {
        this(10, 10); // 调用带参构造方法
    }
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

public class Printer {
    public void print() {
        System.out.println("Printing...");
    }
}

public class Document {
    private String content;
    
    public void sendToPrinter(Printer printer) {
        printer.print(this.content); // 传递内容
    }
    
    public void process() {
        new Printer().printDocument(this); // 传递当前 Document 对象
    }
}

public class Calculator {
    private int value;
    
    public Calculator add(int num) {
        this.value += num;
        return this; // 返回当前对象
    }
    
    public Calculator subtract(int num) {
        this.value -= num;
        return this;
    }
}

// 链式调用示例
Calculator calc = new Calculator();
calc.add(5).subtract(3).add(10); // 连续操作

public class Outer {
    private String name = "Outer";
    
    class Inner {
        private String name = "Inner";
        
        public void printNames() {
            System.out.println(name);         // "Inner" (内部类变量)
            System.out.println(Outer.this.name); // "Outer" (外部类变量)
        }
    }
}

class Employee {
    private String name;
    private double baseSalary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.baseSalary = salary;
    }
    
    public double calculatePay() {
        return baseSalary; // 普通员工直接返回基础薪资
    }
}

class Manager extends Employee {
    private double bonus; // 经理特有属性-奖金
    
    public Manager(String name, double salary, double bonus) {
        super(name, salary); // 调用父类构造
        this.bonus = bonus;
    }
    
    @Override
    public double calculatePay() {
        // 扩展行为：经理工资 = 基础工资 + 奖金
        return super.calculatePay() + bonus; 
    }
    
    public void conductReview() { 
        // 经理特有方法
        System.out.println("Conducting performance review...");
    }
}

 class Parent {
     Parent(int value) {
         System.out.println("Parent构造器: " + value);
     }
 }

 class Child extends Parent {
     Child() {
         super(10); // 显式调用父类有参构造器
         System.out.println("Child构造器");
     }
 }

class Parent {
    String name = "父类";
}

class Child extends Parent {
    String name = "子类";
    
    void print() {
        System.out.println(super.name); // 输出: 父类
        System.out.println(this.name);   // 输出: 子类
    }
}

class Parent {
    void show() {
        System.out.println("Parent的方法");
    }
}

class Child extends Parent {
    @Override
    void show() {
        super.show(); // 先调用父类方法
        System.out.println("Child的方法");
    }
}

public class TestPet {
    public static void main(String[] args) {
        //多态引用
        Pet pet = new Dog();
        pet.setNickname("小白");

        //多态的表现形式
        /*
        编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
        运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
         */
        pet.eat();//运行时执行子类Dog重写的方法
//      pet.watchHouse();//不能调用Dog子类独有的扩展方法

        pet = new Cat();
        pet.setNickname("雪球");
        pet.eat();//运行时执行子类Cat重写的方法
    }
}

public class Person{
    private Pet pet;
    public void adopt(Pet pet) {//形参是父类类型，实参是子类对象
        this.pet = pet;
    }
    public void feed(){
        pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
    }
}

public class PetShop {
    //返回值类型是父类类型，实际返回的是子类对象
    public Pet sale(String type){
        switch (type){
            case "Dog":
                return new Dog();
            case "Cat":
                return new Cat();
        }
        return null;
    }
}

public class TestVariable {
    public static void main(String[] args) {
        Base b = new Sub();
        System.out.println(b.a);  // 1
        System.out.println(((Sub)b).a);  // 2

        Sub s = new Sub();
        System.out.println(s.a); // 2
        System.out.println(((Base)s).a);  // 1
    }
}
class Base{
    int a = 1;
}
class Sub extends Base{
    int a = 2;
}

class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("Dog eats bones");
    }
    
    void bark() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        // 向上转型：Dog -> Animal
        Animal animal = new Dog();  // 隐式转换
        
        animal.eat();  // 输出："Dog eats bones"（多态：调用子类重写方法）
        // animal.bark(); // 编译错误！父类引用无法访问子类特有方法
    }
}

if (父类引用 instanceof 目标子类) {
    目标子类 引用 = (目标子类) 父类引用;
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型
        
        // 向下转型（安全方式）
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // 强制转换
            dog.eat();   // 输出："Dog eats bones"
            dog.bark();  // 输出："Dog barks"（访问子类特有方法）
        }
        
        // 错误示例（导致ClassCastException）
        Animal cat = new Cat();
        // Dog invalidDog = (Dog) cat; // 运行时异常：cat不是Dog对象
    }
}