类与对象
引入
看一个养猫猫问题:
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序,当用户 输入小猫的名字时,就显示该猫的名字,年龄,颜色。如果用户输入的小猫名错误,则显示 张老太没有这只猫猫
- 使用现有技术解决
- 单独的定义变量解决
- 使用数组解决
public class Object {
//编写一个main方法
public static void main(String[] args) {
//张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
//还有一只叫小花,今年 100 岁,花色。请编写一个程序,
//当用户 输入小猫的名字时,就显示该猫的名字,年龄,颜色。
//如果用户输入的小猫名错误,则显示 张老太没有这只猫猫
//1. 单独变量来解决 - 不利于数据的噶案例
第一只猫
String cat1Name = "小白";
int cat1Age = 3;
String cat1Color = "白色";
//第二只猫
String cat2Name = "小花";
int cat2Age = 100;
String cat2Color = "花色";
//2. 数组 - 数据类型体现不出来
// 只能通过[下标]来获取信息,造成变量名字和内容的对应关系不明确
// 不能体现猫的行为
String[] cat1 = {"小白", "3", "白色"};
String[] cat2 = {"小花", "100", "花色"};
}
}
- 现有技术解决的缺点分析
- 不利于数据的管理
- 效率低
java 设计者 引入 类与对象(OOP),根本原因就是现有的技术,不能玩么的解决新的需求
public class Object {
//编写一个main方法
public static void main(String[] args) {
//张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
//还有一只叫小花,今年 100 岁,花色。请编写一个程序,
//当用户 输入小猫的名字时,就显示该猫的名字,年龄,颜色。
//如果用户输入的小猫名错误,则显示 张老太没有这只猫猫
//使用oop面向对象来解决
//实例化一只猫(创建一只猫对象)
//new Cat() : 创建一只猫
//Cat cat1 = new Cat() :把创建的猫赋给cat1
//cat1 就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
cat1.weight = 10;
//创建了第二只猫,并赋给cat2
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
cat2.weight = 20;
//怎么使用 - 怎么访问对象的属性
System.out.println("第一只猫信息" + cat1.name + " " + cat1.age + " " + cat1.color + " " + cat1.weight);
System.out.println("第二只猫信息" + cat2.name + " " + cat2.age + " " + cat2.color + " " + cat2.weight);
}
}
//使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat - 自定义的数据类型
class Cat {
//属性
String name;//名字
int age;//年龄
String color;//颜色
double weight;//体重
}
类与对象的关系示意图
类和对象的区别和联系
- 类是抽象的,概念的,代表一类事物,比如人类,猫类…,即它是数据类型
- 对象是具体的,实际的,代表一个具体事物,即是实例
- 类的对象的模板,对象是类的一个个体,对应一个实例
对象在内存中的存在形式(重点!必须搞懂)
- 字符串是引用类型,存放在方法区的常量池,并且在堆区上存的是地址
- 基本数据类型都存储在堆上
属性/成员变量/字段
基本介绍
- 从概念上或叫法上看:成员变量 = 属性 = field(字段) (即成员变量是用来表示属性的)
- 属性是类的一个组成部分,一般是基本数据类型,也可以是引用类型(对象、数组)。比如前面定义猫类的 int age 就是属性
public class Object02 {
//编写一个main方法
public static void main(String[] args) {
}
}
class Car {
//访问修饰符
protected String name;//属性,成员变量,字段field
double price;
String color;
String[] master; //属性可以是基本数据类型,也可以是引用类型(对象、数组)
}
属性的注意事项和细节说明
- 属性的定义语法同变量,例:访问修饰符 属性类型 属性名;
简单介绍访问修饰符:控制属性的访问范围
有四种访问修饰符:public、protected、默认、private
- 属性的定义类型可以为任意类型,包含基本类型或引用类型
- 属性如果不赋值,有默认值,规则和数组一致:int 0,short 0,byte 0,long 0,float 0.0,double 0.0,char \u0000,boolean false,String null
public class PropertiesDetail {
//编写一个main方法
public static void main(String[] args) {
//创建Person对象
//p1 - 对象名(对象引用)
//new Person() 创建的对象空间(数据) 才是真正的对象
Person p1 = new Person();//p1只是指向这个对象,真正的对象是开辟出来的
//对象的属性默认值,遵守数组规则
System.out.println("当前这个人的信息");
System.out.println("age=" + p1.age);
System.out.println("name=" + p1.name);
System.out.println("sal=" + p1.sal);
System.out.println("isPass=" + p1.isPass);
}
}
class Person {
int age;
String name;
double sal;
boolean isPass;
}
如何创建对象
- 先声明再创建
Cat cat;//声明对象 cat
cat = new Cat();//创建
- 直接创建
Cat cat = new Cat();
如何访问属性
基本语法:
对象名.属性名;
类和对象的内存分配机制(重要):
类与对象的内存分配机制(重点)
- Java内存的结构分析
- 栈:一般存放基本数据类型(局部变量)
- 堆:存放对象(Cat cat,数组等)
- 方法区:常量池(常量,比如字符串),类加载信息
- Java创建对象的流程简单分析
Person p = new Person();p.name = “jack”;p.age = 10;
解读:
- 先加载 Person 类信息(属性和方法信息,只会加载一次)
当再创建一个对象的时候,将不会再加载
- 在堆中分配空间,进行默认初始化(看规则)
- 把地址赋给 p,p就指向对象
- 进行指定初始化,比如:p.name = “jack”; p.age = 10;
成员方法
基本介绍
- 在某些情况下,我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄,姓名…),我们人类还有一 些行为比如:可以说话、跑步…,通过学习,还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善
public class Method01 {
//编写一个main方法
public static void main(String[] args) {
//方法使用
//1. 方法写好后,如果不去调用(使用),不会生效输出语句
//2. 先创建一个对象,然后调用其方法
Person p1 = new Person();
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 Person {
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 sum1, int sum2) 形参列表,有2个形参,可以接受用户传入的两个数
//5. return res 表示把 res 的值,返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}
方法的调用机制原理(重要!示意图)
- [getSum]示意图+说明
- 注意:当返回以后,开辟出来的独立空间就会被销毁
- 而整个程序退出,就全部被销毁了
为什么需要成员方法
public class Method02 {
//编写一个main方法
public static void main(String[] args) {
//看一个需求: 请遍历一个数组 , 输出数组的各个元素值
int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
//使用方法完成输出
MyTools tools = new MyTools();
//遍历map数组
//传统的解决方法就是直接遍历
// for (int i = 0; i < map.length; i++) {
// for (int j = 0; j < map[i].length; j++) {
// System.out.println(map[i][j] + " ");
// }
// System.out.println();
// }
//使用方法
tools.printArr(map);
//要求再次遍历map数组
//复制粘贴一份
// for (int i = 0; i < map.length; i++) {
// for (int j = 0; j < map[i].length; j++) {
// System.out.println(map[i][j] + " ");
// }
// System.out.println();
// }
tools.printArr(map);
}
}
//把输出的功能,写到一个类的方法中,然后调用该方法揭开
class MyTools {
//方法,接受一个二维数组
public void printArr(int[][] map) {
System.out.println("=========");
//对传入的map数据
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}
- 使用传统的方法,每次都要复制粘贴同一份代码,并且如果做修改,每一份都要修改,这就使得代码冗余太高
- 成员方法的好处
- 提高代码的复用性
- 可以将实现的细节封装起来,然后供其他用户来调用即可
成员方法的定义
访问修饰符 返回数据类型 方法名(形参列表…){//方法体
语句:
return 返回值;
}
- 形参列表:表示成员方法输入,如 cat(int n), getSum(int num1, int num2)
- 返回数据类型:表示成员方法输出,void表示没有返回值
- 方法主体:表示为了实现某一功能代码块
- return 语句不是必须的
注意事项和使用细节
访问修饰符(作用是控制方法使用的范围)
- 如果不写则默认访问,(有四种:public、protected、默认、private)
返回数据类型
- 一个方法最多有一个返回值 [思考:如何返回多个结果 - 返回数组]
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
//1. 一个方法最多有一个返回值 [思考,如何返回多个结果 - 返回数组 ]
AA a = new AA();
int[] res = a.getSumAndSub(1, 4);
System.out.println("和=" + res[0]);
System.out.println("差=" + res[1]);
}
}
class AA {
//1. 一个方法最多有一个返回值 [思考,如何返回多个结果 - 返回数组 ]
public int[] getSumAndSub(int n1, int n2) {
int[] resArr = new int[2];//创建一个数组
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}
- 返回类型可以为任意类型,包含基本类型或引用类型(数组、对象)
- 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
}
}
class AA {
//3) 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为 return 值;
//而且要求返回值类型必须和 return 的 值类型一致或兼容
//
public double f1() {
//error
}
}
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
}
}
class AA {
//3) 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为 return 值;
//而且要求返回值类型必须和 return 的 值类型一致或兼容
//
//public double f1() {
public int f1() {//error
double d1 = 1.1 * 3;
int n = 100;
//return n; //ok int->double
return d1;
}
}
- 如果方法是void,则方法体中可以没有 return 语句,或者只写 return;
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
}
}
class AA {
//4) 如果方法是 void,则方法体中可以没有 return 语句,或者 只写 return ,注意,不能写值;
public void f2() {
System.out.println("Hello01");
System.out.println("Hello01");
System.out.println("Hello01");
return;
}
//方法名 遵循驼峰命名法,最好见名知义,表达出该功能的意思即可,
//比如 得到两个数的和 getSum, 开发中按照规范
//最好是见名之意
}
方法名:
- 遵循驼峰命名法,最好见名知义,表达出该功能的意思即可,比如得到两个数的和 getSum,开发中按照规范
形参列表
- 一个方法可以有0个参数,也可以有多个参数,中间用逗号隔开,比如:getSum(int n1, int n2)
- 参数类型可以为任意类型,包含基本类型或引用类型,比如:printArr(int[][] map)
- 调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
//细节:调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数
byte b1 = 1;
byte b2 = 2;
a.getSumAndSub(b1, b2);//ok byte -> int
a.getSumAndSub(1.1, 1.8);//error double -> int
}
}
class AA {
public int[] getSumAndSub(int n1, int n2) {
int[] resArr = new int[2];//创建一个数组
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}
- 方法定义时的参数称为形式参数,简称形参:方法调用时的传入参数称为实际参数,简称实参,实参和形参的类型要一致或兼容、个数、顺序必须一致
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
//细节:形参和实参的类型要一致或兼容、个数、顺序必须一致
// a.getSumAndSub(100);//error
//a.getSumAndSub(1.1, 1);//error 实际参数和形式参数顺序不同
}
}
class AA {
public int[] getSumAndSub(int n1, int n2) {
int[] resArr = new int[2];//创建一个数组
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}
方法体:
- 里面写完成功能的具体的语句,可以为输入、输出、变量、运算、分支、循环、方法调用,但里面不能再定义方法!:即****方法不能嵌套定义
public class MethodDetail {
//编写一个main方法
public static void main(String[] args) {
}
}
class AA {
//细节:方法不能嵌套定义
public void f4() {
public void f5() {
}
}
}
方法调用细节说明
- 同一个类中的方法调用:直接调用即可。比如 print(参数);
public class MethodDetail02 {
//编写一个main方法
public static void main(String[] args) {
A a = new A();
a.sayOk();
}
}
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 class MethodDetail02 {
//编写一个main方法
public static void main(String[] args) {
A a = new A();
// a.sayOk();
a.m1();
}
}
class A {
//跨类中的方法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() 被执行");
}
}
- 特别说明:跨类的方法调用和方法的访问修饰符相关,后细说
类定义的完善
成员方法传参机制
基本数据类型的传参机制
public class MethodParameter01 {
//编写一个main方法
public static void main(String[] args) {
//创建AA对象aa
AA aa = new AA();
int a = 10;
int b = 20;
aa.swap(a, b);
System.out.println("a=" + a + " b=" + b);
}
}
class AA {
public void swap(int a, int b) {
System.out.println("\na和b交换前的值\na=" + a + " b=" + b);
//完成a和b的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + " b=" + b);
}
}
- 之后自己画
引用数据类型的传参机制
- 引用类型传递的是地址(传递也是值,但是值是地址),可以通过形参影响实参
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] + " ");
}
System.out.println();
}
}
class Person {
String name;
int age;
}
class B {
//B 类中编写一个方法 test100,可以接收一个数组,
//在方法中修改该数组,看看原来的数组是否变化?
//会变化
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] + " ");
}
System.out.println();
}
}
- 自己画
public class MethodParameter02 {
//编写一个main方法
public static void main(String[] args) {
//测试
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test200(p);
//测试题,如果test200执行的是p = null ,下面的结果是 10;
//测试题,如果test200执行的是p = new Person().... ,下面的结果是 10;
System.out.println("main的p.age=" + p.age);
}
}
class Person {
String name;
int age;
}
class B {
//B 类中编写一个方法 test200,可以接收一个 Person(age,sal)对象,
//在方法中修改该对象属性,看看原来的对象是否变化?
//会变化
public void test200(Person p) {
p.age = 10000;//修改对象属性
}
}
- 思考题:p = null 和 p = new Person
- 只是将p给置空了,跟对象没有任何关系,因此不会受到影响
成员方法返回类型是引用类型应用实例
- \1. 编写类MyTools类,编写一个方法可以打印二维数组的数据
- \2. 编写一个方法copyPerson,可以复制一个PErson对象,返回复制的对象,克隆对象,注意要求得到新对象和原来的对象是两个独立的对象,只是他们的属性相同
public class MethodExercise02 {
//编写一个main方法
public static void main(String[] args) {
//1) 编写类 MyTools 类,编写一个方法可以打印二维数组的数据。
//2) 编写一个方法 copyPerson,可以复制一个 Person 对象,
//返回复制的对象。克隆对象,
//注意要求得到新对象和原来的 对象是两个独立的对象,只是他们的属性相同
Person p = new Person();
p.name = "jack";
p.age = 20;
//创建一个Mytools对象
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 {
//克隆
//编写方法的思路
//1. 方法的返回类型 Person
//2. 方法名 copyPerson
//3. 方法的形参 (Person p)
//4. 方法体 :创建一个新对象并复制属性,返回即可
public Person copyPerson(Person p) {
//创建一个新的对象
Person p2 = new Person();
//复制内容
p2.name = p.name;
p2.age = p.age;
return p2;
}
}
方法递归调用(重要,难)
基本介绍
- 递归就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂问题,同时可以让代码变得简洁
递归能解决各种问题:
- 各种数学问题如:八皇后问题,汉诺塔,阶乘问题,迷宫问题,球和篮子问题
- 各种算法中也会使用到递归,比如快排,归并排序,二分查找,分治算法
- 将用栈解决的问题–>递归代码比较简洁
- 递归举例
- 打印问题
- 阶乘问题
public class Recursion01 {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
t1.test(4);
}
}
class T {
//分析
public void test(int n) {
if (n > 2) {
test(n - 1);
}
System.out.println("n = " + n);
}
}
public class Recursion02 {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
// t1.test(4);
int res = t1.factorial(5);
System.out.println(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;
}
}
}
递归重要规则
- 执行一个方法时,就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立****的,不会相互影响,比如n变量
- 如果方法中使用的是引用类型变量(比如数组、对象),就会****共享该引用类型的数据
- 递归必须向退出递归的条件逼近,否则就是无限递归,出现StackOverflowError,死龟了
- 当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕
练习题
- 请使用递归的方式求出斐波那契数1,1,2,3,5,8,13…给你一个整数n,求出它的值是多少
public class RecursionExercise01 {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
int n = 7;
int res = t1.Fibonacci(n);
if (res != -1) {
System.out.println("当n= " + n + "对应的斐波那契数=" + res);
}
}
}
class T {
//请使用递归的方式求出斐波那契数1,1,2,3,5,8,13
//给一个整数n,求出值
//思路
//1. 当n = 1 ,值为1
//2. 当n = 2 ,值为1
//3. 当n >= 3, 值为前两个数之和
//递归的思路
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;
}
}
}
- 猴子吃桃子问题,有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个!以后每天猴子都吃其中的一半,然后再多吃一个,当到第10天时,想再吃时(即还没吃),发现只有1个桃子了,问题:最初共多少个桃子
public class RecursionExercise02 {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
int day = 8;
int res = t1.peach(day);
if (res != -1) {
System.out.println("第" + day + "天的桃子个数=" + res);
}
}
}
class T {
//猴子吃桃子问题:有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个!
//以后每天猴子都吃其中的一半,然后再多吃一个
//当到第10天时,想再吃时(即还没吃),发现只有1个桃子
//问:最初有多少个桃子
//思路
//1. 每天都吃一半,并多吃一个
//2. 最后吃到第10天的时候,没吃,但发现只有1个桃子了
//逆推
//day = 10 时,有 1 个桃子
//day = 9 时,有 4 个桃子 = (day10 + 1) * 2
//day = 8 时,有 10个桃子 = (day9 + 1) * 2
//规律就是 前一天的桃子 = (后一天的桃子数 + 1)* 2
public int peach(int day) {
if (day == 10) {//第10天 - 只有一个桃
return 1;
} else if (day >= 1 && day <= 9) {
return (peach(day + 1) + 1) * 2;
} else {
System.out.println("day在1-10");
return -1;
}
}
}
- 递归调用应用实例-迷宫问题
public class MiGong {
//编写一个main方法
public static void main(String[] args) {
//思路
//1. 先创建迷宫,用二维数组表示 int[][] map = new int[8][7];
//2. 先规定map数组的元素值:0 表示可以走 1 表示障碍物
int[][] map = new int[8][7];
//将最上面的一行和最下面的一行全部设置为1
for (int i = 0; i < 7; i++) {
map[0][i] = 1;
map[7][i] = 1;
}
//将最左边的一列和最右边的一列全部置为1
for (int i = 0; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
map[3][1] = 1;
map[3][2] = 1;
//测试回溯
//map[2][2] = 1;
//堵死
// map[2][1] = 1;
// map[2][2] = 1;
// map[1][2] = 1;
//输出当前的地图
System.out.println("===当前地图情况===");
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
//使用findWay给老鼠找路
T t1 = new T();
t1.findWay(map, 1, 1);
System.out.println("===找路的情况如下===");
//输出当前的地图
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}
class T {
//使用递归回溯的思想来解决老鼠出迷宫
//解读
//1. findWay方法就是专门来找出迷宫的路径
//2. 如果找到,就返回true,否则返回false
//3. map就是二维数组,即表示迷宫
//4. i 和 j 就是老鼠的位置,初始化的位置为(1, 1)
//5. 递归的走,要找到退出递归的条件,因此先规定 map数组的各个值的含义
// 0 表示可以走 1 表示障碍物 2 表示可以走的结果 3表示走过,但是是死路走不通
//6. 当 map[6][5] = 2 说明找到通路(就可以结束退出了),否则就继续找
//7. 先确定老鼠找路的策略 下->右->上->左
public boolean findWay(int[][] map, int i, int j) {
if (map[6][5] == 2) {//说明已经找到
return true;
} else {
if (map[i][j] == 0) {//当前整个位置0,说明可以走
//...
//假定可以走通
map[i][j] = 2;
//使用找路策略,来确定该位置是否真的可以走通
if (findWay(map, i + 1, j)) {//先走下
return true;
} else if (findWay(map, i, j + 1)) {//右
return true;
} else if (findWay(map, i - 1, j)) {//上
return true;
} else if (findWay(map, i, j - 1)) {//左
return true;
} else {
map[i][j] = 3;
return false;
}
} else {//map[i][j] == 1, 2, 3
return false;
}
}
}
}
- 递归调用应用实例-汉诺塔
public class HanoiTower {
//编写一个main方法
public static void main(String[] args) {
Tower tower = new Tower();
tower.move(2, 'A', 'B', 'C');
}
}
class Tower {
//方法
//num表示要移动的个数,a b c 分别表示 A塔 B塔 C塔
//题目就是要我们将柱子从A塔移动到C塔,中间可以借助B塔
//
public void move(int num, char a, char b, char c) {
//起始柱 借助柱 目标柱
//如果一个盘,num = 1
if (num == 1) {
System.out.println(a + "->" + c);
} else {
//如果有多个盘,可以看成两个,最下面的和上面的所有盘
//1. 先移动上面所有的盘到 b, 要借助c
//上面的盘都在A,所以小a为起始柱,将其移动到B,因此小b为目标柱,写在小c处
move(num - 1, a, c, b);
//2. 把最下面的这个盘,移动到c
System.out.println(a + "->" + c);
//3. 再把b塔的所有盘移到c,借助a塔
//移动一次后,上面的盘起始位置都在B了,因此小b为起始柱,移动到C,即小c为目标柱
move(num - 1, b, a, c);
}
}
}
方法重载
基本介绍
- Java 中允许同一个类中,多个同名方法的存在,但要求形参列表不一致
比如:System.out.println(); out 是PrintStream类型
- 重载的好处
- 减轻了起名的麻烦
- 减轻了记名的麻烦
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));//会自动匹配calculate
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) 被调用");
// return n1 + n2;
// }
public double calculate(int n1, double n2) {
return n1 + n2;
}
public double calculate(double n1, int n2) {
return n1 + n2;
}
public int calculate(int n1, int n2, int n3) {
System.out.println("calculate(int n1, int n2, int n3) 被调用");
return n1 + n2 + n3;
}
}
注意事项和使用细节
1)方法名:必须相同
2)形参列表:必须不同(形参类型或个数或顺序,至少有一样不同,参数名无要求)
3)返回类型:无要求
- 以上整个没有构成方法的重载,而是方法的重复定义
- 以上也不是重载
练习题
public class OverLoadExercise {
//编写一个main方法
public static void main(String[] args) {
Methods method = new Methods();
method.m(10);
method.m(10, 20);
method.m("Zan");
System.out.println(method.max(10, 24));
System.out.println(method.max(10.0, 24.2));
System.out.println(method.max(10.0, 24.2, 30));
}
}
class Methods {
//2.
//定义三个重载方法 max(),
//第一个方法,返回两个 int 值中的最大值,
//第二个方法,返回两个 double 值中的最大值,
//第三个方法,返回三个 double 值中的最大值,
//并分别调用三个方法
//分析
//1. 方法名 max
//2. 形参 (int int)
//3. int
public int max(int n1, int n2) {
return n1 > n2 ? n1 : n2;
}
public double max(double n1, double n2) {
return n1 > n2 ? n1 : n2;
}
public double max(double n1, double n2, double n3) {
//先求出n1 和 n2 的最大值
double max1 = n1 > n2 ? n1 : n2;
return max1 > n3 ? max1 : n3;
}
//1.
//编写程序,类 Methods 中定义三个重载方法并调用。方法名为 m。
//三个方法分别接收一个 int 参数、两个 int 参数、一个字符串参数。
//分别执行平方运算并输出结果, 相乘并输出结果,输出字符串信息。
//在主类的 main ()方法中分别用参数区别调用三个方法
//分析
//方法名 m
//形参 (int)
//void
public void m(int n) {
System.out.println("平方=" + (n * n));
}
public void m(int n1, int n2) {
System.out.println("相乘=" + (n1 * n2));
}
public void m(String str) {
System.out.println("传入的str=" + str);
}
}
可变参数
基本介绍
- Java 允许将同一个类中多个同名同功能但功能个数不同的方法,封装成一个方法,就可以通过可变参数实现
基本语法:
访问修饰符 返回类型 方法名(数据类型… 形参名) {
}
- 注意:这里的 … 就是语法规则
public class VarParameter01 {
//编写一个main方法
public static void main(String[] args) {
HspMethod m = new HspMethod();
System.out.println(m.sum());
System.out.println(m.sum(1, 5, 100));
}
}
class HspMethod {
//可以计算 2个数的和,3个数的和,4,5....
//可以使用方法重载
// public int sum(int n1, int n2) {
// return n1 + n2;
// }
// public int sum(int n1, int n2, int n3) {
// return n1 + n2 + n3;
// }
// public int sum(int n1, int n2, int n3, int n4) {
// 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;
}
}
注意事项和使用细节
- 可变参数的实参可以为0个或任意多个
- 可变参数的实参可以为数组
- 可变参数的本质就是数组
- 可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
- 一个形参列表中只能出现一个可变参数
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 f2(double... nums, String str) {
}
}
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) {//error
}
}
练习题
public class VarParameterExercise {
//编写一个main方法
public static void main(String[] args) {
HspMethod h = new HspMethod();
System.out.println(h.showScore("小米", 90.1, 80.0));
System.out.println(h.showScore("terry", 90.1, 80.0, 10, 30.5, 20));
}
}
class HspMethod {
//有三个方法,分别实现返回姓名和两门课成绩(总分),
//返回姓名和三门课成绩(总分),
//返回姓名和五门课成绩(总分)。
//封装成一个可变参数的方法
//分析
//1. 方法名 showScore
//2. 形参(String,double...)
//3. 返回String
public String showScore(String str, double... scores) {
double totalScore = 0;
for (int i = 0; i < scores.length; i++) {
totalScore += scores[i];
}
return str + "有" + scores.length + "这么多门课的成绩总分为=" + totalScore;
}
}
作用域
基本使用
- 面向对象中,变量作用域是非常重要的知识点,相对来说不是特别好理解
-
在Java编程中,主要的变量就是属性(成员变量)和局部变量
-
我们说的局部变量一般是指在成员方法中定义的变量,如:Cat类:cry
-
Java中作用域的分类
-
- 全局变量:也就是属性,作用域为整个类体 Cat类:cry eat 等方法使用属性
- 局部变量:也就是除了属性之外的其他变量,作用域为定义它的代码块中
public class VarScope {
//编写一个main方法
public static void main(String[] args) {
}
}
class Cat {
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 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;
String address;
System.out.println(num);//error
System.out.println(address);//error
System.out.println(weight);//
}
}
注意事项和细节使用
- 属性和局部变量可以重名,访问时遵循就近原则
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();
p1.say();
}
}
class Person {
public void say() {
//细节:属性和局部变量可以重名,访问时遵循就近原则
String name = "king";
System.out.println(name);
}
- 在同一个作用域中,比如在同一个成员方法中,两个局部变量,不能重名
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();
p1.say();
}
}
class Person {
public void say() {
//细节:属性和局部变量可以重名,访问时遵循就近原则
String name = "king";
System.out.println(name);
}
public void hi() {
String address = "北京";
String address = "上海";
String name = "hsp";//ok
}
}
- 属性生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁。局部变量,生命周期较短,伴随着它的代码块的执行而创建,伴随着代码块的结束而销毁。即在一次方法调用过程中
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();
//属性生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁。
//局部变量,生命周期较短,伴随着它的代码块的执行而创建,
//伴随着代码块的结束而销毁。即在一次方法调用过程中
p1.say();//当执行say方法时,say方法的局部变量比如name,会创建
//当say执行完毕后,name局部变量就会销毁,但是属性(全局)仍然可以使用
}
}
class Person {
public void say() {
//细节:属性和局部变量可以重名,访问时遵循就近原则
String name = "king";
System.out.println(name);
}
public void hi() {
String address = "北京";
String address = "上海";
String name = "hsp";//ok
}
}
-
作用域范围不同
-
- 全局变量/属性:可以被本类使用。或其他类使用(通过对象调用)
- 局部变量:只能在本类中对应的方法中使用
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
t1.test2(p1);
}
}
class T {
//全局变量/属性:可以被本类使用,或其他类使用(通过对象调用)
//1.
public void test() {
Person p1 = new Person();
System.out.println(p1.name); //jack
}
//2.
public void test2(Person p) {
System.out.println(p.name);//jack
}
}
class Person {
public void say() {
//细节:属性和局部变量可以重名,访问时遵循就近原则
String name = "king";
System.out.println(name);
}
public void hi() {
String address = "北京";
String address = "上海";
String name = "hsp";//ok
}
}
-
修饰符不同
-
- 全局变量/属性可以加修饰符
- 局部变量不可以加修饰符
public class VarScopeDetail {
//编写一个main方法
public static void main(String[] args) {
T t1 = new T();
t1.test2(p1);
}
}
class T {
//全局变量/属性:可以被本类使用,或其他类使用(通过对象调用)
//1.
public void test() {
Person p1 = new Person();
System.out.println(p1.name); //jack
}
//2.
public void test2(Person p) {
System.out.println(p.name);//jack
}
}
class Person {
//细节:属性可以加修饰符(public protected private)
// 局部变量不可以加修饰符
private int age = 20;
String name = "jack";
public void say() {
//细节:属性和局部变量可以重名,访问时遵循就近原则
public String name = "king";//error 局部变量不可以有修饰符
System.out.println(name);
}
public void hi() {
String address = "北京";
// String address = "上海";
String name = "hsp";//ok
}
}
构造方法/构造器
基本介绍
引入:我们来看一个需求:前面我们在创建人类的对象时,是先把一个对象创建好后,再给他的年龄和姓名属性赋值,如果现在我要求,在创建人类的对象时,就直接指定这个对象的年龄和姓名,该怎么做? 这时就可以使用构造器
- 基本语法:
**[修饰符] 方法名(形参列表) {
**}
- 说明:
- 构造器的修饰符可以默认,也可以是public protected private
- 构造器没有返回值:即没有返回类型
- 方法名和类名字必须一样
- 参数列表和成员方法一样的规则
- 构造器的调用,由系统完成
- 构造方法又叫构造器,是类的一种特殊的方法,它的主要作用是完成对新对象的初始化
- 特点**:**
- 方法名和类名相同
- 没有返回值
- 在创建对象时,系统会自动地调用该类地构造器完成对象地初始化
public class Construct01 {
//编写一个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 + " p1的对象age=" + p1.age);
}
}
//在创建人类的对象时,就直接指定整个对象的年龄和姓名
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;
}
}
注意事项和使用细节
- 一个类可以定义多个不同地构造器,即构造器重载
比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名,不需要指定年龄、
public class ConstructDetail {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person("king", 40);
Person p2 = new Person("tom");
}
}
class Person {
String name;
int age;
//第一个构造器
public Person(String pName, int pAge) {
name = pName;
age = pAge;
}
//第二个构造器,只指定任命,不需要指定年龄
public Person(String pName) {
name = pName;
}
}
- 构造器名和类名要相同
- 构造器没有返回值
- 构造器是完成对象的初始化,并不是创建对象
- 在创建对象时,系统自动的调用该类的构造方法
- 如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器(也叫默认构造器),比如Dog() {},使用****javap指令 反编译看看
public class ConstructDetail {
//编写一个main方法
public static void main(String[] args) {
Dog dog1 = new Dog();//使用的是默认的无参构造器,现在自己定义了一个构造器,因此报错
//如果括号内不写,则有个默认的无参构造器
//而如果自己又定义了一个构造器,则会被覆盖
//再进行使用的时候则会报错,除非显式的定义一下
}
}
class Dog {
//如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器(也叫默认构造器)
//默认构造器
Dog() {
}
//一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,
///除非显式的定义一下,即: Dog(){} 写 (这点很重要)
public Dog(String dName) {
//...
}
Dog() {
//显式的定义一下 无参构造器
//若没有这个显式的定义,则会报错
}
}
- 一旦定义了自己的构造器,默认的构造器就覆盖了**,就不能再使用默认的无参构造器了,除非显式的定义一下,即:Dog() {}**
练习题
public class ConstructorExercise {
//编写一个main方法
public static void main(String[] args) {
Person p1 = new Person();//无参构造器
//应该输出 null 和 18
System.out.println("p1的信息 name=" + p1.name + " age=" + p1.age);
Person p2 = new Person("scott", 50);
//应该输出 scott 50
System.out.println("p2的信息 name=" + p2.name + " age=" + p2.age);
}
}
//在前面定义的 Person 类中添加两个构造器:
//第一个无参构造器:利用构造器设置所有人的 age 属性初始值都为 18
//
//第二个带 pName 和 pAge 两个参数的构造器:
//使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。
//分别使用不同的构造器,创建对象
class Person {
String name;//默认null
int age;//默认0
//第一个无参构造器:利用构造器设置所有人的 age 属性初始值都为 18
public Person() {
age = 18;
}
//第二个带 pName 和 pAge 两个参数的构造器:
public Person(String pName, int pAge) {
name = pName;
age = pAge;
}
}
对象创建的流程分析
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();
}
}
class Dog {//类
String name;
int age;
1.
public Dog(String dName, int dAge) {//构造器
name = dName;
age = dAge;
}
//如果我们的构造器的形参,能够直接写成属性名,就更好了
//这里出现了个问题,根据变量的作用域原则,构造器的name 就是 局部变量了,而不是属性了
// 构造器的age 就是 局部变量了,而不是属性了
//==> 引出 this 关键字
2.
public Dog(String name, int age) {//构造器
name = name;
age = age;
}
public void info() {//成员方法 - 输出对象的属性信息
System.out.println(name + "\t" + age);
}
}
- java虚拟机会给每一个对象分配一个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();
}
}
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 就是当前对象的属性
this.name = name;
//this.age 就是当前对象的属性
this.age = age;
}
public void info() {//成员方法 - 输出对象的属性信息
System.out.println(name + "\t" + age);
}
}
深入理解this
- hashCode可以简单的将其当作对象的地址,但它不是对象的实际地址
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 就是当前对象的属性
this.name = name;
//this.age 就是当前对象的属性
this.age = age;
System.out.println("当前对象的hashCode=" + this.hashCode());
}
public void info() {//成员方法 - 输出对象的属性信息
System.out.println(name + "\t" + age + "\t" + "当前对象的hashCode=" + this.hashCode());
}
}
this的注意事项和使用细节
- this关键字可以用来访问本类的属性、方法、构造器
public class ThisDetail {
//编写一个main方法
public static void main(String[] args) {
// T t1 = new T();
// t1.f2();
T t2 = new T();
t2.f3();
}
}
class T {
String name = "jack";
int age = 100;
/细节;访问构造器语法:this(参数列表);
//注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
public T() {
this("jack", 100);
System.out.println("T() 构造器");
//希望在这里访问到T(String name, int age)构造器
}
public T(String name, int age) {
System.out.println("T(String name, int age) 构造器");
}
//细节:通过this关键字可以用来访问本类的属性
public void f3() {
String name = "smith";
//传统方法
System.out.println("name=" + name + " age=" + age);//smith就近原则
//也可以使用this访问属性
System.out.println("name=" + this.name + " age=" + this.age);//jack
}
}
- this用于区分当前类的属性和局部变量
- 访问成员方法的语法:this 方法名(参数列表);
public class ThisDetail {
//编写一个main方法
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();
}
}
- 访问构造器语法:this(参数列表); 注****意:只能在构造器中使用,即只能在构造器中访问另外一个构造器,并且必须放在第一条语句,不能在普通方法里写
public class ThisDetail {
//编写一个main方法
public static void main(String[] args) {
// T t1 = new T();
// t1.f2();
T t2 = new T();
}
}
class T {
//细节;访问构造器语法:this(参数列表);
//注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
public T() {
this("jack", 100);
System.out.println("T() 构造器");
//希望在这里访问到T(String name, int age)构造器
}
public T(String name, int age) {
System.out.println("T(String name, int age) 构造器");
}
}
- this不能在类定义的外部使用,只能在类定义的方法中使用
练习题
- 定义 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.compareTo(p2));
}
}
//定义 Person 类,里面有 name、age 属性,并提供 compareTo 比较方法,
//用于判断是否和另一个人相等,提供测试类 TestPerson 用于测试,
//名字和年龄完全一样,就返回 true, 否则返回 false
//
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;
}
}