封装和重载学习

一、类与对象复习

1. 类和对象的关系

   • 类是模板（图纸）
   • 对象是具体实例（成品）
   • 类可以创建出对象

2. 类的成员

   • 成员属性（成员变量）
   • 成员方法

3. 创建对象的语法

   类名 对象名 = new 类名();
   

4. 调用对象属性和方法的语法

   • 对象名.属性
   • 对象名.方法 ()

5. 成员变量和局部变量的区别

   • 位置：成员变量在方法外，局部变量在方法内
   • 内存位置：成员变量在堆中对象里面，局部变量在栈中方法内，随着方法执行入栈，方法结束弹栈消失，作用域是方法体。

6. 类可以创建多个对象，对象之间没有关系，每个对象都有属于自己的属性和方法

7. this 关键字：this 指代当前类对象

二、构造方法

2.1 无参构造

• 构造方法又叫构造器（constructor），用于创建对象
• 每个类中都有构造方法，默认隐藏，但如果有了其他的构造方法，原本默认的构造方法就不再提供
• 语法：

  public 类名(){
  }
  

• 特点：
  • 没有返回值，也不需要定义返回值类型（连 void 也没有）
  • 方法名只能是当前类类名
  • 只能通过 new 来调用
• 作用：
  • 在堆中创建对象
  • 初始化属性和方法

public class Student {
    String name;
    int age;

    // 无参构造方法
    public Student(){
        System.out.println("Student()执行了");
    }

    public void study(){
        System.out.println(name+"在学习");
    }
}

2.2 有参构造

• 有参构造给构造方法设计参数，调用时传入参数给属性赋值
• 作用：创建出的对象有指定属性值，而不是默认值
• 语法：

  public 类名(数据类型 变量名,...){
      this.成员属性 = 变量;
  }
  

public class Student {
    String name;
    int age;

    // 无参构造
    public Student(){
        System.out.println("Student()执行了");
    }

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

    public void study(){
        System.out.println(name+"在学习");
    }
}

2.3 构造方法总结

• 每个类都默认提供无参构造方法
• 但类中只要定义了任何一个构造方法，默认无参构造就不再提供
• 无论无参还是有参构造，都是用于创建对象的
• 无参构造创建的对象属性是默认值
• 有参构造创建的对象属性直接有指定值
• 建议定义类时，同时提供有参和无参构造方法

三、方法重载

3.1 重载概念

• 重载（Overload）指类中方法的重载
• 语法要求：
  • 方法名相同
  • 参数列表不同（类型、个数、顺序任意不同均可）
  • 与返回值无关
• 作用：方便使用，会根据传入的参数自动确定执行哪个方法

3.2 重载示例

class Person {
    public void show() {
        System.out.println("show()");
    }
    public void show(int age) {
        System.out.println("show(int age)");
    }
    public void show(String name) {
        System.out.println("show(String name)");
    }
    public void show(int age, String name) {
        System.out.println("show(int age, String name)");
    }
    public void show(String age, int name) {
        System.out.println("show(String age, int name)");
    }
}

3.3 构造方法重载

构造方法也可以重载，方便通过不同参数创建对象：

Student s1 = new Student();
Student s2 = new Student(18);
Student s3 = new Student("李华");
Student s4 = new Student("翠花", 18);

四、封装

4.1 封装介绍

• 面向对象编程三大特性：封装、继承、多态
• 封装指将代码打包，包括：
  • 方法的封装
  • 属性的封装
  • 类的封装
• 作用：隐藏实现细节，只暴露使用接口

4.2 属性的封装步骤

1. 属性私有化，使用 private 修饰符
2. 提供 setXxx () 和 getXxx () 方法（固定写法，set/get 后接属性名大写）

4.3 封装示例

class Person {
    private String name;
    private int age;
    
    // setter和getter方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 可以在setter方法中添加验证逻辑
        if (age < 0 || age > 120) {
            System.out.println("年龄不合法");
            return;
        }
        this.age = age;
    }
}

4.4 使用封装

public class Demo2 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("俊强");
        p1.setAge(21);
        System.out.println(p1.getName() + ":" + p1.getAge());
    }
}

五、实战案例

5.1 类中定义其他类的属性

定义工人类 (Worker) 和地址类 (Address)，在工人类中包含地址类属性：

Address 类

public class Address {
    private String address; // 住址
    private int zipCode; // 邮编

    public Address() {}

    public Address(String address, int zipCode) {
        this.address = address;
        this.zipCode = zipCode;
    }

    // getter和setter方法
    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }
    public int getZipCode() { return zipCode; }
    public void setZipCode(int zipCode) { this.zipCode = zipCode; }
}

Worker 类

public class Worker {
    private String name;
    private int age;
    private double salary;
    private Address addr; // 地址属性

    public Worker() {}

    // 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) { this.age = age; }
    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
    public void setAddr(Address addr) { this.addr = addr; }
    public Address getAddr() { return addr; }
}

测试类

public class TestWorker {
    public static void main(String[] args) {
        // 创建Worker对象
        Worker worker = new Worker();
        worker.setName("zhangsan");
        worker.setAge(25);
        worker.setSalary(2500);

        // 创建Address对象
        Address address = new Address();
        address.setAddress("北京市海淀区清华园1号");
        address.setZipCode(100084);
        
        // 设置工人地址
        worker.setAddr(address);

        // 输出信息
        System.out.println("工人姓名:" + worker.getName());
        System.out.println("工人年龄:" + worker.getAge());
        System.out.println("工人工资:" + worker.getSalary());
        System.out.println("工人住址:" + worker.getAddr().getAddress());
        System.out.println("住址邮编:" + worker.getAddr().getZipCode());
    }
}

六、重点总结

1. 构造方法

   • 用于创建对象和初始化
   • 无参构造创建的对象属性为默认值
   • 有参构造创建的对象属性为指定值

2. 重载

   • 方法名相同，参数列表不同
   • 与返回值无关
   • 方便方法调用

3. 封装

   • 属性私有（private）
   • 提供 setter 和 getter 方法
   • 是 JavaBean 规范的重要部分

4. 类中可以包含其他类的对象作为属性，这是面向对象编程中组合关系的体现