封装（包、this、构造器、JavaBean、对象数组）

1.封装

1.1 原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

1.2 步骤

• 使用 private关键字来修饰实例变量
• 提供被public修饰的公共 getXXX/setXXX方法，让外界通过这些方法访问到内部的成员变量
• 通过构造方法（构造器）可以在创建对象的同时就给对象的属性赋值

public class Student {
  private String name;
  private int age;

  public void setName(String n) {
    name = n;
  }

  public String getName() {
    return name;
  }

  public void setAge(int age) {
    age = age;
  }

  public int getAge() {
    return age;
  }
}

2.this关键字

1.this不能在静态方法里使用，可以在  非静态方法、构造方法、构造代码块 里使用；

2.this代表的是调用这个方法的当前对象。

        谁调用这个方法，方法里的this表示就是谁。

3.一般情况下，this可以省略。但是，如果方法里的局部变量和成员变量同名，this不能省略

public class ThisDemo {
    public static void main(String[] args) {
        Student s = new Student();
        // s.name = "jack";
        s.setName("jack");
        // s.age = 18;
        s.setAge(18);
        // s.gender = "男";
        s.setGender("男");

        // 如果直接打印对象，打印的结果是  类型@哈希值
        // 哈希值并不是内存地址值，而是根据内存地址计算出来的结果，一定程度上表示了这个对象的地址
        System.out.println("在main方法里的s = " + s);
        s.study();


        Student s1 = new Student();
        // s1.name = "tony";
        s1.setName("tony");
        s1.x = 5;
        s1.study();
        s1.demo();
    }
}

class Student {
    private String name;
    private int age;
    private String gender;
    int x;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getGender() {
        return this.gender;
    }

    public void study() {
        // 在这种情况下，this可以省略
        System.out.println(name + "正在学习");
        System.out.println(this.name + "正在学习");
    }

    public void demo() {
        // 当方法里出现和成员变量同名的局部变量时，此时的this不能省略
        String x = "hello";
        System.out.println(x);  // 如果直接访问，访问的是局部变量x
        System.out.println(this.x);  // 如果要访问成员变量x,必须要使用 this关键字!
    }

    public static void test() {
        // System.out.println(this);  静态方法里不能使用this
    }
}

3.包

3.1 使用另一个包里声明的类

• 写全类名，  包名.类名

com.company.bean.Person p = new com.company.bean.Person();

java.util.Scanner = new java.util.Scanner(System.in);

• 使用关键字 import导入一个类，可以不写包名，直接写类名

import java.util.Scanner;

Scanner = new Scanner(System.in);

• 如果在不同包里，有同名的两个类，其中一个可以使用import导入，另一个写 包名.类名，或者全部写 包名.类名

4.构造器（构造方法）

构造方法是一个特殊的方法，特殊在：

1. 方法名与类名必须要一致
2. 方法不能有返回值类型声明
3. 调用时要配合new关键字使用（Person p1 = new Person();  new Person()调用Person类的Person()构造方法，创建一个实例对象p1）
4. 每个类默认都有一个空参数的构造方法
5. 如果在类中自定义了构造方法，默认参数的构造方法会被覆盖
6. 构造方法可以重载（方法名 相同，参数不同）

public class ConstructorDemo {
    public static void main(String[] args) {
        Person p1 = new Person();  // 调用了Person类的 Person()构造方法
        // 创建好对象以后，给对象的属性赋值
        p1.setName("jack");
        p1.setAge(18);
        p1.setGender("男");
        p1.setHeight(1.75);
        p1.setWeight(75.5);
        p1.setCity("上海");

        // 有没有一种方式，可以让我们在创建对象的同时就给对象里的属性赋值
        Person p2 = new Person("tony", 20, "男", 1.85, 76, "上海");
        Person p3 = new Person("jerry", "男");
    }
}

public class Person {
    private String name;
    private int age;
    private String gender;
    private double height;
    private double weight;
    private String city;

    /*
     每个类默认都会有一个空参数的构造方法，但是如果在这个类里自定义了构造方法
     那么这个类里的默认空参构造方法会被覆盖
     如果想要使用默认空参构造方法，必须要手动的声明空参构造方法!
    */
    public Person() {
    }

    public Person(String name, int age, String gender, double height, double weight, String city) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.height = height;
        this.weight = weight;
        this.city = city;
    }

    // public Person(String gender, String name){}
    public Person(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }

5. JavaBean

一个标准的JavaBean应该有以下特点：

• 类被public修饰
• 成员变量使用private修饰私有化，禁止外部直接访问
• 提供被public修饰的get/set方法让外部可以通过方法调用访问
• 提供被public修饰的get/set方法让外部可以通过方法调用访问
• 有被public修饰的空参构造方法

6. 对象数组

数组里存储的是实例对象

public class ObjectArray {
    public static void main(String[] args) {
        int[] nums = new int[]{1, 2, 7};

        // 有一个数组，数组里存储的元素是 Dog类型的对象
        Dog[] dogs1 = new Dog[3];
        // dogs1[0] = 1;
        dogs1[0] = new Dog("大黄");
        dogs1[1] = new Dog("小白");
        dogs1[2] = new Dog("花花");

        for (int i = 0; i < dogs1.length; i++) {
            // 直接打印对象，输出的结果是 类型@哈希值
            // System.out.println(dogs1[i]);

            System.out.println(dogs1[i].getName());
        }

        Dog[] dogs2 = {
                new Dog("旺财"),
                new Dog("张三"),
                new Dog("来福")
        };
        System.out.println(dogs2[1].getName());
    }
}