Java基础语法Day_06（面相对象和封装）

第1节 描述类介绍与使用

　　day06_01_面向对象思想的概述

　　day06_02_面向对象思想的举例

　　day06_03_类和对象的关系

　　day06_04_类的定义

　　day06_05_对象的创建及其使用

　　day06_06_手机类练习

　　day06_07_一个对象的内存图

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

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

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

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

　　day06_12_成员变量和局部变量的区别

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

　　day06_14_private关键字的作用及使用

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

　　day06_16_this关键字的作用

　　day06_17_构造方法

　　day06_18_定义一个标准的类（自动生成代码练习题）

　　小节测试

 1 package cn.itcast.day06.demo01;
 2
 3 import java.util.Arrays;
 4
 5 /*
 6 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
 7 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。
 8  */
 9 public class Demo01PrintArray {
10
11     public static void main(String[] args) {
12         int[] array = { 10, 20, 30, 40, 50, 60 };
13
14         // 要求打印格式为：[10, 20, 30, 40, 50]
15         // 使用面向过程，每一个步骤细节都要亲力亲为。
16         System.out.print("[");
17         for (int i = 0; i < array.length; i++) {
18             if (i == array.length - 1) { // 如果是最后一个元素
19                 System.out.println(array[i] + "]");
20             } else { // 如果不是最后一个元素
21                 System.out.print(array[i] + ", ");
22             }
23         }
24         System.out.println("==============");
25
26         // 使用面向对象
27         // 找一个JDK给我们提供好的Arrays类，
28         // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
29         System.out.println(Arrays.toString(array));
30     }
31
32 }

 1 package cn.itcast.day06.demo01;
 2
 3 /*
 4 定义一个类，用来模拟“学生”事物。其中就有两个组成部分：
 5
 6 属性（是什么）：
 7     姓名
 8     年龄
 9 行为（能做什么）：
10     吃饭
11     睡觉
12     学习
13
14 对应到Java的类当中：
15
16 成员变量（属性）：
17     String name; // 姓名
18     int age; // 年龄
19 成员方法（行为）：
20     public void eat() {} // 吃饭
21     public void sleep() {} // 睡觉
22     public void study() {} // 学习
23
24 注意事项：
25 1. 成员变量是直接定义在类当中的，在方法外边。
26 2. 成员方法不要写static关键字。
27  */
28 public class Student {
29
30     // 成员变量
31     String name; // 姓名
32     int age; // 姓名
33
34     // 成员方法
35     public void eat() {
36         System.out.println("吃饭饭！");
37     }
38
39     public void sleep() {
40         System.out.println("睡觉觉！");
41     }
42
43     public void study() {
44         System.out.println("学习！");
45     }
46
47 }

 1 package cn.itcast.day06.demo01;
 2
 3 /*
 4 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
 5
 6 1. 导包：也就是指出需要使用的类，在什么位置。
 7 import 包名称.类名称;
 8 import cn.itcast.day06.demo01.Student;
 9 对于和当前类属于同一个包的情况，可以省略导包语句不写。
10
11 2. 创建，格式：
12 类名称 对象名 = new 类名称();
13 Student stu = new Student();
14
15 3. 使用，分为两种情况：
16 使用成员变量：对象名.成员变量名
17 使用成员方法：对象名.成员方法名(参数)
18 （也就是，想用谁，就用对象名点儿谁。）
19
20 注意事项：
21 如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。
22  */
23 public class Demo02Student {
24
25     public static void main(String[] args) {
26         // 1. 导包。
27         // 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写
28
29         // 2. 创建，格式：
30         // 类名称 对象名 = new 类名称();
31         // 根据Student类，创建了一个名为stu的对象
32         Student stu = new Student();
33
34         // 3. 使用其中的成员变量，格式：
35         // 对象名.成员变量名
36         System.out.println(stu.name); // null
37         System.out.println(stu.age); // 0
38         System.out.println("=============");
39
40         // 改变对象当中的成员变量数值内容
41         // 将右侧的字符串，赋值交给stu对象当中的name成员变量
42         stu.name = "赵丽颖";
43         stu.age = 18;
44         System.out.println(stu.name); // 赵丽颖
45         System.out.println(stu.age); // 18
46         System.out.println("=============");
47
48         // 4. 使用对象的成员方法，格式：
49         // 对象名.成员方法名()
50         stu.eat();
51         stu.sleep();
52         stu.study();
53     }
54
55 }

手机类练习

 1 package cn.itcast.day06.demo02;
 2
 3 /*
 4 定义一个类，用来模拟“手机”事物。
 5 属性：品牌、价格、颜色
 6 行为：打电话、发短信
 7
 8 对应到类当中：
 9 成员变量（属性）：
10     String brand; // 品牌
11     double price; // 价格
12     String color; // 颜色
13 成员方法（行为）：
14     public void call(String who) {} // 打电话
15     public void sendMessage() {} // 群发短信
16  */
17 public class Phone {
18
19     // 成员变量
20     String brand; // 品牌
21     double price; // 价格
22     String color; // 颜色
23
24     // 成员方法
25     public void call(String who) {
26         System.out.println("给" + who + "打电话");
27     }
28
29     public void sendMessage() {
30         System.out.println("群发短信");
31     }
32 }

 1 package cn.itcast.day06.demo02;
 2
 3 public class Demo01PhoneOne {
 4
 5     public static void main(String[] args) {
 6         // 根据Phone类，创建一个名为one的对象
 7         // 格式：类名称 对象名 = new 类名称();
 8         Phone one = new Phone();
 9         System.out.println(one.brand); // null
10         System.out.println(one.price); // 0.0
11         System.out.println(one.color); // null
12         System.out.println("=========");
13
14         one.brand = "苹果";
15         one.price = 8388.0;
16         one.color = "黑色";
17         System.out.println(one.brand); // 苹果
18         System.out.println(one.price); // 8388.0
19         System.out.println(one.color); // 黑色
20         System.out.println("=========");
21
22         one.call("乔布斯"); // 给乔布斯打电话
23         one.sendMessage(); // 群发短信
24     }
25
26 }

一个对象的内存图

两个对象的内存图

 1 package cn.itcast.day06.demo02;
 2
 3 public class Demo02PhoneTwo {
 4
 5     public static void main(String[] args) {
 6         Phone one = new Phone();
 7         System.out.println(one.brand); // null
 8         System.out.println(one.price); // 0.0
 9         System.out.println(one.color); // null
10         System.out.println("=========");
11
12         one.brand = "苹果";
13         one.price = 8388.0;
14         one.color = "黑色";
15         System.out.println(one.brand); // 苹果
16         System.out.println(one.price); // 8388.0
17         System.out.println(one.color); // 黑色
18         System.out.println("=========");
19
20         one.call("乔布斯"); // 给乔布斯打电话
21         one.sendMessage(); // 群发短信
22         System.out.println("=========");
23
24         Phone two = new Phone();
25         System.out.println(two.brand); // null
26         System.out.println(two.price); // 0.0
27         System.out.println(two.color); // null
28         System.out.println("=========");
29
30         two.brand = "三星";
31         two.price = 5999.0;
32         two.color = "蓝色";
33         System.out.println(two.brand); // 三星
34         System.out.println(two.price); // 5999.0
35         System.out.println(two.color); // 蓝色
36         System.out.println("=========");
37
38         two.call("欧巴"); // 给欧巴打电话
39         two.sendMessage(); // 群发短信
40     }
41
42 }

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

 1 package cn.itcast.day06.demo02;
 2
 3 public class Demo03PhoneSame {
 4
 5     public static void main(String[] args) {
 6         Phone one = new Phone();
 7         System.out.println(one.brand); // null
 8         System.out.println(one.price); // 0.0
 9         System.out.println(one.color); // null
10         System.out.println("=========");
11
12         one.brand = "苹果";
13         one.price = 8388.0;
14         one.color = "黑色";
15         System.out.println(one.brand); // 苹果
16         System.out.println(one.price); // 8388.0
17         System.out.println(one.color); // 黑色
18         System.out.println("=========");
19
20         one.call("乔布斯"); // 给乔布斯打电话
21         one.sendMessage(); // 群发短信
22         System.out.println("=========");
23
24         // 将one当中保存的对象地址值赋值给two
25         Phone two = one;
26         System.out.println(two.brand); // 苹果
27         System.out.println(two.price); // 8388.0
28         System.out.println(two.color); // 黑色
29         System.out.println("=========");
30
31         two.brand = "三星";
32         two.price = 5999.0;
33         two.color = "蓝色";
34         System.out.println(two.brand); // 三星
35         System.out.println(two.price); // 5999.0
36         System.out.println(two.color); // 蓝色
37         System.out.println("=========");
38
39         two.call("欧巴"); // 给欧巴打电话
40         two.sendMessage(); // 群发短信
41     }
42
43 }

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

package cn.itcast.day06.demo02;

public class Demo04PhoneParam {

    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "土豪金";

        method(one); // 传递进去的参数其实就是地址值
    }

    public static void method(Phone param) {
        System.out.println(param.brand); // 苹果
        System.out.println(param.price); // 8388.0
        System.out.println(param.color); // 土豪金
    }

}

05-使用对象类型作为方法的返回值

 1 package cn.itcast.day06.demo02;
 2
 3 public class Demo05PhoneReturn {
 4
 5     public static void main(String[] args) {
 6         Phone two = getPhone();
 7         System.out.println(two.brand); // 苹果
 8         System.out.println(two.price); // 8388.0
 9         System.out.println(two.color); // 玫瑰金
10     }
11
12     public static Phone getPhone() {
13         Phone one = new Phone();
14         one.brand = "苹果";
15         one.price = 8388.0;
16         one.color = "玫瑰金";
17         return one;
18     }
19
20 }

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

 1 package cn.itcast.day06.demo03;
 2
 3 /*
 4 局部变量和成员变量
 5
 6 1. 定义的位置不一样【重点】
 7 局部变量：在方法的内部
 8 成员变量：在方法的外部，直接写在类当中
 9
10 2. 作用范围不一样【重点】
11 局部变量：只有方法当中才可以使用，出了方法就不能再用
12 成员变量：整个类全都可以通用。
13
14 3. 默认值不一样【重点】
15 局部变量：没有默认值，如果要想使用，必须手动进行赋值
16 成员变量：如果没有赋值，会有默认值，规则和数组一样
17
18 4. 内存的位置不一样（了解）
19 局部变量：位于栈内存
20 成员变量：位于堆内存
21
22 5. 生命周期不一样（了解）
23 局部变量：随着方法进栈而诞生，随着方法出栈而消失
24 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
25  */
26 public class Demo01VariableDifference {
27
28     String name; // 成员变量
29
30     public void methodA() {
31         int num = 20; // 局部变量
32         System.out.println(num);
33         System.out.println(name);
34     }
35
36     public void methodB(int param) { // 方法的参数就是局部变量
37         // 参数在方法调用的时候，必然会被赋值的。
38         System.out.println(param);
39
40         int age; // 局部变量
41 //        System.out.println(age); // 没赋值不能用
42
43 //        System.out.println(num); // 错误写法！
44         System.out.println(name);
45     }
46
47 }

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

 1 package cn.itcast.day06.demo03;
 2
 3 /*
 4 面向对象三大特征：封装、继承、多态。
 5
 6 封装性在Java当中的体现：
 7 1. 方法就是一种封装
 8 2. 关键字private也是一种封装
 9
10 封装就是将一些细节信息隐藏起来，对于外界不可见。
11  */
12 public class Demo02Method {
13
14     public static void main(String[] args) {
15         int[] array = {5, 15, 25, 20, 100};
16
17         int max = getMax(array);
18         System.out.println("最大值：" + max);
19     }
20
21     // 给我一个数组，我还给你一个最大值
22     public static int getMax(int[] array) {
23         int max = array[0];
24         for (int i = 1; i < array.length; i++) {
25             if (array[i] > max) {
26                 max = array[i];
27             }
28         }
29         return max;
30     }
31
32 }

private关键字的作用及使用

 1 package cn.itcast.day06.demo03;
 2
 3 /*
 4 问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
 5 解决方案：用private关键字将需要保护的成员变量进行修饰。
 6
 7 一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
 8 但是！超出了本类范围之外就不能再直接访问了。
 9
10 间接访问private成员变量，就是定义一对儿Getter/Setter方法
11
12 必须叫setXxx或者是getXxx命名规则。
13 对于Getter来说，不能有参数，返回值类型和成员变量对应；
14 对于Setter来说，不能有返回值，参数类型和成员变量对应。
15  */
16 public class Person {
17
18     String name; // 姓名
19     private int age; // 年龄
20
21     public void show() {
22         System.out.println("我叫：" + name + "，年龄：" + age);
23     }
24
25     // 这个成员方法，专门用于向age设置数据
26     public void setAge(int num) {
27         if (num < 100 && num >= 9) { // 如果是合理情况
28             age = num;
29         } else {
30             System.out.println("数据不合理！");
31         }
32     }
33
34     // 这个成员方法，专门私语获取age的数据
35     public int getAge() {
36         return age;
37     }
38
39 }

 1 package cn.itcast.day06.demo03;
 2
 3 public class Demo03Person {
 4
 5     public static void main(String[] args) {
 6         Person person = new Person();
 7         person.show();
 8
 9         person.name = "赵丽颖";
10 //        person.age = -20; // 直接访问private内容，错误写法！
11         person.setAge(20);
12         person.show();
13     }
14
15 }

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

 1 package cn.itcast.day06.demo03;
 2
 3 /*
 4 对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
 5  */
 6 public class Student {
 7
 8     private String name; // 姓名
 9     private int age; // 年龄
10     private boolean male; // 是不是爷们儿
11
12     public void setMale(boolean b) {
13         male = b;
14     }
15
16     public boolean isMale() {
17         return male;
18     }
19
20     public void setName(String str) {
21         name = str;
22     }
23
24     public String getName() {
25         return name;
26     }
27
28     public void setAge(int num) {
29         age = num;
30     }
31
32     public int getAge() {
33         return age;
34     }
35 }

 1 package cn.itcast.day06.demo03;
 2
 3 public class Demo04Student {
 4
 5     public static void main(String[] args) {
 6         Student stu = new Student();
 7
 8         stu.setName("鹿晗");
 9         stu.setAge(20);
10         stu.setMale(true);
11
12         System.out.println("姓名：" + stu.getName());
13         System.out.println("年龄：" + stu.getAge());
14         System.out.println("是不是爷们儿：" + stu.isMale());
15     }
16
17 }

this关键字的作用

 1 package cn.itcast.day06.demo04;
 2
 3 /*
 4 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
 5 如果需要访问本类当中的成员变量，需要使用格式：
 6 this.成员变量名
 7
 8 “通过谁调用的方法，谁就是this。”
 9  */
10 public class Person {
11
12     String name; // 我自己的名字
13
14     // 参数name是对方的名字
15     // 成员变量name是自己的名字
16     public void sayHello(String name) {
17         System.out.println(name + "，你好。我是" + this.name);
18         System.out.println(this);
19     }
20
21 }

 1 package cn.itcast.day06.demo04;
 2
 3 public class Demo01Person {
 4
 5     public static void main(String[] args) {
 6         Person person = new Person();
 7         // 设置我自己的名字
 8         person.name = "王健林";
 9         person.sayHello("王思聪");
10
11         System.out.println(person); // 地址值
12     }
13
14 }

构造方法

 1 package cn.itcast.day06.demo04;
 2
 3 /*
 4 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
 5 格式：
 6 public 类名称(参数类型 参数名称) {
 7     方法体
 8 }
 9
10 注意事项：
11 1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
12 2. 构造方法不要写返回值类型，连void都不写
13 3. 构造方法不能return一个具体的返回值
14 4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
15 public Student() {}
16 5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
17 6. 构造方法也是可以进行重载的。
18 重载：方法名称相同，参数列表不同。
19  */
20 public class Student {
21
22     // 成员变量
23     private String name;
24     private int age;
25
26     // 无参数的构造方法
27     public Student() {
28         System.out.println("无参构造方法执行啦！");
29     }
30
31     // 全参数的构造方法
32     public Student(String name, int age) {
33         System.out.println("全参构造方法执行啦！");
34         this.name = name;
35         this.age = age;
36     }
37
38     // Getter Setter
39     public void setName(String name) {
40         this.name = name;
41     }
42
43     public String getName() {
44         return name;
45     }
46
47     public void setAge(int age) {
48         this.age = age;
49     }
50
51     public int getAge() {
52         return age;
53     }
54
55 }

 1 package cn.itcast.day06.demo04;
 2
 3 public class Demo02Student {
 4
 5     public static void main(String[] args) {
 6         Student stu1 = new Student(); // 无参构造
 7         System.out.println("============");
 8
 9         Student stu2 = new Student("赵丽颖", 20); // 全参构造
10         System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
11         // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
12         stu2.setAge(21); // 改变年龄
13         System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
14
15     }
16
17 }

定义一个标准的类

 1 package cn.itcast.day06.demo05;
 2
 3 /*
 4 一个标准的类通常要拥有下面四个组成部分：
 5
 6 1. 所有的成员变量都要使用private关键字修饰
 7 2. 为每一个成员变量编写一对儿Getter/Setter方法
 8 3. 编写一个无参数的构造方法
 9 4. 编写一个全参数的构造方法
10
11 这样标准的类也叫做Java Bean
12  */
13 public class Student {
14
15     private String name; // 姓名
16     private int age; // 年龄
17
18     public Student() {
19     }
20
21     public Student(String name, int age) {
22         this.name = name;
23         this.age = age;
24     }
25
26     public String getName() {
27         return name;
28     }
29
30     public void setName(String name) {
31         this.name = name;
32     }
33
34     public int getAge() {
35         return age;
36     }
37
38     public void setAge(int age) {
39         this.age = age;
40     }
41 }

 1 package cn.itcast.day06.demo05;
 2
 3 public class Demo01Student {
 4
 5     public static void main(String[] args) {
 6         Student stu1 = new Student();
 7         stu1.setName("迪丽热巴");
 8         stu1.setAge(20);
 9         System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
10         System.out.println("=================");
11
12         Student stu2 = new Student("古力娜扎", 21);
13         System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
14         stu2.setAge(22);
15         System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
16     }
17
18 }