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