第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 }