6. Java面向对象编程（一）

雾眠气泡水:)

已于 2022-08-12 21:09:23 修改

阅读量507

点赞数 2

分类专栏： Java笔记文章标签： java 面向对象编程基础

于 2022-07-08 12:40:29 首次发布

本文链接：https://blog.csdn.net/qq_44378854/article/details/125668535

版权

Java笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. 类与对象

1.1 类与对象的引入

有两只猫，一只叫小白，今年 3 岁，白色；一只叫小花，今年 100 岁，花色。用代码表示上述信息。

单独的定义变量解决，缺点：不利于数据的管理。

//第 1 只猫信息
String cat1Name = "小白";
int cat1Age = 3;
String cat1Color = "白色";
//第 2 只猫信息
String cat2Name = "小花";
int cat2Age = 100;
String cat2Color = "花色";

使用数组解决，缺点：
(1) 数据类型体现不出来；
(2) 只能通过 [下标] 获取信息，造成变量名字和内容的对应关系不明确；
(3) 不能体现猫的行为。
```
//第 1 只猫信息
String[] cat1 = {"小白", "3", "白色"};
//第 2 只猫信息
String[] cat2 = {"小花", "100", "花色"};
```

1.2 类与对象的关系

类是自定义的数据类型，对象是类的一个具体实例，两者的关系可以类比 int 类型与具体值：
猫类Cat：自定义的数据类型 ➡ 猫对象（具体一只猫）
int：Java提供的数据类型 ➡ 100， 200，300
在这里插入图片描述

从类到对象，目前有几种说法：（1）创建一个对象；（2）实例化一个对象；（3）把类实例化

对于 1.1 中的问题，可以用面向对象（OOP）的方式解决：

public class Test {
	public static void main(String[] args) {
		//第1只猫
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "白色";
		cat1.weight = 10;
		//第2只猫
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";
		cat2.weight = 20;
		//访问对象的属性
		System.out.println("第1只猫信息：" + cat1.name
		+ "\t" + cat1.age + "\t" + cat1.color + "\t" + cat1.weight);
		System.out.println("第2只猫信息：" + cat2.name
		+ "\t" + cat2.age + "\t" + cat2.color + "\t" + cat2.weight);
	}	
}

class Cat {
	String name; //名字
	int age; //年龄
	String color; //颜色
	double weight; //体重
}

1.3 属性 / 成员变量 / 字段

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

属性可以是基本数据类型，也可以是引用类型(对象，数组)。

class Car {
	String name;
	double price;
	String color;
	String[] master;//属性是引用类型（数组）
}

属性的定义语法同变量，但多了“访问修饰符”。示例：private int num;
访问修饰符的作用：控制属性的访问范围。
4种访问修饰符：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 Test {
	public static void main(String[] args) {
		Person p1 = new Person();
		System.out.println("age = " + p1.age) ;
		System.out.println("name = " + p1.name);
		System.out.println("salary = " + p1.salary);
		System.out.println("isPass = " + p1.isPass);
	}	
}

class Person {
	int age;
	String name;
	double salary;
	boolean isPass;
}

输出结果：

age = 0
name = null
salary = 0.0
isPass = false

1.4 创建对象

先声明再创建
```
Cat cat ;
cat = new Cat(); 
```
声明对象以后，栈中的对象名 / 对象的引用的内容为 null，创建对象后，堆中有了对象的空间，对象名的内容才是对象的地址。
直接创建
```
Cat cat = new Cat();
```

1.5 访问属性

访问属性的方式：对象名.属性名，如：cat.name，cat.age，cat.color。

1.6 类和对象的内存分配机制

Java 内存的结构分析：

栈：一般存放基本数据类型（局部变量）。
堆：存放对象、数组等。
方法区：常量池（常量，比如字符串），类加载信息。

上图注解：
① 先加载 Cat 类信息（属性和方法信息, 只会加载一次）。
② 在堆中分配空间，进行默认初始化（看1.3中的规则）。再把地址赋给 cat , cat 就指向对象。
③ 进行指定初始化，如：cat.name = “小白”。
在这里插入图片描述
【例】

2. 成员方法

2.1 方法的定义和使用

在某些情况下，我们要需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄，姓名……），还有一些行为比如：说话、跑步，这时就要用成员方法。现在要求对Person 类完善。

public class Test {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.speak(); 
		p1.cal01(); 
		p1.cal02(5); 
		p1.cal02(10); 

		int returnRes = p1.getSum(10, 20);
		System.out.println("getSum 方法返回的值=" + returnRes);
	}
}

class Person {
	String name;
	int age;
	
	public void speak() {
		System.out.println("我是一个好人");
	}
	
	public void cal01() {
		int res = 0;
		for(int i = 1; i <= 1000; i++) {
			res += i;
		}
		System.out.println("cal01 方法 计算结果=" + res);
	}

	public void cal02(int n) {
		int res = 0;
		for(int i = 1; i <= n; i++) {
			res += i;
		}
		System.out.println("cal02 方法 计算结果=" + res);
	}

	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

2.2 方法的调用机制

在这里插入图片描述

2.3 方法的优势

(1) 提高代码的复用性。
(2) 将实现的细节封装起来，其他用户直接调用即可。

看一个需求：
遍历一个数组 , 输出数组的各个元素值（共3次）。

public class Test {
	public static void main(String[] args) {
		int[][] map = {{0,0,1},{1,1,1},{1,1,3}};
		MyTools tool = new MyTools();
		tool.printArr(map);
		tool.printArr(map);
		tool.printArr(map);
	}
}

class MyTools {//工具类
	public void printArr(int[][] map) {
		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] + "\t");
			}
			System.out.println();
		}
	}
}

2.3 方法的使用细节

方法的访问修饰符作用是控制方法的使用范围，如果不写，就是“默认访问”，共有 4 种：public, protected, 默认, private。

一个方法最多有一个返回值，若想带回多个数据，可返回一个数组。

public class Test {
	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]);
	}
}

class AA {
	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 double f1() {
	double d1 = 1.1;
	int n = 100;
	return n; //正确 int ➡ double
	//return d1; //错误 double ➡ int
}
```
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return。
方法定义时的参数称为形参；方法调用时的传入参数称为实参，实参和形参的类型要一致或兼容，个数、顺序必须致。

方法不能嵌套定义。

public void f4() {
	//错误
	public void f5() {
	}
}

同一个类中的方法调用：不用事先创建对象，直接调用即可。被调方法和主调方法前后顺序无妨。

public class Test {
	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(10);
	}
}

跨类中的方法 A 类调用 B 类方法：需要先创建 B 的对象，再调用其方法，A、B类的前后顺序无妨。（实际上，主类调用其他自定义类也是一样的操作）
```
class A {
	public void m1() {
		B b = new B();
		b.hi();
	}
}
class B {
	public void hi() {
		System.out.println("B 类中的 hi()被执行");
	}
}
```
特别说明一下：跨类的方法调用与方法的访问修饰符相关，后面详讲。

2.4 方法的传参机制

2.4.1 基本数据类型传参

基本数据类型，传递的是值（值拷贝），形参的改变不影响实参。

public class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		AA obj = new AA();
		//仅仅是将main方法中的值拷贝一份给了swap方法
		//swap方法调用完成后，相关的变量等信息就出栈，带不到main方法中来
		obj.swap(a, b);
		System.out.println("main方法中: "+a + "\t" + b);//a=10 b=20
	}
}

class AA {
	public void swap(int a,int b){
		System.out.println("交换前: " + a + "\t" + b);//a=10 b=20
		int tmp = a;
		a = b;
		b = tmp;
		System.out.println("交换前: " + a + "\t" + b);//a=20 b=10
	}
}

2.4.2 引用类型传参

引用类型，传递的是地址，可以通过形参影响实参。

（1）数组传参

public class Test {
	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 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
mian的arr数组：200	2	3

（2）对象传参

public class Test {
	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);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {
		p = 10000;
	}
}

分析：
在这里插入图片描述

输出结果：

main的p.age=10000

【例1】

public class Test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//函数返回后，test200方法的相关内容出栈，包括其中的对象p
		//且该对象p不能被带回mian函数，main函数后续使用的p仍是原对象
		System.out.println("main的p.age="+p.age);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {//传过来一个对象的地址，使p的内容为该对象的地址
		p = null;//但又马上置为空	
	}
}

输出结果：

main的p.age=10

【例2】


```java
public class Test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//函数返回后，test200方法的相关内容出栈，包括其中的对象p
		//且该对象p不能被带回mian函数，main函数后续使用的p仍是原对象
		System.out.println("main的p.age="+p.age);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {//传过来一个对象的地址，使p的内容为该对象的地址
		p = new Person();//但又马上置为另一个新对象的地址
		p.name = "tom";
		p.age = 99;
	}
}

输出结果：

main的p.age=10

【例3】编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。

public class Test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;		
		Person np = b.copyPerson(p);
		System.out.println("p.name="+p.name+"  p.age="+p.age);
		System.out.println("np.name="+np.name+"  np.age="+np.age);
		System.out.println(p == np);//判断两者是否为同一个对象
	}
}
class Person {
	String name;
	int age;
}
class B {
	public Person copyPerson(Person p) {
		Person np = new Person();
		np.name = p.name;
		np.age = p.age;
		return np;
	}
}

2.5 方法的递归调用

调用方法时，相关信息入栈；方法返回时。相关信息出栈。
【例1】
在这里插入图片描述
【例2】

递归的细节问题：

执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
每一层方法的局部变量是独立的，不会相互影响。
如果方法中使用的是引用类型变量（比如数组、对象），各个方法就会共享该引用类型的数据。
递归必须向退出递归的条件逼近，否则就是无限递归，出现
StackOverflowError，栈溢出。

练习：
（1）已知斐波那契数列：1，1，2，3，5，13…使用递归的方式求出第n项。

public class Test {
	public static void main(String[] args) {
		Tool tool = new Tool();
		int n = 7;
		int res = tool.fibonacci(n);
		System.out.println(res);
	}
}

class Tool {
	public int fibonacci(int n) {
		if (n == 1 || n == 2)
		{
			return 1;
		}else {
			return fibonacci(n-1) + fibonacci(n-2);
		}
	}
}

（2）有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个。以后每天都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时（还没吃）发现只有1个桃子了。问：最初共多少个桃子?

public class Test {
	public static void main(String[] args) {
		Tool tool = new Tool();
		int day = 1;
		int res = tool.peachNum(day);
		if (res!=-1)
		{
			System.out.println("第"+day+"天桃子个数是: "+res);
		}else{
			System.out.println("应输入1~10的数字");
		}
		
	}
}

class Tool {
	public int peachNum(int day) {
		if (day == 10)
		{
			return 1;
		}else if(day>=1 && day<=9) {
			return (peachNum(day+1)+1) * 2;
		}else {
			return -1;
		}
	}
}

（3）老鼠出迷宫，找到一条路径，从①处走到②处。
在这里插入图片描述
（待补充）

2.6 方法的重载

2.6.1 基本介绍

重载：Java 允许同一个类有多个同名方法，但要求形参列表不一致（根据这里判断是否是重载就够了）。
重载的好处：
（1）减轻了起名的麻烦
（2）减轻了记名的麻烦
（3）利于接口编程

【例1】方法重载演示

public class Test {
	public static void main(String[] args) {
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
		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 double calculate(int n1, double n2) {
		System.out.println("calculate(int n1, double n2) 被调用..");
		return n1 + n2;
	}

	public double calculate(double n1, int n2) {
		System.out.println("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 + n2;
	}
}

输出结果：

calculate(int n1, int n2) 被调用..
3
calculate(double n1, int n2) 被调用..
3.1
calculate(int n1, double n2) 被调用..
3.1

2.6.2 使用细节

（1）方法名：必须相同。
（2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）。
（3）返回类型：无要求。

【例2】重载对参数名称无要求，所以下面两个方法只是“方法的重复定义”，不构成方法重载，而且是错误的。

class MyCalculator {
	public int calculate(int n1, int n2) {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}
 	public int calculate(int a1, int a2) {
		System.out.println("calculate(int n1, int n2) 被调用");
		return a1 + a2;
	}
}

【例3】重载对返回类型无要求，所以下面两个方法也不构成重载。

class MyCalculator {
	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) 被调用");
		 int res = n1 + n2;
	}
}

【例4】与void show(int a,char b,double c){}构成重载的有:

void show(int x,char y,double z){}
int show(int a,double c,char b){}
void show(int a,double c,char b){}
boolean show(int c,char b){}
void show(double c){}
double show(int x,char y,double z){}
void shows(){}

【例5】重载中的优先级：如果有多个重载方法可供调用，则优先调用参数类型匹配度高的一个。如methods.max(3.2, 2.1, 5)优先调用方法2，如果没有方法2才会调用方法1。

public class Test {
	public static void main(String[] args) {
		Methods methods = new Methods();
		System.out.println(methods.max(3.2, 2.1, 5));
	}
}

class Methods {
	public double max(double n1, double n2, double n3) {//方法1
		double t = n1 > n2 ? n1:n2;
		return t > n3 ? t:n3;
	}
	public double max(double n1, double n2, int n3) {//方法2
		double t = n1 > n2 ? n1:n2;
		return t > n3 ? t:n3;
	}
}

2.7 可变参数

2.7.1 基本介绍

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

基本语法：

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

【例1】一般重载方法与可变参数使用的对比：

//一般重载方法,比较笨
public class Test {
	public static void main(String[] args) {
		Methods m = new Methods();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}
class Methods {
	 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;
	 }
}

//可变参数，灵活
public class Test {
	public static void main(String[] args) {
		Methods m = new Methods();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class Methods {
	public int sum(int... nums) {
		int res = 0;
		//可变参数的使用与数组相同
		for(int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}

2.7.2 使用细节

可变参数的实参可以为0个或任意多个。

可变参数的实参可以为数组。

public class Test {
	public static void main(String[] args) {
		int[] arr = {1, 2, 3};
		Methods m = new Methods();
		m.f1(arr);
	}
}

class Methods {
	public void f1(int... nums) {
		System.out.println(nums.length);//3
	}
}

可变参数的本质就是数组。
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后（保证形参和实参的唯一对应关系）。
一个形参列表中只能出现一个可变参数（保证形参和实参的唯一对应关系）。

【例2】封装一个可变参数方法，同时具备返回姓名和两门课总成绩、返回姓名和三门课总成绩、返回姓名和五门课总成绩的功能。

public class Test {
	public static void main(String[] args) {
		Methods m = new Methods();
		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 Methods {
	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;
	}
}

输出结果：

milan有2门课, 成绩总分为170.1
terry有5门课, 成绩总分为280.6

3. 作用域

3.1 基本使用

在Java中，主要的变量就是属性（成员变量）和局部变量：

全局变量：即属性，作用域为整个类。
局部变量：即属性之外的其他变量，作用域为定义它的代码块，一般指在成员方法中定义的变量。
全局变量（属性）可以不赋值，直接使用，因为有默认值；局部变量必须先赋值再使用，因为没有默认值。

class Methods {
	//属性（成员变量）在定义时，可以直接赋值
	int age = 10;
	double weight; //默认值是 0.0
	public void cry() {
		//局部变量
		int n = 10;
		String name = "jack";
	}
}

3.2 注意事项和细节

属性和局部变量可以重名，访问时遵循就近原则。

public class Test {
	public static void main(String[] args) {
		Methods m = new Methods();
		m.say();//输出king
	}
}

class Methods {
	String name = "jack";
	public void say() {
		//属性和局部变量可以重名，访问时遵循就近原则
		String name = "king";
		System.out.println(name);
	}
}

在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名。

属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁；局部变量生命周期较短，伴随着所在代码块的执行而创建，伴随着所在代码块的的结束而销毁。

public class Test {
	public static void main(String[] args) {
		Methods m = new Methods();
		//当执行say方法时,say方法的局部变量比如 name,会创建
		//当say执行完毕后,name 局部变量就销毁,但是属性(全局变量)仍然可以使用
		p1.say();
	}
}

class Methods {
	String name = "jack";
	public void say() {
		String name = "king";
		System.out.println(name);//输出king
	}
}

全局变量 / 属性也可以被其他类使用（通过对象来使用），有 2 种方法；局部变量只能在本类中所在的方法内使用。

使用其他类中的全局变量 / 属性——方法1

public class Test {
	public static void main(String[] args) {
		T t1 = new T();
		t1.test1(); //jack
	}
}

class T {
	//全局变量/属性：也可以被其他类使用（通过对象来使用)
	public void test1() {
		Person p1 = new Person();
		System.out.println(p1.name);
	}
}
class Person {
	String name = "jack"; 
}

使用其他类中的全局变量 / 属性——方法2

public class Test {
	public static void main(String[] args) {
		Person p2 = new Person();
		T t2 = new T();
		t2.test2(p2); //jack
	}
}

class T {
	//全局变量/属性：也可以被其他类使用（通过创建对象来使用)
	public void test2(Person p) {
		System.out.println(p.name);
	}
}
class Person {
	String name = "jack";
}

全局变量 / 属性可以加修饰符；局部变量不可以加修饰符。

4. 构造方法 / 构造器（constructor）

4.1 基本使用

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

方法名和类名相同。
没有返回值。
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
方法的修饰符可以默认，也可以是 public protected private。
参数列表和成员方法一样的规则。

基本语法：

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

【例】构造方法 / 构造器的使用

public class Test {
	public static void main(String[] args) {
		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;
	public Person(String pName, int pAge) {
		System.out.println("构造器被调用，完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

输出结果：

构造器被调用，完成对象的属性初始化
p1 的信息如下
p1 对象 name = smith
p1 对象 age = 80

4.2 注意事项和细节

一个类可以定义多个不同的构造器，即构造器重载。

public class Test {
	public static void main(String[] args) {
		Person p1 = new Person("king", 40);//第 1 个构造器
		Person p2 = new Person("tom");//第 2 个构造器
		System.out.println("p1: "+p1.name+" "+p1.age);//king 40
		System.out.println("p2: "+p2.name+" "+p2.age);//tom 0
	}
}

class Person {
	String name;
	int age;
	//第 1 个构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
	//第 2 个构造器, 只指定人名，不需要指定年龄（有默认值0）
	public Person(String pName) {
		name = pName;
	}
}

构造器是完成对象的初始化，并不是创建对象。在创建对象时，系统自动的调用该类的构造方法。
如果没有定义构造器，系统会给类生成一个无参构造器（也叫默认构造器）。下面的Dog类在被系统编译后生成的默认构造方法，可以使用javap指令反编译来看。
```
class Dog
{
}
```
反编译结果：

一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式地定义一下。

public class Test {
	public static void main(String[] args) {
		Dog dog = new Dog();
	}
}
class Dog
{
	public Dog(String dname){
		//...
	}
	
	Dog(){//不显式地定义，Dog dog = new Dog()就通不过
		//...
	}
}

5. 对象创建流程分析

学习了构造方法后，我们来重新分析一下对象的创建流程。

public class Test {
	public static void main(String[] args) {
		Person p = new Person("tom", 20);
	}
}
class Person
{
	String name;
	int age = 90;
	Person(String n, int a){
		name = n;
		age = a;
	}
}

对于上面代码，对象创建的流程为：
（1）加载Person类信息到方法区（无论创建多少Person对象，只会加载一次）。
（2）在堆中为对象分配空间。
（3）完成对象初始化：
（3.1）默认初始化 name=null, age=0
（3.2）显式初始化 name=null, age=90
（3.3）构造器的初始化 name=”tom“, age = 20
（4）将对象在堆中的地址赋给p（p是对象名，也可以理解成是对象的引用）。

6. this关键字

6.1 this的引入和使用

先看一段代码：

public class Test {
	public static void main(String[] args) {
		Dog dog = new Dog("tom", 3);
		dog.info();//tom 3
	}
}
class Dog{
	public String name;
	public int age;
	public Dog(String dName, int dAge){
		name = dName;
		age = dAge;
		//如果形参改成name、age，根据就近原则，
		//两个name指的都是通过形参传进来的name
		//name = name;
		//age = age;
	}
	public void info(){
		System.out.println(name+ "\t" + age+ "\t"); 
	}
}

问题：构造方法的形参名不太好，如果能够将dName改成name就好了，但是会发现按照变量的作用域原则，name的值就是null，怎么解决？这就用到了this关键字。

this关键字：Java虚拟机会给每个对象分配 this，代表当前对象。

使用this关键字解决前面变量名问题：

public class Test {
	public static void main(String[] args) {
		Dog dog = new Dog("tom", 3);
		dog.info();//tom 3
	}
}
class Dog{
	public String name;
	public int age;
	public Dog(String name, int age){
		this.name = name;//使用this关键字解决
		this.age = age;
	}
	public void info(){
		System.out.println(name+ "\t" + age+ "\t"); 
	}
}

6.2 this的深入理解

this关键字的理解（可能不特别准确，但帮助理解）：把this看成是所在对象的属性，属性值是该对象的地址（指向该对象）。
在这里插入图片描述
可以用hashcode验证this指向它所在的对象。
【注】Java代码在JVM虚拟机上运行，无法直接获取对象的地址。hashcode 是地址的一种映射，可以用来间接地查看对象地址是否相同，即是否为同一对象。

public class Test {
	public static void main(String[] args) {
		Dog dog1 = new Dog("大壮", 3);
		System.out.println("main方法：dog1的hashCode = " + dog1.hashCode());
		dog1.info();
		System.out.println("===================================");
		Dog dog2 = new Dog("大黄", 2);
		System.out.println("main方法：dog2的hashCode = " + dog2.hashCode());
		dog2.info();
	}
}
class Dog
{
	public String name;
	public int age;
	public Dog(String name, int age){
		this.name = name;
		this.age = age;
		System.out.println("构造方法: this.hashCode = " + this.hashCode());
	}
	public void info(){
		System.out.println("info方法: this.hashCode = " + this.hashCode());
		System.out.println(name+ "\t" + age+ "\t"); 
	}
}

输出结果：

构造方法: this.hashCode = 366712642
main方法：dog1的hashCode = 366712642
info方法: this.hashCode = 366712642
大壮	3	
===================================
构造方法: this.hashCode = 1829164700
main方法：dog2的hashCode = 1829164700
info方法: this.hashCode = 1829164700
大黄	2

6.3 this的使用细节

this 关键字可以用来访问本类的属性、方法、构造器。

this 用于区分当前类的属性和局部变量（前面就是通过这一条引出this）。

public class Test {
	public static void main(String[] args) {
		T t = new T();
		t.f3();
	}
}
class T
{
	String name = "jack";
	int age = 100;
	public void f3(){
		String name = "smith";
		System.out.println(name+" "+age);//smith 100
		System.out.println(this.name+" "+this.age);//jack 100
	}
}

访问成员方法的语法：this.方法名(参数列表)。

public class Test {
	public static void main(String[] args) {
		T t1 = new T();
		t1.f2();
	}
}
class T
{
	public void f1(){
		System.out.println("f1()方法...");
	}
	public void f2(){
		System.out.println("f2()方法...");
		//第1种方式：前面讲的，访问本类中的方法不用创建对象，直接访问即可
		f1();
		//第2种方式
		this.f1();
	}
}

输出结果：

f2()方法...
f1()方法...
f1()方法...

访问构造器语法：this(参数列表)，注意只能在构造器中使用，即只能在构造器中访问本类中另外一个构造器, 且必须放在第一条语句。

public class Test {
	public static void main(String[] args) {
		T t2 = new T();
	}
}
class T
{
	public T() {
		//这里去访问T(String name, int age) 构造器
		this("jack", 100);//放在第一条语句
		System.out.println("T() 构造器");
		
	}
	public T(String name, int age) {
		System.out.println("T(String name, int age构造器" );
	}
}

输出结果：

T(String name, int age构造器
T() 构造器

this 不能在类的外部使用，只能在类的方法中使用。

【例】定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，用于判断是否和另一个人相等。提供测试类 Test 用于测试，若名字和年龄完全一样，返回 true, 否则返回 false。

public class TestPerson {
	public static void main(String[] args) {
		Person p1 = new Person("mary", 20);
		Person p2 = new Person("mary", 20);
		System.out.println("p1 和 p2 比较的结果=" + p1.compareTo(p2));//true
	}
}
class Person {
	String name;
	int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public boolean compareTo(Person p) {
		return this.name.equals(p.name) && this.age == p.age;
	}
}

7. 本章练习

【例1】编写类A01，定义方法getMax，事先求某个double数组的最大值，并返回。

public class Test {
	public static void main(String[] args) {
		double[] arr = {3.5, 9.2, 10.3, 8.2, 4.3};
		A01 a01 = new A01();
		Double max = a01.getMax(arr);
		if(max != null)
			System.out.println("最大值是" + max);
		else
			System.out.println("数组不能为空");

	}
}
class A01{
	public Double getMax(double[] arr){//Double可以接收double或对象作为返回值
		//防止初始化时 arr=null 或 arr={}
		if(arr != null && arr.length != 0){
			double maxNum = arr[0];
			for (int i = 1; i < arr.length; i++){//arr.length==1时不执行
				if (arr[i] > maxNum){
					maxNum = arr[i];
				}
			}
			return maxNum;
		}else{
			return null;
		}		
	}
}

数组为空和数组长度为0的区别：
（1）int[] arr1 ：只是声明了一个数组变量，并未初始化，使用会出错.
（2）int[] arr2 = null：虽然初始化，但是一个空指针，没有指向一个有效的数组，什么都做不了，无法调用这个对象的方法，会产生空指针异常。
（3）int[] arr3 = new int[0]：声明并创建了一个数组对象，只不过长度为0，没有内容。

所以对于数组，不但要判断它是否为空指针，也需要判断它是否有内容，同时要先判断空指针再判断长度是否为0，顺序不能颠倒，因为空指针没有length属性。

【例2】编写Book类，定义方法updatePrice，实现更改某本书的价格。若价格 > 150，则更改为150，若价格 > 100，则更改为100，否则不变。

public class Test {
	public static void main(String[] args) {
		Book book = new Book("西游记", 134.2);
		System.out.println(book.name+" "+book.price);//西游记 134.2
		book.updatePrice();
		System.out.println(book.name+" "+book.price);//西游记 100.0
	}
}
class Book{
	String name;
	double price;
	public Book(String name, double price){
		this.name = name;
		this.price = price;
	}
	public void updatePrice(){
		if(price > 150){
			price = 150;
		}else if(price > 100){
			price = 100;
		}
	}
}

【例3】定义一个圆类Circle，定义属性：半径，提供显示圆周长功能的方法，显示圆面积的方法。
在Java的Math类中有一个字段PI，它是比任何值都接近 π 的double值，即 Math.PI ≈ π。

public class Test {
	public static void main(String[] args) {
		Circle circle = new Circle(3);
		circle.outCircum();
		circle.outArea();
	}
}
class Circle{
	double radius;
	public Circle(double radius){
		this.radius = radius;
	}
	public void outCircum(){
		System.out.println("圆的周长："+2*Math.PI*radius);
	}
	public void outArea(){
		System.out.println("圆的面积："+Math.PI*radius*radius);
	}	
}

【例4】编程创建一个Calei计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商（要求除数为0的话，要提示）。

public class Test {
	public static void main(String[] args) {
		Calei Calei = new Calei(3, 0);
		System.out.println(Calei.add());
		System.out.println(Calei.sub());
		System.out.println(Calei.mul());
		Double divRes = Calei.div();
		if (divRes != null){
			System.out.println(divRes);
		}
	}
}
class Calei{
	double a;
	double b;
	public Calei(double a, double b){
		this.a = a;
		this.b = b;
	}
	public double add(){
		return a+b;
	}
	public double sub(){
		return a-b;
	}
	public double mul(){
		return a*b;
	}
	public Double div(){//注意返回类型
		if(b!=0)
			return a/b;
		else{
			System.out.println("除数不能为0");
			return null;
		}			
	}
}

【例5】分析下面代码的输出。

public class Test { 
	int count = 9; 
	public void count1() { 
		count=10;
		System.out.println(" count1=" + count) ;
	}
	public void count2() { 
		System.out.println(" count1=" + count++ );
	}
	public static void main(String args[]) {
		new Test().count1();
		Test t1= new Test();
		t1.count2();
		t1.count2();
	}
}

（1）new Test().count1() 先创建匿名对象，该对象中的属性count 为 9，调用count1方法后，count 为10，故该句输出count = 10。匿名对象使用一次后，就不能再使用。
（2）Test t1= new Test() 创建t1对象（与前面的匿名对象不是一个对象），该对象中的属性count 为 9。
（3）t1.count2() 先输出t1对象的count属性9，再使count自增，count变为10。
（4）t1.count2() 先输出t1对象的count属性10，再使count自增，count变为11。

输出结果：

 count1=10
 count1=9
 count1=10

【例6】分析下面代码的输出。

class Demo{
	int i= 100;
	public void m () {
		int j=i++;
		System.out.println("i="+i);
		System.out.println("j="+j);
	}
}
public class Test{
	public static void main(String[] args){
		Demo d1 = new Demo(); 
		Demo d2 = d1;
		d2.m(); 
		System.out.println(d1.i);
		System.out.println(d2.i);
	}
}

关键点： d1和d2指向的是同一个对象。
与本题解答关系不大的知识点：i 在堆中，j 在栈中。
输出结果：

i=101
j=100
101
101

【例7】method方法的调用语句为: System.out.println(method(method(10.0,20.0),100)); 试写出method方法的定义形式。

public double method(double d1, double d2) {..}

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

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(参数列表)在构造器中访问另外一个构造器,
		//必须放在第一条语句。
		//this(job, sal);
		this.job = job;
		this.sal = sal;
	}
}

【例9】将对象作为参数传递给方法。
题目要求:：
(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 Test{
	public static void main(String[] args){
		PassObject obj = new PassObject();
		Circle c = new Circle();
		obj.printAreas(c, 5);
	}
}

class Circle{
	double radius;
	public double findArea(){
		return Math.PI*radius*radius;
	}
	public void setRadius(double radius){
		this.radius = radius;
	}
}
class PassObject{
	public void printAreas(Circle c, int times){
		System.out.println("circle\tareas");
		for (int i=1; i<=times; i++){
			//只创建了一个对象，但在求不同半径的
			//圆的面积时，去动态修改了圆的半径，
			//比每次都创建新对象效率高
			c.setRadius(i);
			System.out.println(c.radius + "\t\t" + c.findArea());			
		}
	}
}

【例10】猜拳游戏：人与电脑玩猜拳游戏，共玩3次。先由人出拳，然后电脑出拳，每次游戏后立即显示游戏结果。3次游戏结束后，显示人与电脑分别赢的次数。（0-石头 1-剪刀 2-布）

import java.util.Scanner;
import java.util.Random;
public class Test{
	public static void main(String[] args){
		PerOrCom person = new PerOrCom(0);//初始化人赢的次数为0
		PerOrCom computer = new PerOrCom(0);//初始化电脑赢的次数为0
		Game game = new Game();
		game.play(person, computer);
	}
}

class PerOrCom{//人或电脑
	int current;//当前猜拳数字
	int success;//赢的次数
	public PerOrCom(int success){
		this.success = success;
	}
	public void setCurrent(int current){
		this.current = current;
	}
	public int getSuccess(){
		return success;
	}
}
class Game{
	public void play(PerOrCom person, PerOrCom computer) {
		System.out.println("===玩家共有3次对局===");
		Scanner scanner = new Scanner(System.in);
		Random r = new Random();
		for (int i=0; i<3; i++){
			System.out.print("请出拳（0-石头 1-剪刀 2-布）：");
			person.setCurrent(scanner.nextInt());
			computer.setCurrent(r.nextInt(3));
			if ((person.current == 0 && computer.current == 1) ||(person.current == 1 && computer.current == 2)||(person.current == 2 && computer.current == 0)){
				person.success++; 
				System.out.println("你出的是"+person.current+"，电脑出的是"+computer.current+"，你赢了");
			}else if(person.current == computer.current){
				System.out.println("你出的是"+person.current+", 电脑出的是"+computer.current+", 平局");
			}else{
				computer.success++;
				System.out.println("你出的是"+person.current+", 电脑出的是"+computer.current+", 你输了");
			}
		}
		System.out.println("游戏结束。你赢了"+person.success+"次, 电脑赢了"+computer.success+"次");
	}
}

雾眠气泡水:)

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
6. Java面向对象编程（一）

有两只猫，一只叫小白，今年 3 岁，白色；一只叫小花，今年 100 岁，花色。用代码表示上述信息。单独的定义变量解决，缺点：不利于数据的管理。使用数组解决，缺点：(1) 数据类型体现不出来；(2) 只能通过 [下标] 获取信息，造成变量名字和内容的对应关系不明确；(3) 不能体现猫的行为。1.2 类与对象的关系类是自定义的数据类型，对象是类的一个具体实例，两者的关系可以类比 int 类型与具体值：猫类Cat：自定义的数据类型 ➡ 猫对象（具体一只猫）int：Java提供的数据
复制链接

扫一扫