封装，private关键字，this关键字，构造方法，static 关键字

封装：
定义：封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
private关键字
封装的代码举例：

package com.newedu.jb.day06;
/**
 * 定义一个学生类
 * @author 小可爱
 *
 */
public class Stu {
    //private 私有的，访问修饰符， 成员变量对外不可见
    //成员变量
    private String name; //默认值 null

    private int age;//默认值 0

    private String school; //默认值 null

    //public ：公共的 ，公开的，访问修饰符
    public void setName(String name1){
        name = name1;
    }

    public String getName(){
        return name;
    }
    public void setAge(int age1){
        if(age1>=0 && age1<=150){
            age = age1;
        }else{
            age = 0;
            System.out.println("设置年龄非法值！");
        }
    }
    public int getAge(){
        return age;
    }
    private void setSchool(String school1){
        school = school1;
    }
    public String getSchool(){
        return school;
    }
    /**
     * getter and setter
     */

    //成员方法

    public void eat(){
        System.out.println("eat()方法被调用了");
    }

    public void sleep(){
        System.out.println("sleep()方法被调用了");
    }

    public void study(){
        System.out.println("Student()方法被调用了");
    }

    public void showInfo(){
        System.out.println("name:"+name+" age:"+age+" school:"+school);
        //调用自己的方法
        method1();
    }

    private void method1(){
        System.out.println("私有的方法method1()");
    }
}

访问修饰符：

this关键字：
this:代表所在类的对象引用，当前对象
什么时候使用this呢?
局部变量隐藏成员变量，局部变量与成员变量重名了
其他用法后面和super一起讲解（构造方法的调用)
构造方法：
构造方法作用
给对象的成员变量进行初始化
构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
构造方法注意事项
如果不提供构造方法，系统会给出默认构造方法(无参构造）
如果提供了构造方法，系统将不再提供
构造方法也是可以重载的
构造方法代码演示：

package com.newedu.jb.day06;
/**
 * 自定义一个类型Teacher，表示老师
 * @author 小可爱
 *
 */
public class Teacher {
    //成员变量
    private String name;
    private int age;
    private String school;

    //构造方法 constructor
    //构造方法的作用：给对象的成员变量初始化（赋值）
    //构造方法的格式：
    // 1:方法名和类名相同
    // 2:没有返回值类型，连void也没有

    public Teacher(){
        this.name = "";
        this.age = 25;
        this.school = "中原工学院";
        System.out.println("Teacher类型的构造方法，无参构造方法");
    }

    /**
     * jvm 会 判断当前类，是否有构造方法，无论是无参的还是有参数的，
     * 如果没有：jvm自动添加一个无参构造方法
     * 如果有：什么也不做
     */

    //构造方法重载
    public Teacher(String name,int age,String school){
        this.name  = name;
        this.age = age;
        this.school = school;
    }

    //setter and getter
    // setter and getter 作用 读写成员变量，访问成员变量
    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 String getSchool() {
        return school;
    }
    public void setSchool(String school) {
        this.school = school;
    }
    //成员方法
    public String toString() {
        return "Teacher [name=" + name + ", age=" + age + ", school=" + school + "]";
    }
}

package com.newedu.jb.day06;
/**
 * Teacher的测试类
 * @author 小可爱
 *
 */
public class TeacherDemo {
    public static void main(String[] args) {
        //创建一个对象,并调用Teacher类的无参构造方法来对对象进行初始化。
        Teacher teacher = new Teacher();

        System.out.println(teacher.toString());

        System.out.println("====================");

        Teacher teacher1 = new Teacher("尚文旭",35,"中原工学院");
        System.out.println(teacher1.toString());

    }
}

一个类的标准写法：

package com.newedu.jb.day06;
/**
 * 自定义的老师类
 * @author 小可爱
 *
 */
public class Teacher1 {
    //成员变量
    private String name;
    private int age;
    public static String school;

    //构造方法
    public Teacher1(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
    public Teacher1() {
    }
    public Teacher1(String name) {
        this.name = name;
    }
    public Teacher1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher1(int age, String school) {
        this.age = age;
        this.school = school;
    }
    public Teacher1(String name, String school) {
        this.name = name;
        this.school = school;
    }
    public Teacher1(int age) {
        super();
        this.age = age;
    }

    // 成员方法 setter and getter
    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 String getSchool() {
        return school;
    }
    public void setSchool(String school) {
        this.school = school;
    }

    //成员方法
    public String toString() {
        return "Teacher1 [name=" + name + ", age=" + age + ", school=" + school + "]";
    }
    // 在static的成员方法中，不能存在this关键字。
    public static void showInfo(){
//      System.out.println(this.name+this.age);

//      toString();

    }

}

static 关键字：
可以修饰成员变量和成员方法
static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能(直接)访问静态的成员变量和静态的成员方法

package com.newedu.jb.day06;
/**
 * 自定义的老师类
 * @author 小可爱
 *
 */
public class Teacher1 {
    //成员变量
    private String name;
    private int age;
    public static String school;

    //构造方法
    public Teacher1(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
    public Teacher1() {
    }
    public Teacher1(String name) {
        this.name = name;
    }
    public Teacher1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher1(int age, String school) {
        this.age = age;
        this.school = school;
    }
    public Teacher1(String name, String school) {
        this.name = name;
        this.school = school;
    }
    public Teacher1(int age) {
        super();
        this.age = age;
    }

    // 成员方法 setter and getter
    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 String getSchool() {
        return school;
    }
    public void setSchool(String school) {
        this.school = school;
    }

    //成员方法
    public String toString() {
        return "Teacher1 [name=" + name + ", age=" + age + ", school=" + school + "]";
    }
    // 在static的成员方法中，不能存在this关键字。
    public static void showInfo(){
//      System.out.println(this.name+this.age);

//      toString();

    }

}

package com.newedu.jb.day06;
/**
 * static 关键字的代码演示
 * @author 小可爱
 *
 */
public class TeacherDemo2 {
    public static void main(String[] args) {
        /**
         * 提出一个需求，Teacher对象都是 现在都是轻工业
         */

        //创建一个Teacher对象
        Teacher1  t1 = new Teacher1("尚文旭",35,"中原工学院");

        //创建第二个Teacher对象
        Teacher1 t2 = new Teacher1("小可爱",32,"中原工学院");

        //创建第二个Teacher对象
        Teacher1 t3 = new Teacher1("小泡泡",36,"中原工学院");

        /**
         * 存在这样的问题：
         * a:所有的老师，既然都是同一所学校的，为什么还要每一个对象还要再写一次。
         * b:万一，我们的学校名字发生了改变，"中原工学院" "软件学院";
         * 我们需要对所有的对象中的 学校名字进行改变。
         *
         * 通过static来解决这种问题。
         * static： 静态的，也是一个修改符（关键字）类层面，随着类的加载而加载
         */

        t1.setSchool("中原工学院");

        System.out.println(t1.toString());
        System.out.println(t2.toString());
        System.out.println(t3.toString());
        //The static field Teacher1.school should be accessed in a static way
        t1.school = "xxx";
        Teacher1.school = "bbbb";//jvm 推荐用类名.static成员来访问静态的成员
    }
}