面向对象之封装

1. 类和对象

1.1 类和对象的理解

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

类
类的理解
类是对现实生活中一类具有共同属性和行为的事物的抽象
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
简单理解：类就是对现实事物的一种描述
类的组成
属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸的着的真实存在的实体
简单理解：类是对事物的一种描述，对象则为具体存在的事物

1.2 类的定义

类的组成是由属性和行为两部分组成
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：
①定义类
②编写类的成员变量
③编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;
}

public class Phone {
	//成员变量
	String brand;
	int price;
	//成员方法
	public void call() {
		System.out.println("打电话");
	}
	public void sendMessage() {
		System.out.println("发短信");
	}
}

1.3 对象的使用

创建对象的格式：类名 对象名 = new 类名();
调用成员的格式：对象名.成员变量 对象名.成员方法();

public class PhoneDemo {
	public static void main(String[] args) {
		//创建对象
	    Phone p = new Phone();
             变量      对象
		//使用成员变量
		System.out.println(p.brand);
		System.out.println(p.price);
		p.brand = "小米";
		p.price = 2999;
		System.out.println(p.brand);
		System.out.println(p.price);
		//使用成员方法
		p.call();
		p.sendMessage();
	}
}

1.4 对象内存

《栈内存，堆内存，方法区》Java程序的.class文件加载到方法区，在.class文件中找方法（main方法以及其他自定义的方法），main方法先进栈并在栈内存中开辟一块内存使用，执行main方法中的代码，有变量的话会在mian内存里面开辟一块内存使用，同时类的.class文件加载到方法区，并在堆内存中开辟一块内存空间使用，里面存放的是类的成员变量，成员方法还在方法区的.class文件中，堆内存中的对象有类型指针，指向他的.class文件。main方法中执行对象的方法时，会根据栈内存中变量的地址值找到堆内存中的对象，然后根据堆内存中的类型指针找到对象的类的.class文件加载方法，方法在被调用执行的时候，会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。继续执行main方法，知道main方法中无代码执行，main方法消失，程序结束。

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

2. 成员变量和局部变量

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：

​ 成员变量（堆内存）属于对象，对象在堆内存

​ 局部变量（栈内存）属于方法，方法在栈内存

生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

3. 封装

3.1 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，就要提供相应的操作

提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

public class Student {

    //成员变量
    private String name;    //姓名
    private int age;        //年龄

    //写一个方法，外界可以调用这个方法来访问私有的成员变量
    public void setAge(int a) {
        if (a < 0 || a > 130) {
            //throw new RuntimeException("年龄非法");
            System.out.println("年龄非法");
            return;
        }

        age = a;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    //成员方法
    public void study() {
        System.out.println("学生不学习，天理难容");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}


public class StudentDemo {

    /**
     * 出现这个问题的原因
     *      可以随意访问对象的成员变量
     *
     * 如何解决
     *      不能让外界随意访问
     *
     * private 关键字
     *      作用：
     *          被 private 关键字修饰的成员，只能在本类中访问，外界无法直接访问
     */
    public static void main(String[] args) {
        //创建对象
        Student stu = new Student();

        //给对象的成员变量赋值
        stu.setName("张三");  //
        //stu.age = -18;
        stu.setAge(-18);

        //打印对象信息
//        System.out.println(stu.name + ", " + stu.age); //张三, 18
        System.out.println(stu.getName() + ", " + stu.getAge()); //张三, 18


    }
}

3.2 this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

this代表了当前对象，用在方法里面，如果在方法中写了 this，谁调用了这个方法，this 就是谁

public class Student {

    //成员变量
    private String name;    //姓名
    private int age;        //年龄

    //写一个方法，外界可以调用这个方法来访问私有的成员变量
    public void setAge(int age) {
        if (age < 0 || age > 130) {
            //throw new RuntimeException("年龄非法");
            System.out.println("年龄非法");
            return;
        }

        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    //成员方法
    public void study() {
        System.out.println(this);
        System.out.println("学生不学习，天理难容");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}


public class StudentDemo02 {

    /**
     * this 代表了当前对象
     *
     *      如果在方法中写了 this，谁调用了这个方法，this 就是谁
     */
    public static void main(String[] args) {
        //创建学生对象
        Student stu1 = new Student();
        Student stu2 = new Student();

        stu1.study();
        stu2.study();
    }
}

3.3 封装思想

1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

3.4 构造方法

构造方法的创建：
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法。

构造方法的重载：
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。

推荐的使用方式：
无论是否使用，都手工书写无参数构造方法

重要功能！
可以使用带参构造，为成员变量进行初始化

public class Student {

    //属性，成员变量（写在类中、方法外的变量）
    private String name;    //姓名
    private int age;        //年龄

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

    public Student() {

    }

    //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;
    }

    //行为，成员方法（和我们以前学的方法是一样的，不需要写 static 关键字）
    public void study() {
        System.out.println("好好学习");
    }
    public void doHomework() {
        System.out.println("多做练习");
    }
}

public class StudentDemo {

    /**
     * 构造方法
     *      - 构造方法的方法名和类名完全相同
     *      - 构造方法没有返回值，连 void 也不用写
     *
     * 构造方法在每次创建类的对象时，会自动执行
     *
     * 作用：
     *      构造方法的作用是在创建对象的时候，给对象的成员变量赋值
     *
     * 注意事项
     *      如果一个类中，没有写任何的构造方法，编译器会在编译代码的时候，自动的加上一个没有参数的构造方法
     *
     *      如果写了构造方法，编译器就不帮我们添加空参的构造方法了
     */
    public static void main(String[] args) {
        //创建学生对象
        Student stu = new Student("张三", 18);

        Student stu2 = new Student();
    }
}

4. 标准类

标准类包含空参，有参构造方法，getter/setter方法，数据展示方法。

public class Student {

    //成员变量
    private String name;    //姓名
    private int age;        //年龄
    private char gender;    //性别

    //空参构造
    public Student() {
    }

    //有参构造
    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    //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 char getGender() {
        return gender;
    }

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

    //成员方法，show 方法，展示对象中所有的数据
    public void show() {
        System.out.println(name + ", " + age + ", " + gender);
    }
}