Java基础学习笔记（三）

面向对象基础 

一个Java源文件可以包含多个类的定义，但只能定义一个public类，且public类名必须与文件名一致。如果要定义多个public类，必须拆到多个Java源文件中。 

类与对象

区别和联系

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

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

属性（成员变量/字段）

• 从概念或叫法上看： 成员变量= 属性= field(字段)

public class Object02 { 

	//编写一个main方法
	public static void main(String[] args) {

	}
}

class Car {
	String name;//属性, 成员变量, 字段 field
	double price;
	String color;
	String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}

• 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的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 PropertiesDetail { 

	//编写一个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; 

类和对象的内存分配机制(重要)

示意图

Java 内存的结构分析：

• 栈： 一般存放基本数据类型(局部变量)
• 堆： 存放对象
• 方法区：常量池(常量，比如字符串)， 类加载信息

Java 创建对象的流程简单分析

Person p = new Person();
p.name = “jack”;
p.age = 10

1. 先加载Person 类信息(属性和方法信息, 只会加载一次)
2. 在堆中分配空间, 进行默认初始化(看规则)
3. 把地址赋给p , p 就指向对象
4. 进行指定初始化， 比如p.name =”jack” p.age = 10

成员方法

快速入门

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

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 的结果
	//解读
	//(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;
	}
}

方法调用机制

为什么需要成员方法

看一个需求：请遍历一个数组, 输出数组的各个元素值。

• 解决思路1，传统的方法，就是使用单个for 循环，将数组输出
• 解决思路2: 定义一个类MyTools ,然后写一个成员方法，调用方法实现

public class Method02 { 

	//编写一个main方法
	public static void main(String[] args) {

		//请遍历一个数组 , 输出数组的各个元素值
		int [][] map =  {{0,0,1},{1,1,1},{1,1,3}};

		//使用方法完成输出, 创建MyTools对象 
		MyTools tool = new MyTools();

		//遍历map数组
		//传统的解决方式就是直接遍历
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		//使用方法
		tool.printArr(map);

		//....
		//
		//要求再次遍历map数组
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		tool.printArr(map);


		//...再次遍历
		//
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		tool.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 返回值;
}

• 形参列表：表示成员方法输入cal(int n) ， getSum(int num1, int num2)
• 返回数据类型：表示成员方法输出, void 表示没有返回值
• 方法主体：表示为了实现某一功能代码块
• return 语句不是必须的

注意事项和使用细节

注意事项

访问修饰符(作用是控制方法使用的范围)

• 如果不写默认访问，[有四种: public, protected, 默认, private]

返回数据类型

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

方法名

• 遵循驼峰命名法，最好见名知义，表达出该功能的意思即可

细节

• 方法不能嵌套定义
• 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
• 实参和形参的类型要一致或兼容、个数、顺序必须一致

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

}

• 同一个类中的方法调用：直接调用即可
• 跨类中的方法A类调用B类方法：需要通过对象名调用

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()被执行");
	}
}

练习

编写类AA ，有一个方法：判断一个数是奇数odd 还是偶数, 返回boolean
根据行、列、字符打印对应行数和列数的字符，比如：行：4，列：4，字符#,则打印相应的效果

public class MethodExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {

		AA a = new AA();
		// if(a.isOdd(2)) {//T , 这样的写法以后会看到很多
		// 	System.out.println("是奇数");
		// } else {
		// 	System.out.println("是偶数");
		// }
		// 
		// 
		// 使用print方法
		a.print(4, 4, '#');


		
	}
}
//编写类AA ，有一个方法：判断一个数是奇数odd还是偶数, 返回boolean
class AA {
	//思路
	//1. 方法的返回类型 boolean
	//2. 方法的名字 isOdd
	//3. 方法的形参 (int num)
	//4. 方法体 , 判断
	
	public boolean isOdd(int num) {
		// if(num % 2 != 0) {
		// 	return true;
		// } else {
		// 	return false;
		// }

		//return num % 2 != 0 ? true; false;
		//
		return num % 2 != 0;
	}

	//根据行、列、字符打印 对应行数和列数的字符，
	//比如：行：4，列：4，字符#,则打印相应的效果
	/*
		####
		####
		####
		####
	 */
	//思路
	//1. 方法的返回类型 void
	//2. 方法的名字 print
	//3. 方法的形参 (int row, int col, char c)
	//4. 方法体 , 循环
	public void print(int row, int col, char c) {
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {//输出每一行
				System.out.print(c);
			}
			System.out.println(); //换行
		}
	}
}

成员方法传参机制

基本数据类型的传参机制

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

 

引用数据类型的传参机制

案例

• B 类中编写一个方法test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化
• B 类中编写一个方法test200，可以接收一个Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化？会变化

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();

		//测试
		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);//10000 
	}
}
class Person {
	String name;
	int age; 
}
class B {
	public void test200(Person p) {
		//p.age = 10000; //修改对象属性
		//思考
		p = new Person();
		p.name = "tom";
		p.age = 99;
		//思考
		//p = null; 
	}

	//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] + "\t");
		}
		System.out.println();
	}
}

结论及示意图

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！ 

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

• 编写类MyTools 类，编写一个方法可以打印二维数组的数据。
• 编写一个方法copyPerson，可以复制一个Person 对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同

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

方法重载

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致（形参类型/顺序/个数至少有一个不同）！

示例

class Methods{
	public void m (int a){
		System.out.println(a * a);
	}

	public void m (int a, int b){
		System.out.println(a * b);
	}

	public void m (String c){
		System.out.println(c);
	}

	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){
		double max1 = n1 > n2 ? n1 : n2
		return max1 > n3 ? max1 : n3;
	}
}

public class OverLoadExercise{
	public static void main(String[] args){
		Methods method = new Methods();
		method.m(2);
		method.m(3, 4);
		method.m("hello~");

		System.out.println(method.max(4, 2));
		System.out.println(method.max(5.9, 3.2));
		System.out.println(method.max(4.7, 5.1, 8.6));
	}
}

可变参数

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

基本语法

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

数据类型... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多) 
使用可变参数时，可以当做数组来使用

public class VarParameter01 { 

	//编写一个main方法
	public static void main(String[] args) {

		Method m = new Method();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class Method {
	//可以计算 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. nums 可以当做数组
	//2. 遍历 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;
	}
}

使用细节 

• 可变参数的实参可以为数组
• 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
• 一个形参列表中只能出现一个可变参数

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) {

	// }
}

 练习

public class VarParameterExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		Method m = new Method();
		//m.showScore：对象m 通过 . 调用方法showScore
		System.out.println(m.showScore("milan" , 90.1, 80.0 ));
		System.out.println(m.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
	}
}

class Method  {

	/*
	有三个方法，分别实现返回姓名和两门课成绩(总分)，
	返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	 */
	
	public String showScore(String name, double... scores){
		double totalScore = 0;
		for (int i = 0; i < scores.length; i++) {
			totalScore += scores[i];
		}
		return name + scores.length+ "门课的总成绩是 " + totalScore;
	}
	
 }

构造方法/构造器

基本语法

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

基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

• 构造器的修饰符可以默认， 也可以是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;
	}
}

注意事项和使用细节

• 一个类可以定义多个不同的构造器，即构造器重载
• 比如：我们可以再给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;
	}
}

练习

在前面定义的Person 类中添加两个构造器：

• 第一个无参构造器：利用构造器设置所有人的age 属性初始值都为18
• 第二个带pName 和pAge 两个参数的构造器：使得每次创建Person 对象的同时初始化对象的age 属性值和name 属性值。分别使用不同的构造器，创建对象

public class ConstructorExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();//无参构造器

		//下面输出 name = null, age = 18
		System.out.println("p1的信息 name=" + p1.name + " age=" + p1.age);

		Person p2 = new Person("scott", 50);
		//下面输出 name = scott, age = 50
		System.out.println("p2的信息 name=" + p2.name + " age=" + p2.age);

	}
}

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关键字

对this访问机制的理解

this 的注意事项和使用细节

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

本章练习

题目

编写类A01，定义方法max，实现求某个double数组的最大值，并返回

public class Homework01 { 

	//编写一个main方法
	public static void main(String[] args) {
		A01 a01 = new A01();
		double[] arr = {1, 1.4, -1.3, 89.8, 123.8 , 66}; //;{};
		Double res = a01.max(arr);
		if(res != null) {
			System.out.println("arr的最大值=" + res);
		} else {
			System.out.println("arr的输入有误, 数组不能为null, 或者{}");
		}
	}
}
/*
思路分析
1. 类名 A01
2. 方法名 max
3. 形参 (double[])
4. 返回值 double

先完成正常业务，然后再考虑代码健壮性
 */
class A01 {
	public Double max(double[] arr) {
		//老韩先判断arr是否为null,然后再判断 length 是否>0
		if( arr!= null && arr.length > 0 ) {

			//保证arr至少有一个元素 
			double max = arr[0];//假定第一个元素就是最大值
			for(int i = 1; i < arr.length; i++) {
				if(max < arr[i]) {
					max = arr[i];
				}
			}

			return max;//double
		} else {
			return null;
		}
	}
}

题目

编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，并返回索引，如果找不到，返回-1

public class Homework02 { 

	//编写一个main方法
	public static void main(String[] args) {

		String[] strs = {"jack", "tom", "mary","milan"};
		A02 a02 = new A02();
		int index = a02.find("milan", strs);
		System.out.println("查找的index=" + index);
	}
}

//分析
//1. 类名 A02
//2. 方法名 find
//3. 返回值 int
//4. 形参 (String , String[])
//
//自己补充代码健壮性
class A02 {

	public int find(String findStr, String[] strs) {
		//直接遍历字符串数组，如果找到，则返回索引
		for(int i = 0; i < strs.length; i++) {
			if(findStr.equals(strs[i])) {
				return i;
			}
		}
		//如果没有，就返回-1
		return -1;
	}
}

题目

编写类Book,  定义方法updatePrice，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100,更改为100，否则不变

public class Homework03 { 

	//编写一个main方法
	public static void main(String[] args) {

		//测试
		Book book = new Book("笑傲江湖", 300);
		book.info();
		book.updatePrice();//更新价格
		book.info();
	}
}
/*
分析
1. 类名 Book
2. 属性 price, name
3. 方法名 updatePrice
4. 形参 ()
5. 返回值 void
6. 提供一个构造器
 */

class Book {
	String name;
	double price;
	public Book(String name, double price) {
		this.name = name;
		this.price = price;
	}
	public void updatePrice() {
		//如果方法中，没有 price 局部变量, this.price 等价 price
		if(price > 150) {
			price = 150;
		} else if(price > 100 ) {
			price = 100;
		} 
	}

	//显示书籍情况
	public void info() {
		System.out.println("书名=" + this.name + " 价格=" + this.price);
	}
}

题目

编写类A03, 实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样

public class Homework04 { 

	//编写一个main方法
	public static void main(String[] args) {
		int[] oldArr = {10, 30, 50};
		A03 a03 = new A03();
		int[] newArr = a03.copyArr(oldArr);
		//遍历newArr,验证
		System.out.println("==返回的newArr元素情况==");
		for(int i = 0; i < newArr.length; i++) {
			System.out.print(newArr[i] + "\t");
		}
	}
}

/*
编写类A03, 实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
 */
class A03 {
	public int[] copyArr(int[] oldArr) {
		//在堆中，创建一个长度为 oldArr.length 数组
		int[] newArr = new int[oldArr.length];
		//遍历 oldArr,将元素拷贝到 newArr
		for(int i = 0; i < oldArr.length; i++) {
			newArr[i] = oldArr[i];
		}

		return newArr;
	}
}

题目

编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试

public class Homework06 { 

	//编写一个main方法
	public static void main(String[] args) {
		Cale cale = new Cale(2, 10);
		System.out.println("和=" + cale.sum());
		System.out.println("差=" + cale.minus());
		System.out.println("乘=" + cale.mul());
		Double divRes = cale.div();
		if(divRes != null) {
			System.out.println("除=" + divRes);
		} 
	}
}

/*
 编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
 定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试 
 */

class Cale {
	double num1;
	double num2;
	public Cale(double num1, double num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	//和
	public double sum() {
		return num1 + num2;
	}
	//差
	public double minus() {
		return num1 - num2;
	}
	//乘积
	public double mul() {
		return num1 * num2;
	}
	//除法
	//
	public Double div() {
		//判断
		if(num2 == 0) {
			System.out.println("num2 不能为0");
			return null;
		} else {
			return num1 / num2;
		}
	}
}

题目

定义Music类，里面有音乐名name、音乐时长times属性，并有播放play功能和返回本身属性信息的功能方法getInfo

public class Homework09 { 

	//编写一个main方法
	public static void main(String[] args) {
		Music music = new Music("笑傲江湖", 300);
		music.play();
		System.out.println(music.getInfo());
	}
}

class Music {
	String name;
	int times;
	public Music(String name, int times) {
		this.name = name;
		this.times = times;
	}
	//播放play功能
	public void play() {
		System.out.println("音乐 " + name + " 正在播放中.... 时长为" + times + "秒");
	}
	//返回本身属性信息的功能方法getInfo
	public String getInfo() {
		return "音乐 " + name + " 播放时间为" + times;
	}
}

题目

创建一个Employee类， 属性有(名字，性别，年龄，职位，薪水)， 提供3个构造方法，可初始化  
(1) (名字，性别，年龄，职位，薪水), 
(2) (名字，性别，年龄) (3) (职位，薪水), 要求充分复用构造器

public class Homework12 { 

	//编写一个main方法
	public static void main(String[] args) {
	}
}

class Employee {
	//名字，性别，年龄，职位，薪水
	String name;
	char gender;
	int age;
	String job;
	double sal;
	//因为要求可以复用构造器，因此老韩先写属性少的构造器
	//职位，薪水
	public Employee(String job, double sal) {
		this.job = job;
		this.sal = sal;
	}
	//名字，性别，年龄
	public Employee(String name, char gender, int age) {
		this.name = name;
		this.gender = gender;
		this.age = age;
	}
	//名字，性别，年龄，职位，薪水
	public Employee(String job, double sal, String name, char gender, int age) {
		this(name, gender, age);//使用到 前面的 构造器
		this.job = job;
		this.sal = sal;
	}
	

}

题目

(1) 定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea()方法返回圆的面积。
(2) 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
     public void printAreas(Circle c, int times)     //方法签名/声明
(3) 在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
(4) 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。

public class Homework13 { 

	//编写一个main方法
	public static void main(String[] args) {

		Circle c = new Circle();
		PassObject po = new PassObject();
		po.printAreas(c, 5);
	}
}

class Circle { //类
	double radius;//半径
	public Circle() { //无参构造器

	}
	public Circle(double radius) {
		this.radius = radius;
	}
	public double findArea() {//返回面积
		return Math.PI * radius * radius;
	}
	//添加方法setRadius, 修改对象的半径值
	public void setRadius(double radius) {
		this.radius = radius;
	}
}
class PassObject {
	public void printAreas(Circle c, int times) {
		System.out.println("radius\tarea");
		for(int i = 1; i <= times; i++) {//输出1到times之间的每个整数半径值
			c.setRadius(i) ; //修改c 对象的半径值
			System.out.println((double)i + "\t" + c.findArea());
		}
	}
}