Java面向对象编程（基础部分）

itzzan

已于 2022-10-01 20:55:50 修改

阅读量438

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

于 2022-09-13 15:15:56 首次发布

本文链接：https://blog.csdn.net/weixin_65508929/article/details/126828881

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

类与对象

引入

看一个养猫猫问题：

张老太养了两只猫猫:一只名字叫小白,今年 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中作用域的分类
1. 全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
2. 局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中

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
	}
}

作用域范围不同
1. 全局变量/属性：可以被本类使用。或其他类使用（通过对象调用）
2. 局部变量：只能在本类中对应的方法中使用

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
	}
}

修饰符不同
1. 全局变量/属性可以加修饰符
2. 局部变量不可以加修饰符

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;
	}
}

itzzan

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java面向对象编程（基础部分）

类与对象引入看一个养猫猫问题：张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫使用现有技术解决单独的定义变量解决使用数组解决public class Object { //编写一个main方法 public static void main(String[] args) { //张老太养了两只猫猫:一只名字叫
复制链接

扫一扫