第 6 章面向对象编程(基础)

最新推荐文章于 2024-06-26 18:33:25 发布

binrui996

最新推荐文章于 2024-06-26 18:33:25 发布

阅读量316

点赞数

分类专栏： # Java 文章标签： java c++ 算法

本文链接：https://blog.csdn.net/weixin_44232390/article/details/126593894

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

第 6 章面向对象编程(基础)

提示：此为本人学习笔记，欢迎指出有误之处

第 6 章面向对象编程(基础)

在这里插入图片描述

6.1 类和对象基础

6.1.1 类和对象的区别和联系

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

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

必须搞清楚！！！
在这里插入图片描述

6.1.3 属性/成员变量/字段

从概念或叫法上看：成员变量 = 属性 = field(字段) (即成员变量是用来表示属性的，常叫属性)
属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的 int age 就
是属性


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

注意事项和细节说明

属性的定义语法同变量，示例：访问修饰符属性类型属性名;
（访问修饰符：控制属性的访问范围,有四种访问修饰符 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 { 
	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;
}

6.1.4 如何创建对象

先声明再创建

Cat cat ; //声明对象 cat
cat = new Cat(); //创建

直接创建

Cat cat = new Cat();

6.1.5 如何访问属性

基本语法
对象名.属性名;

cat.name ;
cat.age;
cat.color;

类和对象的内存分配机制(重要)
我们定义一个人类(Person)(包括名字,年龄) 。

//我们看看下面一段代码:
Person p1=new Person();
p1.age=10;
p1.name="小明";
Person p2 = p1; //把p1赋给了p2，让p2指向p1
System.out.println(p2.age);
//请问:p2.age究竟是多少?并画出内存图:

在这里插入图片描述

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

Java 内存的结构分析

栈：一般存放基本数据类型(局部变量)
堆：存放对象(Cat cat , 数组等)
方法区：常量池 (常量，比如字符串) ，类加载信息
示意图 [Cat (name, age, price)]

在这里插入图片描述

//我们看着下面一段代码,会输出什么信息;
Person a=new Person0:
a.age=10;
a.name="小明";
Person b;
b=a;
System.out.println(b.name);//小明b.age=200;
b = null;
System.out.println(a.age); //200
System.out.println(b.age);//异常

在这里插入图片描述

6.2 成员方法

6.2.1基本介绍


public class Method01 { 
	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 num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
	//5. return res; 表示把 res 的值， 返回
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

成员方法的好处

提高代码的复用性
可以将实现的细节封装起来，然后供其他用户来调用即可

6.2.2 方法的调用机制原理

在这里插入图片描述

6.2.3 成员方法的定义

 访问修饰符 返回数据类型 方法名（形参列表..） {
 	//方法体 
 	语句； 
 	return 返回值; 
 }

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

6.2.4 注意事项和使用细节


public class MethodDetail { 
	public static void main(String[] args) {
		AA a = new AA();
		int[] res = a.getSumAndSub(1, 4);
		System.out.println("和=" + res[0]);
		System.out.println("差=" + res[1]);

		//细节1: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
		byte b1 = 1;
		byte b2 = 2;
		a.getSumAndSub(b1, b2);//byte -> int 
		//a.getSumAndSub(1.1, 1.8);//double ->int(×)
		//细节2: 实参和形参的类型要一致或兼容、个数、顺序必须一致
		
		//a.getSumAndSub(100);//× 个数不一致
		a.f3("tom", 10); //ok
		//a.f3(100, "jack"); // 实际参数和形式参数顺序不对		
	}
}

class AA {
	//细节3: 方法不能嵌套定义
	public void f4() {
		//错误
		// public void f5() {

		// }
	}

	public void f3(String str, int n) {

	}

	//细节4. 一个方法最多有一个返回值  [思考，如何返回多个结果 返回数组 ]
	public int[] getSumAndSub(int n1, int n2) {
		int[] resArr = new int[2]; //
		resArr[0] = n1 + n2;
		resArr[1] = n1 - n2;
		return resArr;
	}
	//细节5. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
	//   具体看 getSumAndSub  
	
	//细节6. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 
	//   而且要求返回值类型必须和return的值类型一致或兼容
	public double f1() {
		double d1 = 1.1 * 3;
		int n = 100;
		return n; // int ->double 
		//return d1; //ok? double -> int 
	}

	//细节7；如果方法是void，则方法体中可以没有return语句，或者 只写 return ; 
	//细节8：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义，最好是见名知意
	public void f2() {
		System.out.println("hello1");
		System.out.println("hello1");
		System.out.println("hello1");
		int n = 10;
		//return ;
	}
}

返回数据类型

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

方法名命名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范

形参列表

一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如getSum(int n1,int n2)
参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(intl[] map)
调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数! 【getSum】
方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参,实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]
方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。

方法调用细节说明( ！！！)

同一个类中的方法调用:直接调用即可。比如print(参数);
跨类中的方法A类调用B类方法:需要通过对象名调用。比如对象名.方法名(参数);
特别说明一下:跨类的方法调用和方法的访问修饰符相关，后面我们讲到访问修饰符时,还要再细说。

6.2.5 练习题

编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean
根据行、列、字符打印对应行数和列数的字符，比如：行：4，列：4，字符#,则打印相应的效果
[建议：一定要自己写一遍，不要嫌太简单.]

6.3 成员方法传参机制(非常非常重要)

6.3.1 基本数据类型传参机制

看一个案例,分析结果是什么?

public void swap(int a,int b){
	int tmp = a;
	a = b;
	b = tmp;
	System.out.printIn("a="+a+"\tb="+b);
}

基本数据类型,传递的是值(值拷贝)，形参的任何改变不影响实参!

6.3.2 引用数据类型的传参机制

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


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

在这里插入图片描述

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

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

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

public class MethodExercise02 { 
	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;
	}
}

6.4 方法递归调用

递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁（较难理解）

6.4.1 递归能解决什么问题?

1．各种数学问题如: 8皇后问题，汉诺塔, 阶乘问题, 迷宫问题, 球和篮子的问题(google编程大赛)
2．各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
3.将用栈解决的问题–>递归代码比较简洁

6.4.2 递归举例


public class Recursion01 { 
	public static void main(String[] args) {

		T t1 = new T();
		t1.test(4);//输出什么？ n=2 n=3 n=4
		int res = t1.factorial(5); 
		System.out.println("5的阶乘 res =" + 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;
		}
	}
}

在这里插入图片描述

6.4.3 递归重要规则

执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响,比如n变量
如果方法中使用的是引用类型变量(比如数组,对象)，就会共享该引用类型的数据.
递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就
将结果返回给谁,同时当方法执行完毕或者返回时，该方法也就执行完毕。

6.4.4 练习

请使用递归的方式求出斐波那契数1,1,2,3,5,8,13…给你一个整数n，求出它的值是多
猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后，每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)，发现只有1个桃子了。问题:最初共多少个桃子?

// 参考 答案 
//先自己想
public class RecursionExercise01 { 
	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);
		// } 
		// 
		//桃子问题
		int day = 0;
		int peachNum = t1.peach(day);
		if(peachNum != -1) {
			System.out.println("第 " + day + "天有" + peachNum + "个桃子");
		}
	}
}

class T {
		/*
		请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n，求出它的值是多
		思路分析
		1. 当n = 1 斐波那契数 是1
		2. 当n = 2 斐波那契数 是1
		3. 当n >= 3  斐波那契数 是前两个数的和
		4. 这里就是一个递归的思路
		 */
	
		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个桃子了。问题：最初共多少个桃子？
		
		思路分析 逆推
		1. day = 10 时 有 1个桃子
		2. day = 9 时  有 (day10 + 1) * 2 = 4
		3. day = 8 时  有 (day9 + 1) * 2 = 10
		4. 规律就是  前一天的桃子 = (后一天的桃子 + 1) *2//就是我们的能力
		5. 递归
		 */
		public int peach(int day) { 
			if(day == 10) {//第10天，只有1个桃
				return 1; 
			} else if ( day >= 1 && day <=9 ) {
				return (peach(day + 1) + 1) * 2;//规则，自己要想
			} else {
				System.out.println("day在1-10");
				return -1;
			}
		}	
}

6.4.5 递归调用应用实例-迷宫问题

思路：
使用递归回溯的思想来解决老鼠出迷宫
1. findWay方法就是专门来找出迷宫的路径如果找到，就返回 true ,否则返回false
2. map 就是二维数组，即表示迷宫， i,j 就是老鼠的位置，初始化的位置为(1,1)
3. 因为我们是递归的找路，所以我先规定 map数组的各个值的含义：0 表示可以走， 1 表示障碍物， 2 表示可以走， 3 表示走过，但是走不通是死路
4. 当map[6][5] =2 就说明找到通路,就可以结束，否则就继续找.
5. 先确定老鼠找路策略下->右->上->左


public class MiGong { 
	public static void main(String[] args) {
		//1. 先创建迷宫，用二维数组表示 
		int[][] map = new int[8][7];
		//2. 先规定 map 数组的元素值: 0 表示可以走 1 表示障碍物 
		int[][] map = new int[8][7];
		//3. 将最上面的一行和最下面的一行，全部设置为1
		for(int i = 0; i < 7; i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}
		//4.将最右面的一列和最左面的一列，全部设置为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("\n====找路的情况如下=====");

		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  {	
	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 boolean findWay2(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(findWay2(map, i - 1, j)) {//先走上
					return true;
				} else if(findWay2(map, i, j + 1)){//右
					return true;
				} else if(findWay2(map, i+1, j)) {//下
					return true;
				} else if(findWay2(map, i, j-1)){//左
					return true;
				} else {
					map[i][j] = 3;
					return false;
				}
			} else { //map[i][j] = 1 , 2, 3
				return false; 
			}
		}
	}
}

6.4.6 递归调用应用实例-汉诺塔

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
在这里插入图片描述


public class HanoiTower { 
	public static void main(String[] args) {
		Tower tower = new Tower();
		tower.move(64, 'A', 'B', 'C');
	}
}

class Tower {
	//方法
	//num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔
	public void move(int num , char a, char b ,char c) {
		//如果只有一个盘 num = 1
		if(num == 1) {
			System.out.println(a + "->" + c);
		} else {
			//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
			//(1)先移动上面所有的盘到 b, 借助 c
			move(num - 1 , a, c, b);
			//(2)把最下面的这个盘，移动到 c
			System.out.println(a + "->" + c);
			//(3)再把 b塔的所有盘，移动到c ,借助a
			move(num - 1, b, a, c);
		}
	}
}

6.4.7 递归调用应用实例-八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

八皇后思路分析：

第一个皇后先放第一行第一列
第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继
续放在第二列、第三列、依次把所有列都放完，找到一个合适
继续第三个皇后,还是第一列、第二列….….直到第8个皇后也能放
在一个不冲突的位置,算是找到了一个正确解
当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即
将第一个皇后,放到第一列的所有正确解,全部得到.
然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3.4的步骤【示意图】

说明:理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.arr[8]={0,4.7,5.2,6,1,3}//对应arr下标表示第几行，即第几个皇后，arrti]= val , val表示第i+1个皇后，放在第i+1行的第val+1列

6.5 方法重载(OverLoad)

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

重载的好处

减轻了起名的麻烦
减轻了记名的麻烦

6.5.1 注意事项和使用细节

方法名:必须相同
形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
返回类型:无要求

6.5.2 练习

编写程序，类Methods中定义三个重载方法并调用。方法名为m。三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法。OverLoadExercise.java
在Methods类，定义三个重载方法max()，第一个方法，返回两个int值中的最大值，第二个方法，返回两个double值中的最大值，第三个方法，返回三个double值中的最大值，并分别调用三个方法。


public class OverLoadExercise { 
	public static void main(String[] args) {
		//在主类的main ()方法中分别用参数区别调用三个方法
		Methods method = new Methods();
		method.m(10);//100
		method.m(10, 20);//200
		method.m("韩顺平教育 hello");//字符串信息

		//测试
		System.out.println(method.max(10, 24)); // 24
		System.out.println(method.max(10.0, 21.4)); // 21.4
		System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
	}
}

/*
编写程序，类Methods中定义三个重载方法并调用。方法名为m。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法


定义三个重载方法max()，第一个方法，返回两个int值中的最大值，
第二个方法，返回两个double值中的最大值，第三个方法，
返回三个double值中的最大值，并分别调用三个方法
 */
class Methods {
	//分析
	//1 方法名 max
	//2 形参 (int,int) 
	//3.int
	public int max(int n1, int n2) {
		return n1 > n2 ? n1 : n2;
	}

	//分析
	//1 方法名 max
	//2 形参 (double,double) 
	//3.double
	public double max(double n1, double n2) {
		return n1 > n2 ? n1 : n2;
	}

	//分析
	//1 方法名 max
	//2 形参 (double,double,double) 
	//3.double
	public double max(double n1, double n2, double n3) {
		
		System.out.println("max(double n1, double n2, double n3)");
		//求出n1 和  n2的最大值
		double max1 = n1 > n2 ? n1 : n2;
		return max1 > n3 ? max1 : n3;
	}

	public double max(double n1, double n2, int n3) {	
		System.out.println("max(double n1, double n2, int n3)");
		//求出n1 和  n2的最大值
		double max1 = n1 > n2 ? n1 : n2;
		return max1 > n3 ? max1 : n3;
	}
	
	//分析
	//1 方法名 m
	//2 形参 (int) 
	//3.void
	public void m(int n) {
		System.out.println("平方=" + (n * n));
	} 

	//1 方法名 m
	//2 形参 (int, int) 
	//3.void
	public void m(int n1, int n2) {
		System.out.println("相乘=" + (n1 * n2));
	}

	//1 方法名 m
	//2 形参 (String) 
	//3.void
	public void m(String str) {
		System.out.println("传入的str=" + str);
	}
}

6.6 可变参数

6.6.1 简介

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

语法：

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

//案例演示
public class VarParameter01 { 
	public static void main(String[] args) {
		HspMethod m = new HspMethod();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class Method {
	//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;
	}
}

6.6.2 注意事项和使用细节

可变参数的实参可以为0个或任意多个。
可变参数的实参可以为数组。
可变参数的本质就是数组.
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
一个形参列表中只能出现一个可变参数

6.6.3 练习

有三个方法，分别实现返回姓名和两门课成绩(总分)，返回姓名和三门课成绩(总分)，返回姓名和五门课成绩(总分)。封装成一个可变参数的方法


public class VarParameterExercise { 
	public static void main(String[] args) {
		HspMethod hm = new HspMethod();
		System.out.println(hm.showScore("milan" , 90.1, 80.0 ));
		System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
	}
}

class HspMethod  {

	/*
	有三个方法，分别实现返回姓名和两门课成绩(总分)，
	返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	 */
	
	//分析1. 方法名 showScore  2. 形参(String ,double... ) 3. 返回String
	//听课小伙伴，老师要求必须自己动手写
	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;
	}
 }

6.7 作用域

6.7.1 基本使用

面向对象中，变量作用域是非常重要知识点，相对来说不是特别好理解，要求深刻掌握变量作用域。

在java编程中，主要的变量就是属性(成员变量)和局部变量。
我们说的局部变量一般是指在成员方法中定义的变量。【举例Cat类:cry)
java中作用域的分类
全局变量:也就是属性，作用域为整个类体Cat类:cry eat等方法使用属性
局部变量:也就是除了属性之外的其他变量，作用域为定义它的代码块中!
全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。

6.7.2注意事项和细节使用

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量,生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
作用域范围不同
全局变量/属性: 可以被本类使用，或其他类使用(通过对象调用)
局部变量: 只能在本类中对应的方法中使用
修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符


public class VarScopeDetail { 
	public static void main(String[] args) {
		Person p1 = new Person();
		/*
		属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
		局部变量，生命周期较短，伴随着它的代码块的执行而创建，
		伴随着代码块的结束而销毁。即在一次方法调用过程中
		 */
		//p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
		//name局部变量就销毁,但是属性(全局变量)仍然可以使用
		//
		T t1 = new T();
		t1.test(); //第1种跨类访问对象属性的方式
		t1.test2(p1);//第2种跨类访问对象属性的方式
	}
}

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

	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}

class Person {
	//细节: 属性可以加修饰符(public protected private..)
	//      局部变量不能加修饰符
	public int age = 20;
	String name = "jack";
	public void say() {
		//细节 属性和局部变量可以重名，访问时遵循就近原则
		String name = "king";
		System.out.println("say() name=" + name);
	}

	public void hi() {
		String address = "北京";
		//String address = "上海";//错误,重复定义变量
		String name = "hsp";//可以
	}
}

6.8 构造方法/构造器

6.8.1 基本介绍

我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

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

 说明：

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成


public class Constructor01 { 
	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;
	}
}

6.8.2 注意事项和使用细节

一个类可以定义多个不同的构造器,即构造器重载,比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名,不需要指定年龄
构造器名和类名要相同
构造器没有返回值
构造器是完成对象的初始化并不是创建对象
在创建对象时,系统自动的调用该类的构造方法
如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Dog(){},使用javap指令反编译看看
一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器,除非显式的定义一下,即:Dog(){} 写(这点很重要)

6.8.3 练习


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

/**
 * 在前面定义的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;
	}
}

6.9 对象创建的流程分析

class Person{ //类Person
	int age=90;
	String name;
	Person(String n,int a){ //构造器
		name=n;//给属性赋值
		age=a; //..
	}
}
Person p=new Person("小倩”,20);

流程分析(面试题)

加载Person类信息(Person.class)，只会加载一次
在堆中分配空间(地址)
完成对象初始化 [3.1默认初始化 age=0 name=null 3.2显式初始化age=90,name=null,3.3构造器的初始化 age =20, name=小倩]
在对象在堆中的地址,返回给p(p是对象名,也可以理解成是对象的引用)

6.10 this 关键字

什么是this
java虚拟机会给每个对象分配 this,代表当前对象。可以理解为对象隐藏的属性，指向对象本身。

// 演示
public class This01 { 
	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 就是当前对象的属性name
		this.name = name;
		//this.age 就是当前对象的属性age
		this.age = age;
		System.out.println("this.hashCode=" + this.hashCode());
	}

	public void info(){//成员方法,输出属性x信息
		System.out.println("this.hashCode=" + this.hashCode());
		System.out.println(name + "\t" + age + "\t");
	}
}

class Dog{
	public String name;
	public int age;
	public Dog(String name, int in_age){
		this.name = name;
		this.age = in_age;
	}
	public void info(){
		System.out.println(this.name + "\t" + this.age
+ "\t"+"当前对象的hashcode是:" + this.hashCode());"
	}
}	
//使用hashCode()看看对象的情况

this小结:简单的说,哪个对象调用，this就代表哪个对象
java不能直接打印看到对象的地址（虚拟机上运行的），可以间接用hashcode代替，返回对象的哈希码值（一般是将对象内部地址转换成一个整数实现）

在这里插入图片描述

6.10.1 this 的注意事项和使用细节

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

6.10.2 this 案例


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

/*
定义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;
	}
}

6.11 本章作业

编写类A01，定义方法max，实现求某个double数组的最大值，并返回
编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，并返回索引,如果找不到,返回-1.
编写类Book，定义方法updatePrice，实现更改某本书的价格，具体:如果价格>150,则更改为150，如果价格>100,更改为100，否则不变
编写类AO3,实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
定义一个圆类Circle,定义属性:半径，提供显示圆周长功能的方法，提供显示圆面积的方法
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示)并创建两个对象，分别测试
设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show()显示其信息。并创建对象，进行测试、【提示 this.属性】
定义Music类，里面有音乐名name、音乐时长times属性，并有播放play功能和返回本身属性信息的功能方法getlnfo.
创建一个Employee类，属性有(名字，性别，年龄，职位，薪水)，提供3个构造方法，可以初始化(1)(名字，性别，年龄，职位，薪水),(2)(名字，性别，年龄)(3(职位，薪水)，要求充分复用构造器
将对象作为参数传递给方法。要求:
(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()方法，调用完毕后输出当前半径值。程序运行结果如图所示，老韩提示，如果还是不明确，自己画一个内存图，一定可以搞定
有个人Tom设计他的成员变量.成员方法,可以电脑猜拳,电脑每次都会随机生成0,1,2
0表示石头1表示剪刀2表示布并要可以显示Tom的输赢次数(清单)

binrui996

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第 6 章面向对象编程(基础)

/方法使用 //1. 方法写好后，如果不去调用(使用)，不会输出 //2. 先创建对象 ,然后调用方法即可 Person p1 = new Person();//调用方法 p1 . cal01();//调用cal01方法 p1 . cal02(5);//调用cal02方法，同时给n = 5 p1 . cal02(10);...
复制链接

扫一扫