【 类与对象、成员变量与局部变量、封装、构造方法 】

在编程的世界中，有两种主流的思想：
面向过程：当需要实现一个功能的时候，每一个步骤都要自己亲力亲为，处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。（也就是自己不做，找人帮我做事儿，偷懒儿。）
这里的对象泛指现实世界中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为抽象出来，描述成计算机事件设计思想。它区别面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

int[] array = {10, 20, 30, 40, 50};
// 如果使用面向对象的写法：
// JDK当中已经提供好了一个名字叫做Arrays的类，其中有一个名叫toString的方法
// 可以帮我们将数组转换成为字符串，样子和刚才一样。
System.out.println(Arrays.toString(array)); // [10, 20, 30, 40, 50]

定义好了一个类之后，通常情况下不能直接使用它。如果希望使用，需要创建一个对象。
也就是根据手机设计图，创造一个真正的手机。

如何使用自定义的类。
1. 导包：需要使用的类在什么位置。

import 包路径.类名称;

备注：
A.如果需要使用的类，和当前类，在同一个包里面，那么可以省略导包。
B.如果需要使用的类，位于java.lang包下，那么就可以不导包。
2.创建，格式：

类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用，两种方式：

使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)

/*
定义好了一个类之后，通常情况下不能直接使用它。如果希望使用，需要创建一个对象。
也就是根据手机设计图，创造一个真正的手机。

如何使用自定义的类。
1. 导包：需要使用的类在什么位置。
import 包路径.类名称;
备注：
    A.如果需要使用的类，和当前类，在同一个包里面，那么可以省略导包。
    B.如果需要使用的类，位于java.lang包下，那么就可以不导包。

2. 创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用，两种方式：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
 */
package cn.itcast.day06.demo01;
public class Demo02Student {
    public static void main(String[] args) {
        // 创建对象
        Student stu = new Student();
        // 使用其中的成员变量
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        System.out.println("===============");

        // 改变成员变量的取值
        stu.name = "赵丽颖";
        stu.age = 18;

        System.out.println(stu.name); // 赵丽颖
        System.out.println(stu.age); // 18
        System.out.println("===============");

        // 调用成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

package cn.itcast.day06.demo01;

/*
定义一个类，用来模拟现实当中学生事物。

属性：姓名、年龄
行为：吃饭、睡觉、学习

对应到类当中：

成员变量（属性）：
    String name;
    int age;
成员方法（行为）：
    public void eat() {}
    public void sleep() {}
    public void study() {}

1. 如果一个变量直接定义在类当中，在方法外，那么这就是一个成员变量。（移动位置了）
2. 如果一个方法定义的时候没有static，那么这就是一个成员方法。（去掉static）
 */
public class Student {
    // 成员变量
    String name; // 姓名
    int age; // 年龄
    // 成员方法
    public void eat() {
        System.out.println("吃饭饭");
    }
    public void sleep() {
        System.out.println("睡觉觉");
    }
    public void study() {
        System.out.println("学习");
    }

}

任何数据类型，都可以作为方法的参数类型。


当基本类型作为方法参数的时候，传递的是一个【数据值】。
当引用类型作为方法参数的时候，传递的是一个【地址值】。

如果两个人的地址值相同，那么根本操作的就是同一个对象。

使用自定义的类作为参数类型
示例一：

示例二：

局部变量与成员变量

• 代码当中的位置不同。【重点】
  局部变量：定义在方法{}当中，或者是方法的参数。
  成员变量：直接定义在类当中，在方法外。

• 内存当中的位置也不同。（了解）
  局部变量：栈内存。
  成员变量：堆内存。

• 生命周期也不同。（了解）
  局部变量：随着方法进栈而出现，随着方法出栈而消失。
  成员变量：随着对象创建而出现，随着对象被回收而消失。（一般更长）

• 默认值不同。【重点】
  局部变量：没有默认值，如果不赋值，不能用。
  成员变量：如果没有赋值，那么会有一个默认值。

• 作用域不同。（了解）
  局部变量：只有当前方法内部才可以用。
  成员变量：只要是当前类里面，就能用。

• private关键字：

  格式 :

    private 数据类型 成员变量名称;

加上private之后：本类当中的使用不受影响，但是超出了本类范围，外面就不能直接使用了。

为private成员变量编写一对儿Getter Setter方法：
Getter方法的定义：一种成员方法，有返回值，没有参数，名字叫做getXxx，后面是对应的成员变量名称。
Setter方法的定义：一种成员方法，没有返回值，有参数，名字叫做setXxx，后面是对应的成员变量名称。

• this关键字：
  问题描述：
  局部变量和成员变量出现了重名现象，编译照样没有错误，但是运行的时候，根据就近原则，使用的是局部变量。区分不开。
  解决方案：
  使用一种简单的格式，就可以区分：this.成员变量
  this代表当前对象，“通过谁调用的方法，谁就是this。”

• 构造方法 ：
  构造方法是一种特殊的方法，专门用来创建对象的。
  当我们通过new关键字创建对象的时候，其实就是在调用构造方法。

构造方法：

public 类名称(参数类型 参数名称) {
    // ...
}

注意事项：
1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要完全一样。
2. 构造方法根本不写返回值类型，就连void都不写。
3. 构造方法当中不能return一个具体数值。
4. 如果没有定义任何构造方法，那么编译器将会默认赠送一个无参数、什么都不做的构造方法。
5. 一旦自己定义了至少一个构造方法，那么编译器将根本不再赠送。
6. 构造方法也是可以重载的。
重载（Overload）：方法名称一样，但是参数列表不一样。

如何定义一个标准的XXX类？

1. 所有的成员变量都使用private私有化。
2. 编写一个无参数的构造方法。
3. 编写一个全参数的构造方法。
4. 为每一个成员变量编写一对儿Getter Setter方法。

POJO(Plain Old Java Object)
VO BO DTO Entity Domain Model…