⭐️类与对象⭐️
📚首先看一个养猫猫问题
📚使用现有技术解决
📚现有技术解决的缺点分析
☕️单独的定义变量解决:不利于数据的管理
//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
//第 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)
☕️代码如下:
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
- 对象就是一个具体的实例,
📚类和对象的区别和联系
☕️类是抽象的,概念的,代表一类事物,比如人类,猫类…, 即它是数据类型;
☕️对象是具体的,实际的,代表一个具体事物, 即是实例;
☕️ 类是对象的模板,对象是类的一个个体,对应一个实例。
⭐️对象在内存中存在形式(重要!!!)
📚属性/成员变量/字段
📚 注意事项和细节
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;
}
}
为什么呢?
大家可以先看下面的示意图:
在上面的示意图中,主栈最开始是有一个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;
}
}
📚示意图: