⭐️类与对象⭐️

📚首先看一个养猫猫问题

张老太养了两只猫猫:一只名字叫小白,今年 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; //体重
//行为
}

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

📚类与对象的关系示意图

说明：

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

📚类和对象的区别和联系

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

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

📚属性/成员变量/字段

☕️从概念或叫法上看： 成员变量 = 属性 = 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 nullSystem.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;

⭐️成员方法⭐️

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

📚成员方法快速入门

1. 添加 speak 成员方法,输出 “我是一个好人”；
2. 添加 cal01 成员方法,可以计算从 1+…+1000 的结果；
3. 添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+…+n 的结果；
4. 添加 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 = 5p1.cal02(10); //调用 cal02 方法，同时给 n = 10//调用 getSum 方法，同时 num1=10, num2=20//把 方法 getSum 返回的值，赋给 变量 returnResint 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

📚成员方法的好处

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

📚成员方法的定义

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

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

📚注意事项和使用细节

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

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

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

1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如getSum(int n1,int n2)
2. 参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[][] map)
3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!【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 ;}
}

📒方法调用细节说明

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

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 对象 名字 objAA obj = new AA();obj.swap(a, b); //调用 swapSystem.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;//创建 toolsMyTools 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.namep2.age = p.age; //把原来对象的年龄赋给 p2.agereturn p2;}
}

📚示意图：