面向对象（封装、this、private、static关键字）

面向对象(封装的概述)

封装概述：

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装好处：

1. 隐藏实现细节，提供公共的访问方式

2. 提高了代码的复用性

3. 提高安全性。

封装原则：

1. 将不需要对外提供的内容都隐藏起来。

2. 把属性隐藏，提供公共方法对其访问。

面向对象(private关键字的特点)

private关键字特点：

1. 是一个权限修饰符

2. 可以修饰成员变量和成员方法

3. 被其修饰的成员只能在本类中被访问

面向对象(private应用的案例)

package org.westos.demo5;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-06 09:46
 */
public class Person {
     String name;
    //private 是一个权限修饰符，私有的，可以修饰成员变量、成员方法，被修饰的成员，只能在本类中被访问，外界无法访问。
    private int age;

    public void setAge(int nianling){
        if(nianling>=0&&nianling<=100){
            age = nianling;
        }else{
            System.out.println("设置的年龄不合理");
        }

    }
    public int getAge(){      //提供公共方法来实现对加了private权限修饰符的成员变量的访问
        return age;
    }
    public void show() {
        System.out.println(name);
        System.out.println(age);
    }
}

上述代码在类的成员变量前加上了private权限修饰符之后，只能在本类当中被访问，在测试类中直接调用会报错。

package org.westos.demo5;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-06 09:46
 */
public class MyTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.name="张三";
       // person.age=23; 私有的成员，外界不能直接访问了
        person.setAge(10);
        person.show();
        System.out.println("---------------------------");
        Person person2 = new Person();
        //我们通过 对象名.成员变量名=值 这种方式给成员变量设置值
        //我们通过 对象名.成员变量名 这种方式，不能排除一些不合理的数据
        //我们希望能够对，给成员变量设置的数据进行一些校验。
        //那么我们可以屏蔽掉 对象名.成员变量名=值 这种设置方式
        //怎么屏蔽掉，可以使用关键字 private
        person2.name = "李四";
        person2.setAge(100);
        //person2.age = 1440; 私有的成员，外界不能直接访问了
        person2.show();

        System.out.println(person.name);
       // int age=person.age;
        int age = person.getAge();
        System.out.println(age);

    }
}

就像上面的注释提到的，在private修饰成员后，该成员只能在本类之中被访问，要想让测试类来访问，就需要在定义类时提供公共的访问方法，来让外界通过这个公共的访问方法来实现对被private修饰的成员变量或方法的访问，所以我们就可以通过定义公共方法来实现对错误参数的一些屏蔽。这也是使用private关键字的一个好处。

面向对象(this关键字的概述和应用)

为什么要有this：
当我们的 局部变量 和 成员变量 相同 的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题

package org.westos.demo91;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-06 10:37
 */
public class Teacher {
    //私有成员变量
    private String name;
    private int age;

    //提供公共的set方法
    public void setName(String name) { //成员变量和局部变量重名了
        System.out.println("this代表的那个对象" + this);
        this.name = name;
        //teacher.name=name;
    }

    public void setAge(int age) { //成员变量和局部变量重名了
        System.out.println("this代表的那个对象" + this);
        //age = age;                              /* 变量的访问原则，遵循就近原则：
                                                     方法中要访问一个变量，我会先
                                                     在局部位置找，找到就使用如果找
                                                     不到，会去成员位置找，找到就
                                                     使用 ，因为这个原因，将自己赋
                                                     给了自己，程序会报错*/
        this.age = age;
    }

    //提供的公共的get方法
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    public void teache() {
        System.out.println("教书");

    }

}

正如上述代码中的注释所提到的，局部变量与成员变量名称一样，所以系统会报错，因为出现了局部变量隐藏成员变量的现象，为了进行区分，就会用到this关键字。

this关键字特点：

是当前类的对象引用，简单的记，它就代表当前类的一个对象，谁调用这个方法,那么该方法的内部的this就代表谁。

this的应用场景：
解决局部变量隐藏成员变量

面向对象(构造方法)

构造方法概述和作用：
创建对象,给对象中的成员进行初始化

构造方法格式：

1. 方法名与类名相同

2. 没有返回值类型，连void都没有

3. 没有具体的返回值

代码示例：

package org.westos.demo6;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-06 14:54
 */
public class Rectangle {
    //定义属性
    private double width;
    private double height;
    //提供构造方法

    public Rectangle() {     //无参构造
    }

    public Rectangle(double width, double height) {   //有参构造
        this.width = width;
        this.height = height;
    }
    //提供get set 方法

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //提供获取周长的方法
    public double getPerimeter() {

       return (width + height) * 2;
    }

    //提供获取面积的方法
    public double getArea() {
        return width * height;
    }


}

1. 在上述类的定义中引入了构造方法，构造方法有两种，无参构造和有参构造。

2. 在我们自定以一个类以后，系统会自带一个无参构造，但不会显示出来，所以我们即使在自定义类中再次写入无参构造的代码块也不会影响程序正常运行，也就是说在不涉及到有参构造时，代码块中的无参构造代码块可有可无，使用无参构造来创建对象并不会受到影响，但是由于没有涉及到有参构造，所以无法使用有参构造来创建对象。

3. 但是有参构造不一样，所以如果在自定义类中写入了有参构造，则类自带的无参构造就会失效，我们就只能使用有参构造来创建对象，所以用户要是想继续使用无参构造，就必须在类中写入无参构造的代码块，这样这个类既可以使用有参构造，也可以使用无参构造。

面向对象(构造方法的重载及注意事项)

构造方法也存在重载，和方法的重载一样，自定义类中允许存在多个同名的构造方法，但是不同点是参数个数和参数类型，在创建对象时系统会根据参数情况来自动匹配使用哪种构造方法。

构造方法注意事项：

1. 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

2. 如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
   注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

3. 当然，使用有参构造方法来创建对象时，可以直接使用有参构造中的参数来给对象的成员变量进行赋值，模板在上述代码已经给出。

面向对象(创建一个对象的步骤)

画图演示

Student s = new Student();
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量

面向对象(static关键字)

package org.westos.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-06 15:11
 */
public class Person {
    public String name;
    //我想让中国这个数据变成共享变量，让这个类的所有对象，都能够共享他
    // 我们可以使用一个关键字，static 静态的 可以修饰成员变量，和成员方法
    //被static所修饰的成员变量，是一个共享变量，被类的所有对象所共享
    //被静态所修饰的成员，是随时类的加载而加载（随着 .class文件进内存，静态的东西就会加载）
    //优先于对象而存在
    public static String country = "中国";
}

static关键字的特点：

1. 随着类的加载而加载

2. 优先于对象存在

3. 被类的所有对象共享

举例：咱们班级的学生应该共用同一个班级编号。 其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)

4. 可以通过类名调用，其实它本身也可以通过对象名调用，推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员

   static内存图
   大体过程与上述对象的创建内存图一致，只是被加载进方法区的东西会被分为共享区和非共享区，共享区中的东西为静态东西，所以静态变量存在于方法区。

面向对象(static的注意事项)

static的注意事项：

1. 在静态方法中是没有this关键字的
   如何理解呢?
   静态是随着类的加载而加载，this是随着对象的创建而存在。
   静态优先于对象。

2. 静态方法只能访问静态的成员变量和静态的成员方法
   简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态。

面向对象(静态变量和成员变量的区别)

1. 所属不同
   静态变量属于类，所以也称为类变量
   成员变量属于对象，所以也称为实例变量(对象变量)

2. 内存中位置不同
   静态变量存储于方法区的静态区
   成员变量存储于堆内存

3. 内存出现时间不同
   静态变量随着类的加载而加载，随着类的消失而消失
   成员变量随着对象的创建而存在，随着对象的消失而消失

4. 调用不同
   静态变量可以通过类名调用，也可以通过对象调用
   成员变量只能通过对象名调用