第二章 面向对象基础
2-1 类和对象
1 面相过程和面向对象
【1】面向过程和面向对象
【2】理解
- 需求：吃一盘菜（普罗旺斯茄块烩马铃薯，使用青椒做辅料）
【3】对象
【4】面向对象思想小结
- 面向对象思想小结：
1. 客观存在的任何一种事物，都可以看做为程序中的对象
2. 使用面向对象思想可以将复杂的问题简单化
3. 将我们从执行者的位置，变成了指挥者
【5】案例（仅供理解使用）
（1）面向过程
package com.itheima.contrast;
public class Demo1Pop {
/*
需求: 遍历打印数组, 要求结果为[11, 22, 33, 44, 55]
面向过程思想: 自己一步步的实现需求
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
// 1. 打印左括号
System.out.print("[");
// 2. 遍历数组获取每一个元素
for (int i = 0; i < arr.length; i++) {
// 3. 判断是否是最后一个元素
if(i == arr.length - 1){
// 4. 是最后一个元素特殊处理, 换行打印,拼接右括号
System.out.println(arr[i] + "]");
}else{
// 5. 不是最后一个元素, 不换行, 拼接逗号空格
System.out.print(arr[i] + ", ");
}
}
}
}
（2）面向对象
- 数组服务员
package com.itheima.contrast;
public class 数组服务员 {
public int 获取最大值(int[] arr){
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
}
return max;
}
public int 获取最小值(int[] arr){
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
public void 遍历打印数组(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1){
System.out.println(arr[i] + "]");
}else{
System.out.print(arr[i] + ", ");
}
}
}
}
- 测试类
package com.itheima.contrast;
public class Demo1Oop {
/*
需求: 遍历打印数组, 要求结果为[11, 22, 33, 44, 55]
面向对象思想: 指挥 [对象] 来实现需求
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
// 1. 创建数组服务员对象
数组服务员 二狗 = new 数组服务员();
// 2. 指挥二狗对象, 调用内部的printArray方法遍历打印数组
二狗.遍历打印数组(arr);
}
}
2 类和对象的关系
【1】什么是类？
【2】类的组成
【3】类和对象的关系
3 类的定义
【1】类的组成
【2】类的定义
【3】案例
package com.itheima.object1;
public class Student {
// 属性 : 姓名, 年龄
// 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
String name;
int age;
// 行为 : 学习
// 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
public void study(){
System.out.println("学习");
}
}
4 对象的创建和使用
【1】对象的创建和使用
【2】案例
package com.itheima.object1;
public class TestStudent {
/*
创建对象的格式:
类名 对象名 = new 类名();
调用成员变量的格式:
对象名.变量名
调用成员方法的格式:
对象名.方法名();
*/
public static void main(String[] args) {
// 类名 对象名 = new 类名();
Student stu = new Student();
// 对象名.变量名
// 默认初始化值
System.out.println(stu.name); // null
System.out.println(stu.age); // 0
stu.name = "张三";
stu.age = 23;
System.out.println(stu.name); // 张三
System.out.println(stu.age); // 23
// 对象名.方法名();
stu.study();
// com.itheima.object1.Student@b4c966a
// 全类名(包名 + 类名)
System.out.println(stu);
}
}
5 案例-手机类的创建和使用
【1】需求
需求：定义一个手机类，然后定义一个手机测试类，在手机测试类中通过对象完成成员变量和成员方法的使用
【2】分析
【3】实现
- 手机类
package com.itheima.test1;
public class Phone {
// 品牌, 价格
String brand;
int price;
// 打电话, 发短信
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
}
- 手机测试类
package com.itheima.test1;
public class TestPhone {
public static void main(String[] args) {
// 1. 创建对象
Phone p = new Phone();
// 2. 给成员变量进行赋值
p.brand = "大米";
p.price = 2999;
// 3. 打印赋值后的成员变量
System.out.println(p.brand + "..." + p.price);
// 4. 调用成员方法
p.call("阿强");
p.sendMessage();
}
}
2-2 对象内存图
1 单个对象内存图
【1】内存图
2 两个对象内存图
【1】内存图
3 两个引用指向同一个对象内存图
【1】内存图
【2】垃圾回收
4 成员变量和局部变量的区别
2-3 封装
1 private关键字
【1】private关键字
【2】小结
【3】案例
- 学生类
package com.itheima.object2;
public class Student {
/*
学生类
private : 私有的
private是一个权限修饰符
可以用来修饰成员(变量,方法)
特点: 只能在本类当中进行访问
*/
String name;
private int age;
// 设置值
public void setAge(int a){
if(a >= 0 && a <= 120){
age = a;
}else{
System.out.println("您的年龄不合理");
}
}
// 获取值
public int getAge(){
return age;
}
public void show(){
System.out.println(name + "..." + age);
}
}
- 学生测试类
package com.itheima.object2;
public class TestStudent {
/*
学生测试类
*/
public static void main(String[] args) {
Student stu = new Student();
stu.name = "张三";
//stu.age = 23;
stu.setAge(-23);
stu.show();
}
}
2 private 关键字的使用
【1】private关键字的使用
一个标准类的编写：
- 把成员变量用private修饰
- 提供对应的setXxx()/getXxx()方法
【2】案例
- 学生类
package com.itheima.test2;
public class Student {
private String name;
private int age;
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void show(){
System.out.println(name + "..." + age);
}
}
- 学生测试类
package com.itheima.test2;
public class TestStudent {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("张三");
stu.setAge(23);
System.out.println(stu.getName());
System.out.println(stu.getAge());
int age = stu.getAge();
for(int i = 1; i <= age; i++){
System.out.println("生日快乐");
}
stu.show(); // 仅仅是对数据做展示
}
}
3 this 关键字
【1】this关键字的作用
【2】this关键字的概念
【3】案例
- 学生类
package com.itheima.mythis;
public class Student {
private String name;
public void setName(String name){
System.out.println("[方法中打印this]");
System.out.println(this);
this.name = name;
}
}
- 学生测试类
package com.itheima.mythis;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println("[打印对象名]--> s1");
System.out.println(s1);
s1.setName("张三");
System.out.println("----------------------");
Student s2 = new Student();
System.out.println("[打印对象名]--> s2");
System.out.println(s2);
s2.setName("李四");
}
}
4 this关键字内存原理
【1】内存图
5 封装
【1】封装
【2】封装总结
2-4 构造方法
1 构造方法的格式和执行时机
【1】构造方法概述
- 执行时机：
- 创建对象的时候调用，每创建一次对象，就会调用一次构造方法
- 不能手动调用构造方法
【2】案例
- 学生类
package com.itheima.constructor;
public class Student {
/*
格式:
1. 方法名需要跟类名相同, 大小写也要一致
2. 没有返回值类型, 连void都没有
3. 没有具体的返回值(不能由return带回具体的结果)
*/
public Student(){
System.out.println("我是Student类的构造方法");
}
}
- 学生测试类
package com.itheima.constructor;
public class TestStudent {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
Student stu3 = new Student();
}
}
2 构造方法的作用
【1】作用
【2】案例
- 学生类
package com.itheima.constructor;
public class Student {
/*
格式:
1. 方法名需要跟类名相同, 大小写也要一致
2. 没有返回值类型, 连void都没有
3. 没有具体的返回值(不能由return带回具体的结果)
*/
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = age;
System.out.println("我是Student类的构造方法");
}
public void show(){
System.out.println(name + "..." + age);
}
}
- 学生测试类
package com.itheima.constructor;
public class TestStudent {
public static void main(String[] args) {
Student stu1 = new Student("张三",23);
stu1.show();
}
}
3 构造方法的注意事项
【1】注意事项
【2】案例
- 学生类
package com.itheima.constructor;
public class Student {
/*
格式:
1. 方法名需要跟类名相同, 大小写也要一致
2. 没有返回值类型, 连void都没有
3. 没有具体的返回值(不能由return带回具体的结果)
*/
private String name;
private int age;
// 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
public Student(){}
// 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
public Student(String name, int age){
this.name = name;
this.age = age;
System.out.println("我是Student类的构造方法");
}
public void show(){
System.out.println(name + "..." + age);
}
}
- 学生测试类
package com.itheima.constructor;
public class TestStudent {
public static void main(String[] args) {
Student stu1 = new Student("张三",23);
stu1.show();
Student stu2 = new Student();
}
}
4 标准代码编写和使用案例
【1】需求
【2】实现
- 学生类
package com.itheima.test3;
/*
JavaBean类: 封装数据
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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 void show(){
System.out.println(name + "..." + age);
}
}
- 学生测试类
package com.itheima.test3;
public class TestStudent {
public static void main(String[] args) {
// 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName("张三");
stu1.setAge(23);
stu1.show();
// 2. 通过带参数构造方法, 直接给属性进行赋值
Student stu2 = new Student("李四",24);
stu2.show();
}
}
