Java总结六：面向对象编程（上）_java面向对象编程cat-CSDN博客

本文链接：https://blog.csdn.net/Baridhu/article/details/122758557

面向对象编程（一）

⭐️类与对象⭐️

📚首先看一个养猫猫问题

张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 10 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫

在这里插入图片描述

📚使用现有技术解决

之前我们的技术只有：
☕️单独的定义变量解决
☕️使用数组解决

📚现有技术解决的缺点分析
☕️单独的定义变量解决:不利于数据的管理

     //单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
     //第 1 只猫信息
     String cat1Name = "小白";
     int cat1Age = 3;
     String cat1Color = "白色";
     //第 2 只猫信息
     String cat2Name = "小花";
     int cat2Age = 10;
     String cat2Color = "花色";

☕️使用数组解决:
(1)数据类型体现不出来;
(2) 只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确;
(3) 不能体现猫的行为。

//数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确(3) 不能体现猫的行为
//第 1 只猫信息
String[] cat1 = {"小白", "3", "白色"};
//第 2 只猫信息
String[] cat2 = {"小花", "10", "花色"};

📚优化解决方法：引入类与对象(OOP)

java 设计者引入类与对象(OOP) ,根本原因就是现有的技术，不能完美的解决新的新的需求.

☕️代码如下：

public class Object01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        //使用 OOP 面向对象解决
        //实例化一只猫[创建一只猫对象]
        //1. new Cat() 创建一只猫(猫对象)
        //2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
        //3. cat1 就是一个对象
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";
        cat1.weight = 10;
        //创建了第二只猫，并赋给 cat2
        //cat2 也是一个对象(猫对象)
        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 10;
        cat2.color = "花色";
        cat2.weight = 20;
        //怎么访问对象的属性呢
        System.out.println("第 1 只猫信息" + cat1.name
                + " " + cat1.age + " " + cat1.color + " " + cat1.weight);
        System.out.println("第 2 只猫信息" + cat2.name
                + " " + cat2.age + " " + cat2.color + " " + cat2.weight);
    }
}
    //使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
    //属性/成员变量
    String name; //名字
    int age; //年龄
    String color; //颜色
    double weight; //体重
//行为
}

📚一个程序其实就是一个世界，里面包含了许多的事物，这些事物可以用对象来表示，其中对象又包含属性和行为。(对象[属性, 行为）
在这里插入图片描述

📚类与对象的关系示意图

在这里插入图片描述
说明：

类就是数据类型,比如Cat
对象就是一个具体的实例,

📚类和对象的区别和联系

☕️类是抽象的，概念的，代表一类事物,比如人类,猫类…, 即它是数据类型；
☕️对象是具体的，实际的，代表一个具体事物, 即是实例；
☕️ 类是对象的模板，对象是类的一个个体，对应一个实例。

⭐️对象在内存中存在形式(重要！！！)

在这里插入图片描述

📚属性/成员变量/字段

☕️从概念或叫法上看： 成员变量 = 属性 = field(字段) （即成员变量是用来表示属性的)
☕️属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的 int age 就是属性。

📚 注意事项和细节

☕️属性的定义语法同变量，示例：访问修饰符属性类型属性名;
其中访问修饰符：控制属性的访问范围，有四种访问修饰符 public, proctected, 默认, private ,后面会详细介绍。
☕️属性的定义类型可以为任意类型，包含基本类型或引用类型。
☕️属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null。

public class Details {
    //编写一个 main 方法
    public static void main(String[] args) {
        //创建 Person 对象
        //p1 是对象名(对象引用)
        //new Person() 创建的对象空间(数据) 才是真正的对象
        Person p1 = new Person();
        //对象的属性默认值，遵守数组规则:
        //int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
        System.out.println("\n 当前这个人的信息");
        System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
    }
}
class Person {
    //四个属性
    int age;
    String name;
    double sal;
    boolean isPass;
}

📚如何创建对象

📒先声明再创建

Cat cat ; //声明对象 cat
cat = new Cat(); //创建

📒直接创建

Cat cat = new Cat();

📚如何访问属性

基本语法：对象名.属性名;
案例演示赋值和输出：

cat.name ;
cat.age;
cat.color;

⭐️成员方法⭐️

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名…),我们人类还有一些行为比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用成员方法才能完成。

📚成员方法快速入门

添加 speak 成员方法,输出 “我是一个好人”；
添加 cal01 成员方法,可以计算从 1+…+1000 的结果；
添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+…+n 的结果；
添加 getSum 成员方法,可以计算两个数的和。

public class Method01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        //方法使用
        //1. 方法写好后，如果不去调用(使用)，不会输出
        //2. 先创建对象 ,然后调用方法即可
        Person1 p1 = new Person1();
        p1.speak(); //调用方法
        p1.cal01(); //调用 cal01 方法
        p1.cal02(5); //调用 cal02 方法，同时给 n = 5
        p1.cal02(10); //调用 cal02 方法，同时给 n = 10
        //调用 getSum 方法，同时 num1=10, num2=20
        //把 方法 getSum 返回的值，赋给 变量 returnRes
        int returnRes = p1.getSum(10, 20);
        System.out.println("getSum 方法返回的值=" + returnRes);
    }
}
class Person1 {
    String name;
    int age;
    //方法(成员方法)
    //添加 speak 成员方法,输出 “我是一个好人”
    //1. public 表示方法是公开
    //2. void ： 表示方法没有返回值
    //3. speak() : speak 是方法名， () 形参列表
    //4. {} 方法体，可以写我们要执行的代码
    //5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
    public void speak() {
        System.out.println("我是一个好人");
    }
    //添加 cal01 成员方法,可以计算从 1+..+1000 的结果
    public void cal01() {
        //循环完成
        int res = 0;
        for(int i = 1; i <= 1000; i++) {
            res += i;
        }
        System.out.println("cal01 方法 计算结果=" + res);
    }
    //添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果
    //1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
    public void cal02(int n) {
        //循环完成
        int res = 0;
        for(int i = 1; i <= n; i++) {
            res += i;
        }
        System.out.println("cal02 方法 计算结果=" + res);
    }
    //添加 getSum 成员方法,可以计算两个数的和
    //1. public 表示方法是公开的
    //2. int :表示方法执行后，返回一个 int 值
    //3. getSum 方法名
    //4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数
    //5. return res; 表示把 res 的值， 返回
    public int getSum(int num1, int num2) {
        int res = num1 + num2;
        return res;
    }
}

📒输出结果：

我是一个好人
cal01 方法 计算结果=500500
cal02 方法 计算结果=15
cal02 方法 计算结果=55
getSum 方法返回的值=30

在这里插入图片描述

📚成员方法的好处

提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可

📚成员方法的定义

访问修饰符 返回数据类型 方法名（形参列表..） {//方法体
语句；
return 返回值;
}

1. 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
2. 返回数据类型：表示成员方法输出, void 表示没有返回值
3. 方法主体：表示为了实现某一功能代码块
4. return 语句不是必须的。
5. 提示: 结合前面的题示意图, 来理解

📚注意事项和使用细节

📒访问修饰符 (作用是控制方法使用的范围)
如果不写默认访问，[有四种: public, protected, 默认, private], 具体在后面说。
📒返回数据类型

一个方法最多有一个返回值 [思考，如何返回多个结果返回数组 ]
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的
值类型一致或兼容
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

📒方法名

遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和——getSum, 开发中按照规范。

📒形参列表

一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如getSum(int n1,int n2)
参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[][] map)
调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!getSum(4)．方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参,实参和形参的类型要一致或兼容、个数、顺序必须一致!

📒方法体

里面写完成功能的具体的语句。可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。

public class MethodDetail {
    public static void main(String[] args) {
        AA a = new AA();
        int[] res = a.getSumAndSub(1, 4);//实参
        System.out.println("和=" + res[0]);
        System.out.println("差=" + res[1]);
        //细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
        byte b1 = 1;
        byte b2 = 2;
        a.getSumAndSub(b1, b2);//byte -> int
        //a.getSumAndSub(1.1, 1.8);//double ->int(×)
        //细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致
        //a.getSumAndSub(100);//× 个数不一致
        a.f3("tom", 10); //ok
        //a.f3(100, "jack"); // 实际参数和形式参数顺序不对
    }
}
class AA {
    //细节: 方法不能嵌套定义
    public void f4() {
    //错误
    // public void f5() {
    // }
    }
    public void f3(String str, int n) {
    }
    //1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]
    public int[] getSumAndSub(int n1, int n2) {//形参
        int[] resArr = new int[2]; //
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
    //2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
    // 具体看 getSumAndSub
    //3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
    //而且要求返回值类型必须和 return 的值类型一致或兼容
    public double f1() {
        double d1 = 1.1 * 3;
        int n = 100;
        return n; // int ->double
        //return d1; //ok? double -> int
    }
    //如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
    //提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义
    //，最好是见名知意
    public void f2() {
        System.out.println("hello1");
        System.out.println("hello1");
        System.out.println("hello1");
        int n = 10;
        //return ;
    }
}

📒方法调用细节说明

同一个类中的方法调用:直接调用即可。比如print(参数);
案例演示:A类sayOk调用print()
跨类中的方法A类调用B类方法:需要通过对象名调用。比如对象名.方法名(参数);案例演示:B类 hi 调用print()
特别说明一下:跨类的方法调用和方法的访问修饰符相关。

public class MethodDetail02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        A a = new A();
        //a.sayOk();
        a.m1();
    }
}
class A {
    //同一个类中的方法调用：直接调用即可
    public void print(int n) {
        System.out.println("print()方法被调用 n=" + n);
    }
    public void sayOk() { //sayOk 调用 print(直接调用即可)
        print(10);
        System.out.println("继续执行 sayOK()~~~");
    }
    //跨类中的方法 A 类调用 B 类方法：需要通过对象名调用
    public void m1() {
        //创建 B 对象, 然后在调用方法即可
        System.out.println("m1() 方法被调用");
        B b = new B();
        b.hi();
        System.out.println("m1() 继续执行:)");
    }
}
class B {
    public void hi() {
        System.out.println("B 类中的 hi()被执行");
    }
}

⭐️成员方法传参机制⭐️

方法的传参机制对我们今后的编程非常重要，一定要搞的清清楚楚明明白白。

1. 基本数据类型的传参机制：
📚案例：

public class MethodParameter01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //创建 AA 对象 名字 obj
        AA obj = new AA();
        obj.swap(a, b); //调用 swap
        System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
    }
}
class AA {
    public void swap(int a,int b){
        System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
        //完成了 a 和 b 的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
    }
}

📚重点关注下面的图：
在这里插入图片描述
结论：
基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参!
2. 引用数据类型的传参机制：

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
         //测试
         B b = new B();
         int[] arr = {1, 2, 3};
         b.test100(arr);//调用方法
         System.out.println(" main 的 arr 数组 ");
         //遍历数组
         for(int i = 0; i < arr.length; i++) {
         	System.out.print(arr[i] + "\t");
         }
         System.out.println();
    }
}
class Person {
    String name;
    int age;
}
class B {
    //可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
    public void test100(int[] arr) {
        arr[0] = 200;//修改元素
        //遍历数组
        System.out.println(" test100 的 arr 数组 ");
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

📚运行结果：

test100 的 arr 数组 
200	2	3	
main 的 arr 数组 
200	2	3

📚结论：
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！（这里可以参考之前的数组）
📚示意图：
在这里插入图片描述

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        System.out.println("main 的 p.age=" + p.age);//10000
    }
}
class Person {
    String name;
    int age;
}
class B {
    public void test200(Person p) {
        p.age = 10000; //修改对象属性
    }
}

📚运行结果：

main 的 p.age=10000

📚示意图：
在这里插入图片描述

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        System.out.println("main 的 p.age=" + p.age);//10
    }
}
class Person {
    String name;
    int age;
}
class B {
    public void test200(Person p) {
        p = new Person();
        p.name = "tom";
        p.age = 99;
    }
}

📚运行结果：

main 的 p.age=10

📚示意图：
在这里插入图片描述
📚结论：
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

📚思考题：

思考以下代码的输出值：

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);
        System.out.println("main 的 p.age=" + p.age);//10
    }
}
class Person {
    String name;
    int age;
}
class B {
    public void test200(Person p) {
        p=null;
    }
}

有很多人的答案可能是：异常，我可以告诉你，你做错了！
正确答案是：10。

为什么呢？
大家可以先看下面的示意图：在这里插入图片描述
在上面的示意图中，主栈最开始是有一个p的，它指向一个对象，调用了b.test( p )，这样会开辟一个新的空间，新空间中的p也会指向同一个对象，p=null表示此时新空间中的p不再指向对象，而主方法中的p依旧指向之前的对象，所以输出p.age时输出的依旧是10。

⭐️成员方法返回类型是引用类型应用实例⭐️

看下面代码：

public class MethodExercise02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "milan";
        p.age = 100;
        //创建 tools
        MyTools tools = new MyTools();
        Person p2 = tools.copyPerson(p);
        //到此 p 和 p2 是 Person 对象，但是是两个独立的对象，属性相同
        System.out.println("p 的属性 age=" + p.age + " 名字=" + p.name);
        System.out.println("p2 的属性 age=" + p2.age + " 名字=" + p2.name);
       //提示:可以同对象比较看看是否为同一个对象
        System.out.println(p == p2);//false
    }
}
class Person {
    String name;
    int age;
}
class MyTools {
    //编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象，
    //注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
    //
    //编写方法的思路
    //1. 方法的返回类型 Person
    //2. 方法的名字 copyPerson
    //3. 方法的形参 (Person p)
    //4. 方法体, 创建一个新对象，并复制属性，返回即可
    public Person copyPerson(Person p) {
        //创建一个新的对象
        Person p2 = new Person();
        p2.name = p.name; //把原来对象的名字赋给 p2.name
        p2.age = p.age; //把原来对象的年龄赋给 p2.age
        return p2;
    }
}

📚运行结果：

p 的属性 age=100 名字=milan
p2 的属性 age=100 名字=milan
false

📚示意图：
在这里插入图片描述

⭐️方法递归调用(非常非常重要，比较难)⭐️

简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。

⭐️递归能解决什么问题?

在这里插入图片描述

⭐️递归举例

列举两个小案例,来帮助大家理解递归调用机制
1. 打印问题
2. 阶乘问题

public class Recursion01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        T t1 = new T();
        t1.test(4);//输出什么？ n=2 n=3 n=4
        int res = t1.factorial(5);
        System.out.println("5 的阶乘 res =" + res);
    }
}
class T {
    //分析
    public void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }
    //factorial 阶乘
    public int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }
}

📚打印问题示意图：
在这里插入图片描述
📚阶乘问题示意图：

📚练习
1. 斐波那契数
请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13…给你一个整数 n，求出它的值是多少。

public class RecursionExercise01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        T1 t1 = new T1();
         int n = 7;
         int res = t1.fibonacci(n);
         if(res != -1) {
         System.out.println("当 n="+ n +" 对应的斐波那契数=" + res);
         }
    }
}
class T1 {
    /*
    请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 n，求出它的值是多
    思路分析
    1. 当 n = 1 斐波那契数 是 1
    2. 当 n = 2 斐波那契数 是 1
    3. 当 n >= 3 斐波那契数 是前两个数的和
    4. 这里就是一个递归的思路
    */
    public int fibonacci(int n) {
        if( n >= 1) {
            if( n == 1 || n == 2) {
                return 1;
            } else {
                return fibonacci(n-1) + fibonacci(n-2);
            }
        } else {
            System.out.println("要求输入的 n>=1 的整数");
            return -1;
        }
    }
}

2. 猴子吃桃子问题：
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，想再吃时（即还没吃），发现只有 1 个桃子了。问题：最初共多少个桃子？

public class RecursionExercise01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        T1 t1 = new T1();
        //桃子问题
        int day = 0;
        int peachNum = t1.peach(day);
        if(peachNum != -1) {
            System.out.println("第 " + day + "天有" + peachNum + "个桃子");
        }
    }
}
class T1 {
    /*
    猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
    以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，
    想再吃时（即还没吃），发现只有 1 个桃子了。问题：最初共多少个桃子？
    思路分析 逆推
    1. day = 10 时 有 1 个桃子
    2. day = 9 时 有 (day10 + 1) * 2 = 4
    3. day = 8 时 有 (day9 + 1) * 2 = 10
    4. 规律就是 前一天的桃子 = (后一天的桃子 + 1) *2//就是我们的能力
    5. 递归
    */
    public int peach(int day) {
        if(day == 10) {//第 10 天，只有 1 个桃
            return 1;
        } else if ( day >= 1 && day <=9 ) {
            return (peach(day + 1) + 1) * 2;//规则，自己要想
        } else {
            System.out.println("day 在 1-10");
            return -1;
        }
    }
}

⭐️方法重载(OverLoad)⭐️

📚重载的好处

1. 减轻了起名的麻烦
2. 减轻了记名的麻烦

📚重载练习

📚案例

public class OverLoad01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        // System.out.println(100);
        // System.out.println("hello,world");
        // System.out.println('h');
        // System.out.println(1.1);
        // System.out.println(true);
        //
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}
class MyCalculator {
    //下面的四个 calculate 方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }
    //没有构成方法重载, 仍然是错误的，因为是方法的重复定义
    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }
    //看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }
    //一个整数，一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }
    //一个 double ,一个 Int 和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }
    //三个 int 的和
    public int calculate(int n1, int n2,int n3) {
        return n1 + n2 + n2;
    }
}

📚注意事项和使用细节

方法名：必须相同
形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
返回类型:无要求

📚练习
判断题:

void show(int a,char b,double c)构成重载的有:
void show(int x.char y,double z)()//不是
int show(int a,double c.char b)()//是
void show(int a,double c.char b)()//是
boolean show(int c,char b)()//是
void show(double c)()//是
double show(int x.char y,double z)()//不是
void shows()//不是

⭐️可变参数⭐️

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

📚基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {
}

📚快速入门案例

public class VarParameter01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100)); //106
        System.out.println(m.sum(1,19)); //20
    }
}
class HspMethod {
    //可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。
    //可以使用方法重载
    // public int sum(int n1, int n2) {//2 个数的和
    // return n1 + n2;
    // }
    // public int sum(int n1, int n2, int n3) {//3 个数的和
    // return n1 + n2 + n3;
    // }
    // public int sum(int n1, int n2, int n3, int n4) {//4 个数的和
    // return n1 + n2 + n3 + n4;
    // }
    //..... //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
    //解读
    //1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
    //2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
    //3. 遍历 nums 求和即可
    public int sum(int... nums) {
    //System.out.println("接收的参数个数=" + nums.length);
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

📚注意事项和使用细节

1. 可变参数的实参可以为0个或任意多个。
2. 可变参数的实参可以为数组。
3. 可变参数的本质就是数组.
4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5. 一个形参列表中只能出现一个可变参数

public class VarParameterDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
       //细节: 可变参数的实参可以为数组
        int[] arr = {1, 2, 3};
        T t1 = new T();
        t1.f1(arr);
    }
}
class T {
    public void f1(int... nums) {
        System.out.println("长度=" + nums.length);
    }
    //细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {
    }
    //细节: 一个形参列表中只能出现一个可变参数
    //下面的写法是错的. // public void f3(int... nums1, double... nums2) {
    // }
}

⭐️作用域⭐️

面向对象中，变量作用域是非常重要知识点，相对来说不是特别好理解，请大家注意，认真思考，要求深刻掌握变量作用域。

1. 在java编程中，主要的变量就是属性(成员变量)和局部变量。
2. 我们说的局部变量一般是指在成员方法中定义的变量。
3. java中作用域的分类
全局变量:也就是属性，作用域为整个类体Cat类:cry eat等方法使用属性;
局部变量:也就是除了属性之外的其他变量，作用域为定义它的代码块中!
4. 全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，
才能使用，因为没有默认值。

public class VarScope {
    //编写一个 main 方法
    public static void main(String[] args) {
    }
}
class Cat {
    //全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
    //属性在定义时，可以直接赋值
    int age = 10; //指定的值是 10
    //全局变量(属性)可以不赋值，直接使用，因为有默认值，
    double weight; //默认值是 0.0
    public void hi() {
        //局部变量必须赋值后，才能使用，因为没有默认值
        int num = 1;
        String address = "北京的猫";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);//属性
    }
    public void cry() {
        //1. 局部变量一般是指在成员方法中定义的变量
        //2. n 和 name 就是局部变量
        //3. n 和 name 的作用域在 cry 方法中
        int n = 10;
        String name = "jack";
        System.out.println("在 cry 中使用属性 age=" + age);
    }
    public void eat() {
        System.out.println("在 eat 中使用属性 age=" + age);
        //System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
    }
}

📚注意事项和细节使用

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名.
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变
量,生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁.即在一次方法调用过程中。
作用域范围不同
全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)局部变量:只能在本类中对应的方法中使用
修饰符不同
全局变量/属性可以加修饰符局部变量不可以加修饰符

📚举例：

public class VarScopeDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        Person p1 = new Person();
        /*
        属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
        局部变量，生命周期较短，伴随着它的代码块的执行而创建，
        伴随着代码块的结束而销毁。即在一次方法调用过程中
        */
        //p1.say();//当执行 say 方法时，say 方法的局部变量比如 name,会创建，当 say 执行完毕后
        //name 局部变量就销毁,但是属性(全局变量)仍然可以使用
        //
        T t1 = new T();
        t1.test(); //第 1 种跨类访问对象属性的方式
        t1.test2(p1);//第 2 种跨类访问对象属性的方式
    }
}
class T {
    //全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
    public void test() {
        Person p1 = new Person();
        p1.say();//say() name=king
        System.out.println(p1.name);//jack
    }
    public void test2(Person p) {
        System.out.println(p.name);//jack
    }
}
class Person {
    //细节: 属性可以加修饰符(public protected private..)
    // 局部变量不能加修饰符
    public int age = 20;
    String name = "jack";
    public void say() {
        //细节 属性和局部变量可以重名，访问时遵循就近原则
        String name = "king";
        System.out.println("say() name=" + name);
    }
    public void hi() {
        String address = "北京";
        //String address = "上海";//错误,重复定义变量
        String name = "hj";//可以
    }
}

📚运算结果：

say() name=king
jack
jack

⭐️构造方法(构造器)⭐️

📚我们来看一个需求：

前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

📚基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
1. 方法名和类名相同
2. 没有返回值
3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

📚基本语法

[修饰符] 方法名(形参列表){
方法体;
}

📚说明

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成

📚入门案例

public class Constructor01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        //当我们 new 一个对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person("smith", 80);
        System.out.println("p1 的信息如下");
        System.out.println("p1 对象 name=" + p1.name);//smith
        System.out.println("p1 对象 age=" + p1.age);//80
    }
}
//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
    String name;
    int age;
    //构造器
    //1. 构造器没有返回值, 也不能写 void
    //2. 构造器的名称和类 Person 一样
    //3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
    public Person(String pName, int pAge) {
        System.out.println("构造器被调用~~ 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}

☕️运行结果：

构造器被调用~~ 完成对象的属性初始化
p1 的信息如下
p1 对象 name=smith
p1 对象 age=80

📚注意事项和使用细节

📒一个类可以定义多个不同的构造器，即构造器重载
比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名,不需要指定年龄
📒构造器名和类名要相同
📒构造器没有返回值
📒构造器是完成对象的初始化.并不是创建对象
📒在创建对象时,系统自动的调用该类的构造方法
📒如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如 Dog(){},使用javap指令反编译看看
📒一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下,即:Dog(){} 写(这点很重要)

public class ConstructorDetail {
    //编写一个 main 方法
    public static void main(String[] args) {
        Person p1 = new Person("king", 40);//第 1 个构造器
        Person p2 = new Person("tom");//第 2 个构造器
        Dog dog1 = new Dog();//使用的是默认的无参构造器
    }
}
class Dog {
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
    //使用 javap 指令 反编译看看
    /*
    默认构造器
    Dog() {
    }
    */
    //一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
    //除非显式的定义一下,即: Dog(){} 写 (这点很重要)
    //
    public Dog(String dName) {
    //...
    }
    Dog() { //显式的定义一下 无参构造器
    }
}
class Person {
    String name;
    int age;//默认 0
    //第 1 个构造器

    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
    //第 2 个构造器, 只指定人名，不需要指定年龄
    public Person(String pName) {
        name = pName;
    }
}

⭐️对象创建的流程分析(重点)⭐️

大家先看一个案例：

class Person{//类Person
	int age=90;
	String name;
	Person(String n,int a)//构造器
		name=n;//给属性赋值
		age=a;//..
	}
}
Person p=new Person(“小倩"，20);

大家想一想这个对象创建的流程图是什么(面试题)？
📚答案：
在这里插入图片描述

⭐️this 关键字⭐️

📚什么是this

java虚拟机会给每个对象分配this，代表当前对象。

📚使用this解决前面变量命名问题

public class This01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        Dog dog1 = new Dog("大壮", 3);
        System.out.println("dog1 的 hashcode=" + dog1.hashCode());
        //dog1 调用了 info()方法
        dog1.info();
        System.out.println("============");
        Dog dog2 = new Dog("大黄", 2);
        System.out.println("dog2 的 hashcode=" + dog2.hashCode());
        dog2.info();
    }
}
class Dog{ //类
    String name;
    int age;
    // public Dog(String dName, int dAge){//构造器
    // name = dName;
    // age = dAge;
    // }
    //如果我们构造器的形参，能够直接写成属性名，就更好了
    //但是出现了一个问题，根据变量的作用域原则
    //构造器的 name 是局部变量，而不是属性
    //构造器的 age 是局部变量，而不是属性
        //==> 引出 this 关键字来解决
    public Dog(String name, int age){//构造器
        //this.name 就是当前对象的属性 name
        this.name = name;
        //this.age 就是当前对象的属性 age
        this.age = age;
        System.out.println("this.hashCode=" + this.hashCode());
    }
    public void info(){//成员方法,输出属性 x 信息
        System.out.println("this.hashCode=" + this.hashCode());
        System.out.println(name + "\t" + age + "\t");
    }
}

运行结果：

this.hashCode=460141958
dog1 的 hashcode=460141958
this.hashCode=460141958
大壮	3	
============
this.hashCode=1163157884
dog2 的 hashcode=1163157884
this.hashCode=1163157884
大黄	2

分析：
Dog类构造器

public Dog(String name, int age){//构造器
        this.name = name;
        this.age = age;
    }

其中：this.name 就是当前对象的属性 name，this.age 就是当前对象的属性 age

📚深入理解 this

上面的案例可以用这个图表示，大家要非常的注意！！！
在这里插入图片描述
📚小结:
简单的说,哪个对象调用，this就代表哪个对象。

📚this的注意事项和使用细节

📒 this 关键字可以用来访问本类的属性、方法、构造器；
📒this 用于区分当前类的属性和局部变量；
📒访问成员方法的语法：this.方法名(参数列表);
📒访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)；
📒 this 不能在类定义的外部使用，只能在类定义的方法中使用。

📒 this 关键字可以用来访问本类的属性、方法、构造器；

public class Detail {
    public static void main(String[] args) {
        T t1=new T();
        t1.f1();
    }
}
class T{
    // this 关键字可以用来访问本类的属性、方法、构造器
    String name = "jack";
    int age = 10;
    public void f1(){
        String name="smith";
        //传统方式
        System.out.println("name=" + name + ",age=" + age);
        //也可以使用this
        System.out.println("name=" + this.name + ",age=" + this.age);
    }
}

传统方式会有就近原则即优先考虑局部变量。

📒访问成员方法的语法：this.方法名(参数列表)

public class Detail {
    public static void main(String[] args) {
        T t1=new T();
        t1.f2();
    }
}
class T{
    //访问成员方法的语法：this.方法名(参数列表)
    public void f1(){
        System.out.println("f1()方法..");
    }
    public void f2(){
        System.out.println("f2()方法..");
        //调用本类的f1
        //第一种方式
        f1();
        //第二种方式
        this.f1();
    }
}

运行结果：

f2()方法..
f1()方法..
f1()方法..

📒访问构造器语法：this(参数列表)

public class Detail {
    public static void main(String[] args) {
        T t1=new T();
    }
}
class T{
    //访问构造器语法：this(参数列表);
    public T(){
        this("jack",10);//注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句
        System.out.println("T()构造器");
    }
    public T(String name,int age){
        System.out.println("T(String name,int age)构造器");
        System.out.println("name:"+name+",age:"+age);
    }
}

运行结果：

T(String name,int age)构造器
name:jack,age:10
T()构造器

这里注意：
this("jack",10);在构造器中访问另外一个构造器时, this语句必须放在第一条语句

 public T(){
        this("jack",10);//注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句
        System.out.println("T()构造器");
    }

如果像下面这样就会报错

 public T(){
        System.out.println("T()构造器");
         this("jack",10);
    }

在这里插入图片描述

📚练习

定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，用于判断是否和另一个人相等，提供测试类 TestPerson用于测试, 名字和年龄完全一样，就返回 true, 否则返回 false

答案：

public class TestPerson {
    //编写一个 main 方法
    public static void main(String[] args) {
        Person p1 = new Person("mary", 20);
        Person p2 = new Person("mary", 20);
        System.out.println("p1 和 p2 比较的结果=" + p1.compareTo(p2));
    }
}
class Person {
    String name;
    int age;
    //构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //compareTo 比较方法
    public boolean compareTo(Person p) {
        //名字和年龄完全一样
        // if(this.name.equals(p.name) && this.age == p.age) {
        // return true;
        // } else {
        // return false;
        // }
        return this.name.equals(p.name) && this.age == p.age;
    }
}