01 面向对象基础

大纲：

• 设计对象并使用
• 封装
• this关键字
• 构造方法
• 标准JavaBean
• 对象内存图
• 补充知识：成员变量、局部变量的区别

1、设计对象并使用

1.1 类和对象

示例代码：

• 定义一个类：Phone

  public class Phone {
      String name;
      double price;
  
      public static void call(){
          System.out.println("手机在打电话");
      }
  
      public static void playGame(){
          System.out.println("手机在玩游戏");
      }
  }
  

• 创建对象

  public class PhoneTest {
      public static void main(String[] args) {
          Phone p = new Phone();
  
          // 给手机赋值
          p.price = 1999.99;
          // 获取对象中的值
          System.out.println(p.price);  // 1999.99
          // 调用手机中的方法
          p.call();  // 手机在打电话
          p.playGame();  // 手机在玩游戏
      }
  }
  

小结：

1.2 类的几个补充注意事项

定义类的补充注意事项：

小结：

2、封装

面向对象三大特征：封装、继承、多态

2.1 封装的概念

2.2 private关键字

private关键字:

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 被private修饰的成员只能再本类中才能访问

示例使用场景：加入我定义了一个女朋友类，我不希望女朋友的名字和年龄被错误的赋值，此时就可以基于private实现该功能，示例代码如下

public class GirlFriend {
    String gender;
    private String name;
    private int age;
}

此时访问name就会报错

GirlFriend g1 = new GirlFriend();
g1.name = "小红";
// java: name 在 ***.GirlFriend 中是 private 访问控制

如果想修改private修饰的成员：

• 基于方法：在GirlFriend中提供get（）和set（）方法，分别用于获取和赋值

示例代码：

public class GirlFriend {
    private int age;

    public void setAge(int a){
        if(a >= 18 && a <= 20){
            age = a;
        }
        else {
            System.out.println("非法数据");
        }
    }

    public int getAge(){
        return age;
    }
}

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend g1 = new GirlFriend();

        g1.setAge(18);
        int age = g1.getAge();
        System.out.println(age);  // 18

        g1.setAge(-18);  // 非法数据
    }
}

补充：关于static

• 用static 修饰的方法可以直接被调用, 不用static修饰的需要先实例化一个对象后才可以被调用
  • 比如 person这个类里面有一个方法public static add(){}
  • 那么可以直接用person类调用 person.add();
  • 当然也可以用下面的方法先出一个对象在调用也是可以
  • 如果这个方法前面没有static 比如 public add(){}，那么先要person p=new person()，然后用p.add()，类加载器在加载这个类的时候就已经实例化了这个类
• 注意，初始化加载，比较占内存

3、this关键字

3.1 就近原则

谁离的近先用谁

private int age;  // 0

public void tempMethod(){
    int age = 80;  // 局部变量
    System.out.println(age);
}

GirlFriend g1 = new GirlFriend();
g1.tempMethod(); // 80

那么如果我想使tempMethod()打印的结果为private int age;中的age，怎么办呢?

使用this关键字。

3.2 this

作用：可以区别成员变量和局部变量

示例代码：

private int age;  // 0

public void tempMethod(){
    int age = 80;
    System.out.println(this.age);
}

GirlFriend g1 = new GirlFriend();
g1.tempMethod(); // 0

此时，我们就可以基于this关键字优化之前的代码：

public class GirlFriend {
    private int age;  // 0

    public void setAge(int age){
        if(age >= 18 && age <= 20){
            this.age = age;
        }
        else {
            System.out.println("非法数据");
        }
    }

    public int getAge(){
        return this.age;
    }
}

4、构造方法

4.1 构造方法的概述

根据使用场景，构造方法分为：

• 空参构造方法

• 有参构造方法

示例代码：

package day4.code;

public class Student {
    private String name;
    private int age;

    public Student(){
        System.out.println("无参构造函数");
    }

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return this.age;
    }
}

基于无参构造：

// 无参构造函数
Student stu = new Student();  // 无参构造函数
stu.setName("张三");
stu.setAge(18);
System.out.println(stu.getName() + stu.getAge());  // 张三18

基于有参构造：

Student stu = new Student("李四", 20);
System.out.println(stu.getName() + stu.getAge());  // 李四20

4.2 构造方法的注意事项

4.3 小结

5、标准JavaBean

JavaBean是一个遵循特定写法的Java类

假如我们要实现这样一个功能：

示例代码：

备注：

构造方法、get、set写起来太繁琐（使用IDEA时）？

• 快捷键Alt + Insert 或者 Alt + Fn + Insert
  
• 或者下载一个插件PGT

public class User {
    private String name;
    private String password;
    private String gender;
    private String mail;
    private int age;

    public User(String name, String password, String gender, String mail, int age) {
        this.name = name;
        this.password = password;
        this.gender = gender;
        this.mail = mail;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getMail() {
        return mail;
    }

    public void setMail(String mail) {
        this.mail = mail;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

6、对象内存图

视频链接：面向对象-07-三种情况的对象内存图

大纲：

• 一个对象的内存图
• 多个对象的内存图
• 两个变量指向同一个对象内存图
• this的内存原理
• 基本数据类型和引用数据类型的区别
• 局部变量和成员变量的区别

先回顾一下JVM的内存分配：

6.1 一个对象的内存图

6.2 多个对象的内存图

6.3 两个变量指向同一个对象内存图

6.4 this的内存原理

this的作用：区分局部变量和成员变量。

那么是通过什么方式区分的呢？

this的本质：所在方法调用者的地址值

那么关于set、get方法的内存原理呢？

6.5 基本数据类型和引用数据类型的区别

首先区别基本数据类型与引用数据类型：

• 基本数据类型：整数类型、浮点数类型、布尔类型、字符类型
  • 变量中存储真实的数据
• 引用数据类型：除了上述类型的其他所有类型
  • 变量中存储的是地址值
  • 引用：使用了其他空间中的数据

基本数据类型：

引用数据类型：

小结：

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

成员变量：类中方法外的变量。

局部变量：方法中的变量。

了解即可：

7、面向对象综合训练

• 文字版格斗游戏
• 对象数组练习
• 购物车

7.1 文字版格斗游戏

7.1.1 基础版

示例代码：

import java.util.Random;

public class Role {
    private String name;
    private int blood;

    public Role(String name, int blood) {
        this.name = name;
        this.blood = blood;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public void attack(Role role) {
        Random r = new Random();
        // 设每次攻击伤害在1~20之间
        int hurt = r.nextInt(20) + 1;
        // 计算剩余血量，若为负数，则变为0
        int residualBlood = role.getBlood() - hurt;
        residualBlood = residualBlood < 0 ? 0 : residualBlood;
        role.setBlood(residualBlood);
        System.out.println(this.getName() + "打了" + role.getName() + "一下，造成了" + hurt + "伤害，对方剩余"
                + residualBlood + "血量");
    }
}

public class RoleTest {
    public static void main(String[] args) {
        Role r1 = new Role("奥特曼", 100);
        Role r2 = new Role("小怪兽", 100);
        while (true){
            r1.attack(r2);
            if(r2.getBlood() == 0){
                System.out.println(r1.getName() + "击败了" + r2.getName());
                break;
            }

            r2.attack(r1);
            if(r1.getBlood() == 0){
                System.out.println(r2.getName() + "击败了" + r1.getName());
                break;
            }
        }
    }
}

结果展示：

奥特曼打了小怪兽一下，造成了10伤害，对方剩余90血量
小怪兽打了奥特曼一下，造成了8伤害，对方剩余92血量
奥特曼打了小怪兽一下，造成了15伤害，对方剩余75血量
小怪兽打了奥特曼一下，造成了5伤害，对方剩余87血量
奥特曼打了小怪兽一下，造成了19伤害，对方剩余56血量
小怪兽打了奥特曼一下，造成了14伤害，对方剩余73血量
奥特曼打了小怪兽一下，造成了7伤害，对方剩余49血量
小怪兽打了奥特曼一下，造成了8伤害，对方剩余65血量
奥特曼打了小怪兽一下，造成了9伤害，对方剩余40血量
小怪兽打了奥特曼一下，造成了8伤害，对方剩余57血量
奥特曼打了小怪兽一下，造成了18伤害，对方剩余22血量
小怪兽打了奥特曼一下，造成了2伤害，对方剩余55血量
奥特曼打了小怪兽一下，造成了8伤害，对方剩余14血量
小怪兽打了奥特曼一下，造成了1伤害，对方剩余54血量
奥特曼打了小怪兽一下，造成了20伤害，对方剩余0血量
奥特曼击败了小怪兽

备注：你可能觉得最终结果为什么总是奥特曼赢，这结果不随机啊？因为奥特曼先出手的。

7.1.2 升级版

升级版代码量很多，但本质上就是把长相、打斗的攻击方式的各种修饰语句存入列表，然后打斗时基于Random随机抽取出来。

​ 在上一个的基础上，我想看到人物的性别和长相，打斗的时候我想看到武功招式。

举例：

​ 程序运行之后结果为：

​ 姓名为:乔峰 血量为:100 性别为:男 长相为:气宇轩昂

​ 姓名为:鸠摩智 血量为:100 性别为:男 长相为:气宇轩昂

​ 乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。给鸠摩智造成一处瘀伤。

​ 鸠摩智使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向乔峰。结果乔峰退了半步，毫发无损。

​ 。。。。

​ 乔峰K.O.了鸠摩智

分析：

​ 长相是提前定义好的，提前放在一个数组当中，程序运行之后，从数组中随机获取。

//男生长相数组
String[] boyfaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
//女生长相数组
String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};

​ 武功招式也是提前定义好的，提前放在一个数组当中，程序运行之后，从数组随机获取

//attack 攻击描述：
String[] attacks_desc = {
    "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
    "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
    "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
    "%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
    "%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
    "%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"

​ 受伤的提前也是提前定义好的，只不过不是随机了，根据剩余血量获取不同的描述

//injured 受伤描述：
String[] injureds_desc = {
    "结果%s退了半步，毫发无损",
    "结果给%s造成一处瘀伤",
    "结果一击命中，%s痛得弯下腰",
    "结果%s痛苦地闷哼了一声，显然受了点内伤",
    "结果%s摇摇晃晃，一跤摔倒在地",
    "结果%s脸色一下变得惨白，连退了好几步",
    "结果『轰』的一声，%s口中鲜血狂喷而出",
    "结果%s一声惨叫，像滩软泥般塌了下去"

​ 其中输出语句跟以前不一样了，用的是System.out.printf（）；该输出语句支持%s占位符

public class Test {
    public static void main(String[] args) {
        //两部分参数：
        //第一部分参数：要输出的内容%s（占位）
        //第二部分参数：填充的数据
        
        System.out.printf("你好啊%s","张三");//用张三填充第一个%s
        System.out.println();//换行
        System.out.printf("%s你好啊%s","张三","李四");//用张三填充第一个%s，李四填充第二个%s
    }
}

最终代码示例：

import java.util.Random;

public class RoleUpgrade {
    private String name;
    private int blood;
    private char gender;
    private String face;//长相是随机的

    String[] boyfaces = {"风流俊雅", "气宇轩昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目狰狞"};
    String[] girlfaces = {"美奂绝伦", "沉鱼落雁", "婷婷玉立", "身材娇好", "相貌平平", "相貌简陋", "惨不忍睹"};

    //attack 攻击描述：
    String[] attacks_desc = {
            "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
            "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
            "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
            "%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
            "%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
            "%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
    };

    //injured 受伤描述：
    String[] injureds_desc = {
            "结果%s退了半步，毫发无损",
            "结果给%s造成一处瘀伤",
            "结果一击命中，%s痛得弯下腰",
            "结果%s痛苦地闷哼了一声，显然受了点内伤",
            "结果%s摇摇晃晃，一跤摔倒在地",
            "结果%s脸色一下变得惨白，连退了好几步",
            "结果『轰』的一声，%s口中鲜血狂喷而出",
            "结果%s一声惨叫，像滩软泥般塌了下去"
    };

    public RoleUpgrade() {
    }

    public RoleUpgrade(String name, int blood, char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        //随机长相
        setFace(gender);
    }


    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getFace() {
        return face;
    }

    public void setFace(char gender) {
        Random r = new Random();
        //长相是随机的
        if (gender == '男') {
            //从boyfaces里面随机长相
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];
        } else if (gender == '女') {
            //从girlfaces里面随机长相
            int index = r.nextInt(girlfaces.length);
            this.face = girlfaces[index];
        } else {
            this.face = "面目狰狞";
        }


    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }


    //定义一个方法用于攻击别人
    //思考：谁攻击谁？
    //Role r1 = new Role（）；
    //Role r2 = new Role（）；
    //r1.攻击(r2);
    //方法的调用者去攻击参数
    public void attack(RoleUpgrade role) {
        Random r = new Random();
        int index = r.nextInt(attacks_desc.length);
        String KungFu = attacks_desc[index];

        //输出一个攻击的效果
        System.out.printf(KungFu, this.getName(), role.getName());
        System.out.println();

        //计算造成的伤害 1 ~ 20
        int hurt = r.nextInt(20) + 1;

        //剩余血量
        int remainBoold = role.getBlood() - hurt;
        //对剩余血量做一个验证，如果为负数了，就修改为0
        remainBoold = remainBoold < 0 ? 0 : remainBoold;
        //修改一下挨揍的人的血量
        role.setBlood(remainBoold);

        //受伤的描述
        //血量> 90 0索引的描述
        //80 ~  90  1索引的描述
        //70 ~  80  2索引的描述
        //60 ~  70  3索引的描述
        //40 ~  60  4索引的描述
        //20 ~  40  5索引的描述
        //10 ~  20  6索引的描述
        //小于10的   7索引的描述
        if (remainBoold > 90) {
            System.out.printf(injureds_desc[0], role.getName());
        } else if (remainBoold > 80 && remainBoold <= 90) {
            System.out.printf(injureds_desc[1], role.getName());
        } else if (remainBoold > 70 && remainBoold <= 80) {
            System.out.printf(injureds_desc[2], role.getName());
        } else if (remainBoold > 60 && remainBoold <= 70) {
            System.out.printf(injureds_desc[3], role.getName());
        } else if (remainBoold > 40 && remainBoold <= 60) {
            System.out.printf(injureds_desc[4], role.getName());
        } else if (remainBoold > 20 && remainBoold <= 40) {
            System.out.printf(injureds_desc[5], role.getName());
        } else if (remainBoold > 10 && remainBoold <= 20) {
            System.out.printf(injureds_desc[6], role.getName());
        } else {
            System.out.printf(injureds_desc[7], role.getName());
        }
        System.out.println();


    }


    public void showRoleInfo() {
        System.out.println("姓名为：" + getName());
        System.out.println("血量为：" + getBlood());
        System.out.println("性别为：" + getGender());
        System.out.println("长相为：" + getFace());
    }

}

public class RoleUpgradeTest {
    public static void main(String[] args) {
        //1.创建第一个角色
        RoleUpgrade r1 = new RoleUpgrade("乔峰", 100, '男');
        //2.创建第二个角色
        RoleUpgrade r2 = new RoleUpgrade("鸠摩智", 100, '男');

        //展示一下角色的信息
        r1.showRoleInfo();
        r2.showRoleInfo();

        //3.开始格斗 回合制游戏
        while (true) {
            //r1开始攻击r2
            r1.attack(r2);
            //判断r2的剩余血量
            if (r2.getBlood() == 0) {
                System.out.println(r1.getName() + " K.O了" + r2.getName());
                break;
            }

            //r2开始攻击r1
            r2.attack(r1);
            if (r1.getBlood() == 0) {
                System.out.println(r2.getName() + " K.O了" + r1.getName());
                break;
            }
        }
    }
}

示例结果：

姓名为：乔峰
血量为：100
性别为：男
长相为：五官端正
姓名为：鸠摩智
血量为：100
性别为：男
长相为：相貌英俊
乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。
结果给鸠摩智造成一处瘀伤
鸠摩智运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向乔峰。
结果乔峰退了半步，毫发无损
乔峰使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向鸠摩智。
结果鸠摩智痛苦地闷哼了一声，显然受了点内伤
鸠摩智阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向乔峰。
结果给乔峰造成一处瘀伤
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。
结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向乔峰。
结果乔峰痛苦地闷哼了一声，显然受了点内伤
乔峰阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向鸠摩智。
结果鸠摩智摇摇晃晃，一跤摔倒在地
鸠摩智上步抢身，招中套招，一招【劈挂连环】，连环攻向乔峰。
结果乔峰摇摇晃晃，一跤摔倒在地
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。
结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智使出了一招【背心钉】，转到对方的身后，一掌向乔峰背心的灵台穴拍去。
结果乔峰脸色一下变得惨白，连退了好几步
乔峰阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向鸠摩智。
结果鸠摩智脸色一下变得惨白，连退了好几步
鸠摩智大喝一声，身形下伏，一招【劈雷坠地】，捶向乔峰双腿。
结果『轰』的一声，乔峰口中鲜血狂喷而出
乔峰阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向鸠摩智。
结果『轰』的一声，鸠摩智口中鲜血狂喷而出
鸠摩智使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向乔峰。
结果乔峰一声惨叫，像滩软泥般塌了下去
乔峰大喝一声，身形下伏，一招【劈雷坠地】，捶向鸠摩智双腿。
结果鸠摩智一声惨叫，像滩软泥般塌了下去
鸠摩智使出了一招【背心钉】，转到对方的身后，一掌向乔峰背心的灵台穴拍去。
结果乔峰一声惨叫，像滩软泥般塌了下去
鸠摩智 K.O了乔峰

7.2 对象数组练习

题意：定义数组存储三个商品对象

• 商品属性：商品的id、名字、价格、库存；
• 创建三个商品对象，并把商品对象存入到数组当中。

略

02 面向对象进阶

大纲：

• static
• 继承
• 包、final、权限修饰符、代码块
• 抽象类
• 接口
• 多态
• 内部类
• 拼图小游戏

1、static

1.1 静态变量概述

先看一段代码：

package day7.code.StaticDemo01;

public class Student {
    private String name;
    private int age;
    private String teacherName;

    public Student() {
    }

    public Student(String name, int age, String teacherName) {
        this.name = name;
        this.age = age;
        this.teacherName = teacherName;
    }

    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 String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    public void study() {
        System.out.println(this.name + "正在学习");
    }

    public void show() {
        System.out.println(this.name + "," + this.age + "," + this.teacherName);
    }
}

package day7.code.StaticDemo01;

public class StudentTest {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(18);
        stu1.setTeacherName("Tom");
        stu1.study();
        stu1.show();

        Student stu2 = new Student();
        stu2.setName("李四");
        stu2.setAge(20);
        stu2.study();
        stu2.show();
    }
}

结果展示：

张三正在学习
张三,18,Tom
李四正在学习
李四,20,null

可以看到，我没给“李四”的“老师”赋值。所以打印了null。

但都是一个班的同学，每创建一个同学就给老师命名一次太麻烦了，有没有简单的方式呢？

需改Student类，加入static，注意此时为public，非私有属性：

private String name;
private int age;
public static String teacherName;

重新运行StudentTest类：

张三正在学习
张三,18,Tom
李四正在学习
李四,20,Tom

并且，此时可以在StudentTest类中统一命名“老师”这一属性：Student.teacherName = "Tom";

完整代码展示如下：

package day7.code.StaticDemo01;

public class Student {
    private String name;
    private int age;
    public static String teacherName;

    public Student() {
    }

    public Student(String name, int age, String teacherName) {
        this.name = name;
        this.age = age;
        this.teacherName = teacherName;
    }

    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 String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    public void study() {
        System.out.println(this.name + "正在学习");
    }

    public void show() {
        System.out.println(this.name + "," + this.age + "," + this.teacherName);
    }
}

package day7.code.StaticDemo01;

public class StudentTest {
    public static void main(String[] args) {

        Student.teacherName = "Tom";

        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(18);
        stu1.study();
        stu1.show();

        Student stu2 = new Student();
        stu2.setName("李四");
        stu2.setAge(20);
        stu2.study();
        stu2.show();
    }
}

结果展示：

张三正在学习
张三,18,Tom
李四正在学习
李四,20,Tom

1.2 static内存图

执行第一步tudent.teacherName = "***";时：

所以，简单来说什么时候用static：需要”共享“时。

1.3 静态方法

补充：

• 什么是工具类？
  • 
• 工具类的创建要求

  • 

  • 注意”私有化构造方法“：工具类提供了各种工具帮助我们解决问题，不需要我们实例化

练习：创建要求的工具类

示例代码：

package day7.code.StaticDemo02;

public class ArrayUtil {
    private ArrayUtil() {
    }

    public static String printArr(int[] arr) {
        String result = "[";
        for(int i = 0; i < arr.length; i++) {
            if(i == arr.length -1){
                result = result + arr[i] + "]";
                break;
            }
            result = result + arr[i] + ",";
        }
        return result;
    }

    public static double getAerage(int[] arr){
        double result = 0;
        for(int i = 0; i < arr.length; i++) {
            result += arr[i];
        }
        result /= arr.length;
        return result;
    }
}

package day7.code.StaticDemo02;

public class TestDemo {
    public static void main(String[] args) {
        int arr[] = {10, 20, 30};

        String pr = ArrayUtil.printArr(arr);
        System.out.println(pr);  // [10,20,30]

        double aerage = ArrayUtil.getAerage(arr);
        System.out.println(aerage);  // 20.0
    }
}

1.4 static的注意事项

1.4.1 从代码方面理解

一、静态方法中没有this关键字

我们平时写public void show(Student this)，并没有写static，它不是静态方法。

但它并不是没有this关键字，this隐藏了。

示例代码：

package day7.code.StaticDemo03;

public class Student {
    String name;
    int age;
    static String teacherName;

    public static void method() {
        System.out.println("静态方法");
    }


//    public void show() {
//        System.out.println(this.name + "," + this.age + "," + this.teacherName);
//    }

    // 其实上面的方法隐藏了一个this
    // this:表示当前方法调用者的地址值,这个this由虚拟机赋值
    public void show(Student this) {
        System.out.println(this);
        System.out.println(name + "," + age + "," + teacherName);
    }
}

package day7.code.StaticDemo03;


public class StudentTest {
    public static void main(String[] args) {
        Student.teacherName = "Tom";

        Student stu1 = new Student();
        System.out.println(stu1);
        stu1.name = "张三";
        stu1.age = 18;
        stu1.show();

        System.out.println("====================");

        Student stu2 = new Student();
        System.out.println(stu2);
        stu2.name = "李四";
        stu2.age = 20;
        stu2.show();
    }
}

结果展示：

day7.code.StaticDemo03.Student@1b6d3586
day7.code.StaticDemo03.Student@1b6d3586
张三,18,Tom
====================
day7.code.StaticDemo03.Student@4554617c
day7.code.StaticDemo03.Student@4554617c
李四,20,Tom

由结果可知，show(Student this)中的this表示当前方法调用者的地址值.

这个this由虚拟机赋值，不能主动赋值，比如stu1.show(stu2);就会报错。

show方法同样可以改为：

public void show(Student this) {
        System.out.println(this);
        System.out.println(this.name + "," + this.age + "," + this.teacherName);
    }

因为this表示当前方法调用者的地址值，只不过这里this可以省略，顾不写

二、静态方法中，只能访问静态

换句话理解，静态方法不能访问非静态的东西（两个：成员变量和成员方法）

报错原因也很简单，程序并不知道this指向的是谁，不知道打印的是哪个对象的成员变量和成员方法。

静态方法没有this，无法访问成员变量和成员方法。

三、非静态方法可以访问所有

随便访问。

public void show(Student this) {
        System.out.println(this);
        System.out.println(this.name + "," + this.age + "," + this.teacherName);
        
        method(); // 调用静态方法
    }

1.4.2 从内存方面理解

首先我们要知道“静态”与“非静态”加载的时机不同：

• 静态：随着类的加载而加载
• 非静态：和对象有关

只加载了类，没有创建对象，那内存中就会只加载静态的东西，不加载非静态的东西。

下面我们从static内存图方面理解static的注意事项：

一、静态方法不能访问非静态

静态方法不能调用实例变量

静态方法不能调用非静态方法

二、非静态可以访问所有

1.5 重新认识main方法

学习了那么多东西，现在回顾一下mian方法中的各个词

2、继承

面向对象三大特征：封装、继承、多态

2.1 继承的概述

概述：

使用场景：

• 类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承

2.2 继承的特点

Java继承的特点：

• 只能单继承
• 不支持多继承，但支持多层继承
• 所有的类都直接或者间接继承于Object

为什么不和C++一样支持多继承？

写代码不爽

Java中所有的类都直接或者间接继承于Object

练习1：继承的练习

思路：

示例代码：

• 第一层：动物

  public class Animal {
      public void eat() {
          System.out.println("吃东西");
      }
  
      public void drink() {
          System.out.println("喝水");
      }
  }
  

• 第二层：猫、狗

  public class Dog extends Animal {
      public void lookHome() {
          System.out.println("看家");
      }
  }
  

  public class Cat extends Animal {
      public void catchMouse() {
          System.out.println("抓老鼠");
      }
  }
  

• 第三层

  public class TaiDi extends Dog {
      public void touch() {
          System.out.println("泰迪蹭一蹭");
      }
  }
  

  public class HaShiQi extends Dog {
      public void breakHome() {
          System.out.println("哈士奇拆家");
      }
  }
  

  public class LiHua extends Cat {
  }
  

  public class BuOu extends Cat {
  }
  

• 测试

  public class TestDemo {
      public static void main(String[] args) {
          BuOu b = new BuOu();
          b.catchMouse();  // 抓老鼠
  
          LiHua l = new LiHua();
          l.eat();  // 吃东西
          
          HaShiQi h = new HaShiQi();
          h.breakHome();  // 哈士奇拆家
          h.drink();  // 喝水
  
          TaiDi t = new TaiDi();
          t.touch();  // 泰迪蹭一蹭
          t.lookHome();  // 看家
      }
  }
  

2.3 子类到底能继承父类的哪些内容？

2.3.1 构造方法

父类的构造方法不能被继承。

我们从代码方面理解：

2.3.2 成员变量

无论私有还是非私有，成员变量都可以被继承，但私有的情况下，成员变量不能直接被使用。

非私有的情况下：

私有情况下（用privite修饰）：

2.3.3 成员方法

• 非私有：可以
• 私有：不可以

先看看如果采用传统的继承方式：

加入我向找P方法，那就要找15层，追溯到A方法

这样继承，会导致代码效率非常低，所以Java采用了”虚方法“，提高效率

2.4 继承中：成员变量的访问特点

总结：

示例代码：

public class ExdendsDemo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.showName();
    }
}

class Fu {
    String name = "Fu";
}

class Zi extends Fu {
    String name = "Zi";

    public void showName() {
        String name = "Temp";
        System.out.println(name);  // Temp
        System.out.println(this.name);  // Zi
        System.out.println(super.name);  // Fu
    }
}

2.5继承中：成员方法的访问特点

• 直接调用满足就近原则
• super调用，直接访问父类

方法重写的本质：子类覆盖了从父类继承的虚方法表的方法

示例代码：

public class ExdendsDemo2 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.methd();
    }
}

class Ye {
    public void speak() {
        System.out.println("我是Ye");
    }
}

class Fu extends Ye {
    @Override
    public void speak() {
        System.out.println("我是Fu");
    }
}

class Zi extends Fu {
    @Override
    public void speak() {
        System.out.println("我是Zi");
    }

    public void methd() {
        this.speak();  // 我是Zi
        super.speak();  // 我是Fu
    }
}

2.6 继承中：构造方法的特点

示例代码：

package day8.code.Demo3;

public class Fu {
    String name;
    int age;

    public Fu() {
        System.out.println("这是父类的空参构造");
    }

    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package day8.code.Demo3;

public class Zi extends Fu {
    public Zi() {
        super();  // 不写也行，子类的构造方法默认先访问父类的空参构造
        System.out.println("这是子类的空参构造");
    }

    // 当人我们可以基于super，完成和父类一样的带参构造
    public Zi(String name, int age) {
        super(name, age);
    }
}

package day8.code.Demo3;

public class TestDemo {
    public static void main(String[] args) {
        // 1.有参构造
        Zi z = new Zi("Zhangsan", 18);
        System.out.println(z.name + "," + z.age);  // Zhangsan,18

        // 2.无参构造
        Zi z2 = new Zi();
        // 这是父类的空参构造
        // 这是子类的空参构造
    }
}

2.7 this、super使用总结

练习

示例代码：

先写一个员工类

package day8.code.Demo4;

public class Employee {
    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void work() {
        System.out.println("员工正在工作");
    }

    public void eat() {
        System.out.println("吃米饭");
    }
}

然后写员工类的两个子类：经理、厨师

package day8.code.Demo4;

public class Manager extends Employee {
    private double annualSalary;

    public Manager() {
    }


    public Manager(String id, String name, double salary, double annualSalary) {
        super(id, name, salary);
        this.annualSalary = annualSalary;
    }

    public double getAnnualSalary() {
        return annualSalary;
    }

    public void setAnnualSalary(double annualSalary) {
        this.annualSalary = annualSalary;
    }

    @Override
    public void work() {
        System.out.println("经理在管理其他人");
    }
}

package day8.code.Demo4;

public class Cook extends Employee {
    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }

    public void work() {
        System.out.println("厨师正在做饭");
    }
}

最后写个测试类看看效果：

package day8.code.Demo4;

public class TestDemo {
    public static void main(String[] args) {
        Employee e = new Employee("001", "张三", 1000);
        System.out.println(e.getId() + "," + e.getName() + "," + e.getSalary());  // 001,张三,1000.0
        e.work();  // 员工正在工作
        e.eat();  // 吃米饭

        Manager m = new Manager("002", "李四", 1000, 2000);
        System.out.println(m.getId() + "," + m.getName() + "," + m.getSalary() + "," + m.getAnnualSalary());  // 002,李四,1000.0,2000.0
        m.work();  // 经理在管理其他人
        m.eat();  // 吃米饭

        Cook c = new Cook("003", "王五", 1200);
        System.out.println(c.getId() + "," + c.getName() + "," + c.getSalary());  // 003,王五,1200.0
        c.work();  // 厨师正在做饭
        c.eat();  // 吃米饭
    }
}

3、多态

3.1 多态的概述

应用场景-例子：假如我们要写个学生信息管理系统，在写注册时，由于使用者不同，按之前的学习成果，我们会写三个注册方法，对应不同的形参

而现在，基于多态，一个就够了，我们在形参里可以用他们共同的父类：Person

示例代码：

package day8.code.Demo5;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 day8.code.Demo5;

public class Student extends Person{
    @Override
    public void show(){
        System.out.println("学生信息为：" + getName() + "," + getAge());
    }
}

package day8.code.Demo5;

public class Teacher extends Person{
    @Override
    public void show(){
        System.out.println("老师信息为：" + getName() + "," + getAge());
    }
}

package day8.code.Demo5;

public class Manager extends Person{
    @Override
    public void show(){
        System.out.println("管理员信息为：" + getName() + "," + getAge());
    }
}

package day8.code.Demo5;

public class TestDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);

        Teacher t = new Teacher();
        t.setName("李四");
        t.setAge(30);

        Manager m = new Manager();
        m.setName("王五");
        m.setAge(25);

        register(s);  // 学生信息为：张三,18
        register(t);  // 老师信息为：李四,30
        register(m);  // 管理员信息为：王五,25
    }

    public static void register(Person p){
        p.show();
    }
}

3.2 多态调用成员的特点

• 变量调用：编译看左边，运行也看左边
• 方法调用：编译看左边，运行看右边

内存理解：

3.3 多态的优势和弊端

优势：

总结：

综合练习

链接：面向对象进阶-12-多态的综合练习

4、包、final、权限修饰符、代码块

此部分为面向对象进阶部分补充知识。

4.1 包

包的概述

包的使用规则：

第四种情况：

总结：

4.2 final

final常用于修饰一些“规则”，防止

示例：

关于常量：

补充：我们之前说过“字符串不能被改变”，就涉及到final，String源码如下：

4.3 权限修饰符

• 概念：用来控制一个成员能够被访问的范围。
• 可以修饰成员变量、方法、构造方法、内部类。
• 分类：
  

4.4 代码块

分类：

• 局部代码块（已淘汰）：提前结束变量的生命周期
• 构造代码块（了解即可）：抽取构造方法中的重复代码
• 静态代码块（重点）：数据的初始化

构造代码块：

静态代码块：

示例代码：

public class Student {
    String name;

    static {
        System.out.println("这是静态代码块");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Student s = new Student();  // 这是静态代码块
    }
}

5、抽象类

抽象类和抽象方法

5.1 概述

5.2 定义格式

示例代码：

假设我们需要写一个类，每个子类都有一个work（）函数，但内容不同，此时就可以使用抽象类：

public abstract class Person {
    public abstract void work();
}

5.3 注意事项

抽象类不能实例化：

其实就是不能创建对象（简单理解为抽象类是用于继承的，它没有什么内容，不需要实例化）

练习

示例代码：

首先定义父类Animal，我们基于抽象类去写Animal

package day9.code.Demo03;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(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 drink(){
        System.out.println("正在喝水");
    }

    public abstract void eat();
}

之后开始写三个子类：

package day9.code.Demo03;

public class Front extends Animal {
    public Front() {
    }

    public Front(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}

package day9.code.Demo03;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
}

package day9.code.Demo03;

public class Sheep extends Animal {
    public Sheep() {
    }

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("山羊在吃草");
    }
}

最后写测试类，看看效果：

package day9.code.Demo03;

public class TestDemo {
    public static void main(String[] args) {
        Dog d = new Dog("张三", 3);
        System.out.println(d.getName() + "," + d.getAge());  // 张三,3
        d.eat();  // 狗在吃骨头
        d.drink();  // 正在喝水
    }
}

5.4 小结

6、接口

6.1 定义和使用

接口和抽象类：

练习

示例代码：

首先创建父类Animal

package day9.code.Demo04;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(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 abstract void eat();
}

之后创建”游泳“接口

package day9.code.Demo04;

public interface Swim {
    public abstract void swim();
}

之后创建子类：兔子

package day9.code.Demo04;

public class Rabbit extends Animal {
    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }
}

之后，定义青蛙，此时就涉及到游泳这个接口：

通过报错提示，我们可以知道要定义哪些抽象类，点击”OK“，IDEA可以帮我们写部分代码。

package day9.code.Demo04;

public class Front extends Animal implements Swim {
    public Front() {
    }

    public Front(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

之后，撰写子类：狗

package day9.code.Demo04;

public class Dog extends Animal implements Swim {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在啃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗在狗刨");
    }
}

最后写个测试类看看效果：

package day9.code.Demo04;

public class TestDemo {
    public static void main(String[] args) {
        Front f = new Front("张三", 1);
        System.out.println(f.getName() + "," + f.getAge());  // 张三,1
        f.eat();  // 青蛙在吃虫子
        f.swim();  // 青蛙在蛙泳
    }
}

6.2 接口成员的特点

6.3 接口和类之间的关系

细节：如果实现类实现了最下面的子接口，那么我们就需要重写所有的抽象方法。

如果你是西安Inter3，那么同时也必须重写Inter1和Inter2

6.4 接口和抽象类的综合练习

视频链接：面向对象进阶-18-接口和抽象类的综合案例_哔哩哔哩_bilibili

思路：

6.5 多学三招

• JDK8开始接口中新增的方法
• 接口的应用
• 适配器设计模式

6.5.1 JDK8开始接口中新增的方法

为何要这样设计呢？

此时我们就可以基于JDK8新特性去解决问题

6.5.1.1 默认方法

示例：

6.5.1.2 静态方法

示例代码：

首先定义一个接口，它含有一个抽象方法个一个静态方法

package day9.code.Demo05;

public interface Inter {
    public abstract void method();

    public static void show(){
        System.out.println("静态方法");
    }
}

之后创建一个实现类，此时会发现，我们只需要重写抽象方法，不需要重写静态方法（静态方法不可被重写，当然，如果你重新定义一个与静态方法同名的方法也可以，这不是重写，两个方法调用方式不同而已）

package day9.code.Demo05;

public class InterImpl implements Inter{
    @Override
    public void method() {
        System.out.println("Inter中的抽象方法");
    }

    public void show(){
        System.out.println("实现类中的show");
    }
}

最后写个测试类：

package day9.code.Demo05;

public class TestDemo {
    public static void main(String[] args) {
        // 调用接口中的静态方法
        Inter.show();  // 静态方法show

        // 调用实现类中的方法
        InterImpl i = new InterImpl();
        i.method();  // Inter中的抽象方法
        i.show();  // 实现类中的show
    }
}

6.5.2 JDK9开始接口中新增的方法

小结：

6.5.3 接口的应用

接口的多态：

6.5.4 适配器设计模式

应用示例：

比方说我由一个抽象类，里面由五个抽象方法，但我现在只需要抽象方法中的method3，其他的都不要，怎么办呢？

package day9.code.Demo06;

public interface Inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
}

我们可以先写一个中间的适配器InterAdapter，将该抽象类中的五个抽象方法都进行”空实现“。

细节：因为InterAdapter作为适配器，没有被实例化的意义，所以一般我们会加个abstract，将其变为抽象类

package day9.code.Demo06;

public abstract class InterAdapter implements Inter{
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }
}

然后再写一个类去继承InterAdapter，此时我们就可以实现需要哪个抽象方法就写哪个抽象方法了

package day9.code.Demo06;

public class InterImpl extends InterAdapter {
    @Override
    public void method3() {
        System.out.println("method3");
    }
}

最后写个测试类：

package day9.code.Demo06;

public class TestDemo {
    public static void main(String[] args) {
        InterImpl i = new InterImpl();
        i.method3();  // method3
    }
}

总结：

7、内部类

• 内部类的概念
• 内部类的分类
  • 成员内部类（了解）
  • 静态内部类（了解）
  • 局部内部类（了解）
  • 匿名内部类（掌握）

7.1 内部类的概念

7.2 成员内部类

7.2.1 内部类的书写

7.2.2 创建成员内部类的对象

方式一示例代码：

7.2.3 成员内部类如何获取外部类的成员变量

直接通过案例理解：

结合内存图去理解：

7.3 静态内部类

示例代码：

小结：

7.4 局部内部类

示例代码：

7.5 匿名内部类

示例代码一：

为啥格式长这样呢？

示例代码二：

如果是抽象方法，格式又怎样理解？

接下来，我们通过将class反编译，更好的理解匿名内部类：

此时我们可以看出，红框里的代码其实就是个对象，真正的匿名内部类是大括号里的内容。

大括号里的内容和new Animal() 可以是实现关系，也可以是继承关系，就看我们自己先前定义的是接口还是类了。

示例代码三：

那匿名内部类到底干嘛用？

小结：

8、阶段项目：拼图小游戏

拼图小游戏

• 视频链接：阶段项目-01-项目介绍和界面搭建
• 涉及知识：前文所学 + GUI

03 常用API

• Math
• System
• Runtime
• Object和Objects
• BigInteger和BigDecimal
• 正则表达式

1、Math

1.1 概述

Math：

• 一个进行数学计算的工具类
• 私有化构造方法，所有的方法都是金静态的

1.2 常用方法

示例代码：

public class Math01 {
    public static void main(String[] args) {
        int a = -1;
        int b = Math.abs(a);
        System.out.println(b);  // 1
    }
}

练习：常用API-02-练习：两道数学算法题

2、System

示例代码一：

public class System01 {
    public static void main(String[] args) {
        System.out.println("Hello 01");
        // 0 : 正常停止
        // 1 ： 异常停止
        System.exit(0);
        System.out.println("Hello 02");
    }
}

结果过展示：

Hello 01

Process finished with exit code 0

示例代码二：

public class System02 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++)
            System.out.println("正在计时");
        long end = System.currentTimeMillis();

        System.out.println(end - start);  // 2
    }
}

示例代码三：

public class System03 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[3];
        System.arraycopy(arr1, 1, arr2, 0, 3);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

结果展示：

2
3
4

Process finished with exit code 0

小结：

3、Runtime

Runtime表示当前虚拟机的运行环境

示例代码：

package day10.code.Demo01;

public class Runtime01 {
    public static void main(String[] args) {
        // 1.getRuntime()
        Runtime r1 = Runtime.getRuntime();
        Runtime r2 = Runtime.getRuntime();
        System.out.println(r1 == r2);

        // 2.exit()
        // Runtime.getRuntime().exit(0);
        /* 补充 System.exit() 的底层就是基于Runtime
        public static void exit(int status) {
            Runtime.getRuntime().exit(status);
        }
         */

        // 3.availableProcessors()
        System.out.println(Runtime.getRuntime().availableProcessors());  // 12

        // 4.maxMemory()
        System.out.println(Runtime.getRuntime().maxMemory());  // 3776970752

        // 5.totalMemory()
        System.out.println(Runtime.getRuntime().totalMemory());  // 255328256

        // 6.freeMemory()
        System.out.println(Runtime.getRuntime().freeMemory());  // 251328480

        // 7.exec()
        // Runtime.getRuntime().exec("shutdowm -a");

    }
}

4、Object和Objects

视频链接：

• 常用API-05-Object_哔哩哔哩_bilibili
• 常用API-06-浅克隆、深克隆和对象工具类Objects_哔哩哔哩_bilibili

老师常常结合源码去解释知识点，讲的非常细，视频可以多刷几遍。

4.1 Object

Object:

• Java中的顶级父类。所有的类都直接或间接的继承与Object类。
• Object类中的方法可以被所有子类访问，所以我们要学习Object类和其中的方法。

4.1.1 Object的构造方法

• 只有一个空参构造

4.1.2 Object的成员方法

这里先学习三个常用的，其他的之后再聊。

public String toString()				//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)		//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()    			//对象克隆

4.1.2.1 toString方法

• 作用：返回对象的字符串表示形式
• 总结：如果向看到对象的属性值，就重写toString方法

案例1：演示toString方法

实现步骤：

1. 创建一个学生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法
2. 创建一个测试类（ObjectDemo01），在测试类的main方法中去创建学生对象，然后调用该对象的toString方法获取该对象的字符串表现形式，并将结果进行输出

如下所示：

Student类

public class Student {

    private String name ;       // 姓名
    private String age ;        // 年龄

    // 无参构造方法和有参构造方法以及get和set方法略
    ...
        
}

ObjectDemo01测试类

public class ObjectDemo01 {

    public static void main(String[] args) {

        // 创建学生对象
        Student s1 = new Student("itheima" , "14") ;

        // 调用toString方法获取s1对象的字符串表现形式
        String result1 = s1.toString();

        // 输出结果
        System.out.println("s1对象的字符串表现形式为：" + result1);

    }

}

运行程序进行测试，控制台输出结果如下所示：

s1对象的字符串表现形式为：com.itheima.api.system.demo04.Student@3f3afe78

为什么控制台输出的结果为：com.itheima.api.system.demo04.Student@3f3afe78； 此时我们可以查看一下Object类中toString方法的源码，如下所示：

public String toString() {		// Object类中toString方法的源码定义
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

其中getClass().getName()对应的结果就是：com.itheima.api.system.demo04.Student；Integer.toHexString(hashCode())对应的结果就是3f3afe78。

我们常常将"com.itheima.api.system.demo04.Student@3f3afe78"这一部分称之为对象的内存地址值。但是一般情况下获取对象的内存地址值没有太大的意义。获取对象的成员变量的字符串拼接形式才算有意义，怎么实现呢？此时我们就需要在Student类中重写Object的toString方法。我们可以通过idea开发工具进行实现，具体步骤如下所示：

1. 在空白处使用快捷键：alt + insert。此时会弹出如下的对话框

2. 选择toString，此时会弹出如下的对话框

同时选择name和age属性，点击OK。此时就会完成toString方法的重写，代码如下所示：

@Override
public String toString() {
    return "Student{" +
        "name='" + name + '\'' +
        ", age='" + age + '\'' +
        '}';
}

这段代码就是把Student类中的成员变量进行了字符串的拼接。重写完毕以后，再次运行程序，控制台输出结果如下所示：

s1对象的字符串表现形式为：Student{name='itheima', age='14'}

此时我们就可以清楚的查看Student的成员变量值，因此重写toString方法的意义就是以良好的格式，更方便的展示对象中的属性值

我们再来查看一下如下代码的输出：

// 创建学生对象
Student s1 = new Student("itheima" , "14") ;

// 直接输出对象s1
System.out.println(s1);

运行程序进行测试，控制台输出结果如下所示：

Student{name='itheima', age='14'}

我们可以看到和刚才的输出结果是一致的。那么此时也就证明直接输出一个对象，那么会默认调用对象的toString方法，因此如上代码的等同于如下代码：

// 创建学生对象
Student s1 = new Student("itheima" , "14") ;

// 调用s1的toString方法，把结果进行输出
System.out.println(s1.toString());

因此后期为了方便进行测试，我们常常是通过输出语句直接输出一个对象的名称。

小结：

1. 在通过输出语句输出一个对象时，默认调用的就是toString()方法
2. 输出地址值一般没有意义，我们可以通过重写toString方法去输出对应的成员变量信息（快捷键：atl + insert ， 空白处 右键 -> Generate -> 选择toString）
3. toString方法的作用：以良好的格式，更方便的展示对象中的属性值
4. 一般情况下Jdk所提供的类都会重写Object类中的toString方法

4.1.2.2 equals方法

案例：演示equals方法

实现步骤：

1. 在测试类（ObjectDemo02）的main方法中，创建两个学生对象，然后比较两个对象是否相同

代码如下所示：

public class ObjectDemo02 {

    public static void main(String[] args) {

        // 创建两个学生对象
        Student s1 = new Student("itheima" , "14") ;
        Student s2 = new Student("itheima" , "14") ;

        // 比较两个对象是否相等
        System.out.println(s1 == s2);

    }

}

运行程序进行测试，控制台的输出结果如下所示：

false

因为"=="号比较的是对象的地址值，而我们通过new关键字创建了两个对象，它们的地址值是不相同的。因此比较结果就是false。

我们尝试调用Object类中的equals方法进行比较，代码如下所示：

// 调用equals方法比较两个对象是否相等
boolean result = s1.equals(s2);

// 输出结果
System.out.println(result);

运行程序进行测试，控制台的输出结果为：

false

为什么结果还是false呢？我们可以查看一下Object类中equals方法的源码，如下所示：

public boolean equals(Object obj) {		// Object类中的equals方法的源码
    return (this == obj);
}

通过源码我们可以发现默认情况下equals方法比较的也是对象的地址值。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；

那么要比较对象的属性，我们就需要在Student类中重写Object类中的equals方法。equals方法的重写，我们也可以使用idea开发工具完成，具体的操作如下所示：

1. 在空白处使用快捷键：alt + insert。此时会弹出如下的对话框

2. 选择equals() and hashCode()方法，此时会弹出如下的对话框

点击next，会弹出如下对话框：

选择neme和age属性点击next，此时就会弹出如下对话框：

取消name和age属性（因为此时选择的是在生成hashCode方法时所涉及到的属性，关于hashCode方法后期再做重点介绍），点击Finish完成生成操作。生成的equals方法和hashCode方法如下：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return Objects.equals(name, student.name) && Objects.equals(age, student.age);	// 比较的是对象的name属性值和age属性值
}

@Override
public int hashCode() {
    return 0;
}

hashCode方法我们暂时使用不到，可以将hashCode方法删除。重写完毕以后运行程序进行测试，控制台输出结果如下所示：

true

此时equals方法比较的是对象的成员变量值，而s1和s2两个对象的成员变量值都是相同的。因此比较完毕以后的结果就是true。

小结：

1. 默认情况下equals方法比较的是对象的地址值
2. 比较对象的地址值是没有意义的，因此一般情况下我们都会重写Object类中的equals方法

4.1.2.3 clone方法

​ 把A对象的属性值完全拷贝给B对象，也叫对象拷贝,对象复制

对象克隆的分类：

深克隆和浅克隆

浅克隆：

​ 不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来

​ 基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。

​ Object类默认的是浅克隆

深克隆：

​ 基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的

代码实现：

package com.itheima.a04objectdemo;

public class ObjectDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected object clone(int a) 对象克隆 

        //1.先创建一个对象
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
        User u1 = new User(1, "zhangsan", "1234qwer", "girl11", data);

        //2.克隆对象
        //细节:
        //方法在底层会帮我们创建一个对象,并把原对象中的数据拷贝过去。
        //书写细节:
        //1.重写Object中的clone方法
        //2.让javabean类实现Cloneable接口
        //3.创建原对象并调用clone就可以了
        //User u2 =(User)u1.clone();

        //验证一件事情：Object中的克隆是浅克隆
        //想要进行深克隆，就需要重写clone方法并修改里面的方法体
        //int[] arr = u1.getData();
        //arr[0] = 100;

        //System.out.println(u1);
        //System.out.println(u2);


        //以后一般会用第三方工具进行克隆
        //1.第三方写的代码导入到项目中
        //2.编写代码
        //Gson gson =new Gson();
        //把对象变成一个字符串
        //String s=gson.toJson(u1);
        //再把字符串变回对象就可以了
        //User user =gson.fromJson(s, User.class);

        //int[] arr=u1.getData();
        //arr[0] = 100;

        //打印对象
        //System.out.println(user);

    }
}

package com.itheima.a04objectdemo;

import java.util.StringJoiner;



//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦实现了，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克隆
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private String path;
    private int[] data;




    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    /**
     * 获取
     *
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     *
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     *
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     *
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     *
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     *
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     *
     * @return path
     */
    public String getPath() {
        return path;
    }

    /**
     * 设置
     *
     * @param path
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * 获取
     *
     * @return data
     */
    public int[] getData() {
        return data;
    }

    /**
     * 设置
     *
     * @param data
     */
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "角色编号为：" + id + "，用户名为：" + username + "密码为：" + password + ", 游戏图片为:" + path + ", 进度:" + arrToString();
    }


    public String arrToString() {
        StringJoiner sj = new StringJoiner(", ", "[", "]");

        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。

        //先把被克隆对象中的数组获取出来
        int[] data = this.data;
        //创建新的数组
        int[] newData =new int[data.length];
        //拷贝数组中的数据
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //调用父类中的方法克隆对象
            User u=(User)super.clone();
        //因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
        u.data =newData;
        return u;
    }
}

4.2 Objects类

4.2.1 概述

tips：了解内容

查看API文档，我们可以看到API文档中关于Objects类的定义如下：

Objects类所在包是在java.util包下，因此在使用的时候需要进行导包。并且Objects类是被final修饰的，因此该类不能被继承。

Objects类提供了一些对象常见操作的方法。比如判断对象是否相等，判断对象是否为null等等。

接下来我们来查看一下API文档，看一下Objects类中的成员，如下所示：

我们可以发现Objects类中无无参构造方法，因此我们不能使用new关键字去创建Objects的对象。同时我们可以发现Objects类中所提供的方法都是静态的。因此我们可以通过类名直接去调用这些方法。

4.2.2 常见方法

tips：重点讲解内容

常见方法介绍

我们要重点学习的Objects类中的常见方法如下所示：

public static String toString(Object o) 					// 获取对象的字符串表现形式
public static boolean equals(Object a, Object b)			// 比较两个对象是否相等
public static boolean isNull(Object obj)					// 判断对象是否为null
public static boolean nonNull(Object obj)					// 判断对象是否不为null

我们要了解的Objects类中的常见方法如下所示：

public static <T> T requireNonNull(T obj)					// 检查对象是否不为null,如果为null直接抛出异常；如果不是null返回该对象；
public static <T> T requireNonNullElse(T obj, T defaultObj) // 检查对象是否不为null，如果不为null，返回该对象；如果为null返回defaultObj值
public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier)	// 检查对象是否不为null，如果不为null，返回该对象；如果															 // 为null,返回由Supplier所提供的值

上述方法中的T可以理解为是Object类型。

案例演示