【day6】类与对象、封装、构造方法

01_面向对象思想的概述

02_面向对象思想的举例

当我们使用面向过程的时候，所有的步骤全都是我们自己来做的；如果使用面向对象就是找人帮我们做事，帮你做事的这个人就是对象。
面向对象就是强调别人帮我做事，面向对象比较省事，简单化，只要管谁能够帮我就行

03_类和对象的关系

类是抽象的，只是一个描述而已，说你是什么能做什么，假的（类就是一个设计图，是虚的）
对象是具体的，可以打电话，拍照片。根据类创建的一个对象（对象是能实现功能，是实的）

如果想实现图纸当中的功能，就得根据图纸创建手机；同理，我们要想实现类当中的功能，通常情况下我们要根据一个抽象的类来实例化一个具体的对象。这里实例化就是创建

04_类的定义

注意:
1、普通的方法带有static的，而我们今天成员方法的特点是没有static关键字（方法没有static它就是成员方法了），和有没有参数有没有返回值是没有关系的
2、此前的那些变量都叫做局部变量，因为它们都是写在一个方法内部的；现在是直接把这个变量写在方法外类当中的，位置发生了改变，一旦直接写在类里就不是普通的变量了，它叫成员变量。

05_对象的创建及其使用

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用
如何创建一个对象：
1、导包：也就是指出需要使用的类，在什么位置。对于和当前类属于同一个包的情况，可以省略导包语句不写
2、创建：类名称 对象名 = new 类名称（）
3、使用：分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
（也就是，想用谁，就用对象名点儿谁）

注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。（引用类型为null）

06_手机类练习

要想使用它，就要根据一个类创建一个对象
同一个包下就不需要导包

07_一个对象的内存图

成员变量直接就找到，但是成员方法的步骤是红色先过来，绿色再继续走

总结：
1、在运行main方法之前，方法区要最先有数据。方法区是存储class相关信息，包含方法的信息。方法区保存的是.class相关数据（还包含成员变量、成员方法）
2、方法的运行一定要在栈当中。
3、凡是new出来的东西都在堆当中。
4、等号左边好比就是一个局部变量，对象名称就是个变量名称
5、堆当中的成员变量是参考着方法区中的成员变量在我的堆当中进行创建，null值就保存在堆里面。但是堆当中的成员方法是一个地址值，指向了右边的方法区，这点一定要注意。

08_两个对象使用同一个方法的内存图

shift+F6：可以给变量统一进行命名
方法要执行肯定要进栈，只要方法运行结束就要从栈中消失

两个都是new出来的对象，没有产生任何的联系，你是你我是我，相互不干扰，井水不犯河水
这两个对象当中的成员方法地址都指向了方法区当中同一块空间

09_两个引用指向同一个对象的内存图

两个对象如何产生联系？
将one当中保存的对象地址值赋值给two（虽然两个名称是不一样的，但是两个名称保存的地址是相同的）

两个对象名称指向了同一个对象空间

橙色找到对象，绿色找到方法

10_使用对象类型作为方法的参数

任何数据类型都能做方法的参数或者返回值

带有static的这就是一个普通的方法，它不需要对象，直接就能调用。

当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值

任何数据类型都能作为方法的参数往里传递，而如果要是说要是一个数组或者是一个对象一个类的话，那么真正传递的是0x666这样的地址值，有了地址值，想用谁你就点谁就可以了。

11_使用对象类型作为方法的返回值

自定义的类作为方法的返回值
返回值类型是phone，意思是最终会产生一个结果，这个结果是phone类型的
当使用一个对象类型作为方法的返回值时，返回值其实就是对象的地址值

12_成员变量和局部变量的区别

不赋值的局部变量不能用

局部变量跟着方法走，成员变量跟着对象走

13_面向对象三大特征之封装性

arry.fori：变成循环情况

封装就是将一些细节信息隐藏起来，对于外界不可见（我把一个具体的步骤封装成一个方法，那么外界只管调用拿结果就行）

14_private关键字的作用及使用

private直接放在成员变量最前方

对于private修饰的成员变量，可以使用一对set/get方法对变量进行赋值
set必须有参数无返回值，参数类型得和你set的值保持一致，名称的规则是：set然后首字母变大写；get必须没有参数有返回值，返回值的类型必须
一旦使用了private进行修饰，那么本类中当中仍然可以随意访问，但是，超出了本类的范围之外就不能再直接访问了

写上private的好处是：
一旦写上private，外边无法直接访问，直接间接访问，这样间接的方式写点代码就能阻止那些不合理的数据被设置进来（有大括号里面可以设置一些if语句），提高了代码的安全性

15_练习使用private关键字定义学生类

不能直接访问，我们get拿出来，set放进去
对于基本类型当中的boolean值，get方法一定要写成isXxx的形式，而setXxx规则不变

使用private关键字将需要保护的成员变量进行修饰
一旦使用private进行修饰，那么本类当中仍然可以随意访问。但是！超出了本类范围之外就不能再直接访问了

package day_06;

// alt+insert创建get、set快捷方法(set是往里放，get是往外拿，但前提是要写private成员变量)
// 对于基本类型当中的boolean值，get方法一定要写成isXxx的形式，而setXxx规则不变
public class student {
    private String name;    //姓名
    private int age;    //年龄
    private boolean male;   //是不是爷们儿

    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 boolean isMale() {
        return male;
    }

    public void setMale(boolean male) {
        this.male = male;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package day_06;

public class DemoStudent {
    public static void main(String[] args) {
        student stu=new student();
        stu.setName("胡歌");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println("姓名："+stu.getName());
        System.out.println("年龄："+stu.getAge());
        System.out.println("是不是爷们儿："+stu.isMale());
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

16_this关键字的作用（this解决重名）

private关键字可以提高我们代码的安全性
没有static的方法是成员方法


当将变量who修改成name时：

成员变量的前面写"this."，但是局部变量的前面什么都不要写。
this 关键字可以解决重名分不开的问题。
this一定是写在方法的内部写上this，而方法肯定调用才会执行，如果person调用satHello，那么person就是this。此处this.name其实就是person.name，就是对象名称person点方法名就是我自己的名字了。


通过谁调用的方法谁就是this，那this主要是用来在重名的情况下实现区分的效果。使用this可以点到成员变量

17_构造方法

注意重载形式的构造方法的使用


当去new关键字去创建的时候，其实类名称就是构造方法名。new对象就是在调用构造对象方法
构造方法中的参数有什么用？ 这样你就省的去写那个set什么了，用它的时候不用去调用set什么set什么，不用这样，你就可以直接能够通过构造方法往里传值

package day_06_构造方法;

/*构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：
public 类名称(参数类型 参数名称){
    方法体
}

注意事项：
1、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
3、构造方法不能return一个具体的返回值。
4、如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体什么事情都不做
public Student(){}      留空，什么也不做
5、一旦编写了至少一个构造方法，那么编译器将不在赠送。(除非把赠送的那个也写出来。)
6.构造方法也是可以进行重载的
重载：方法名称相同，参数列表不同

*/
/*
构造方法中的参数有什么用？
这样你就省的去写那个set什么了，用它的时候不用去调用set什么set什么，不用这样。你直接就能够通过构造方法往里传值

*/
public class Student {

    //成员变量
    private String name;
    private int age;

    //无参数的构造方法
    public Student()                                                                                                                                                                                     {  //constructor构造器
        System.out.println("默认无参构造方法执行了");
    }

    //全参数的构造方法
    public Student(String name,int age){
        System.out.println("全参构造方法执行了");
        this.name=name;
        this.age=age;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

package day_06_构造方法;

public class DemoStudent {
    public static void main(String[] args) {
        Student student=new Student();  //无参构造
        System.out.println("==================");

        Student student2=new Student("赵丽颖",20);//全参构造
        //没有用set方法，直接通过构造就给它放进去了。 this.name=name;  this.age=age;
        System.out.println("姓名："+student2.getName()+",年龄："+student2.getAge());

        //如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
        student2.setAge(21);//改变年龄
        System.out.println("姓名："+student2.getName()+",年龄："+student2.getAge());

       /* 重载形式的全参数的构造方法，只是在创建对象的时候更加方便我们把那些现成的数据通过参数的形式设置进来
       而省去你多次调用setXxx的方法这样的麻烦，但是当你去修改对象内容的时候，setXxx方法还是有用的。

       目前这个类是由4个部分组成的：
       1.分别是成员变量都用private
       2.无参数的构造方法一定要自己写上，否则人家是不会赠送的。
       3.因为我们要再写一个全参数的构造方法
       4.get、set方法

       */
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

18_定义一个标准的类（4部分组成）

package day_06_定义一个标准类;
/*
一个标准的类通常要拥有下面四个组成部分：
     1.所有的成员变量都要使用private关键字修饰
     2.为每一个成员变量编写一对儿get\set方法
     3.编写一个无参数的构造方法
     4.编写一个全参数的构造方法

这样标砖的类也叫做Java Bean
*/
public class Student {

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

    //2.无参数的构造方法
    public Student() {
    }

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

    //4.set get方法
    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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package day_06_定义一个标准类;

public class DemoStudent {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("迪丽热巴");
        stu.setAge(20);
        System.out.println("姓名："+stu.getName()+",年龄,"+stu.getAge());
        System.out.println("=========================");

        //我不想set一个一个往里放，我想一下子把这些数据放进去
        Student stu2=new Student("古力娜扎",21);
        System.out.println("姓名："+stu2.getName()+",年龄,"+stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名："+stu2.getName()+",年龄,"+stu2.getAge());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19