第七章面向对象编程

news2024/12/23 17:06:30

第七章面向对象编程
7.1对象在内存中存在形式
在这里插入图片描述
7.1.1属性/成员变量/字段(field)
1.属性=成员变量=字段field,概念上相等

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

2.属性是类的一个组成部分,一般是基本数据类型,也可以是引用类型(对象、数组)
1)属性定义语法同变量,访问修饰符 属性类型 属性名;
2)属性的定义类型可以为任意类型,包含基本类型或引用类型
3)属性如果不赋值,有默认值,规则和数组一致,具体说: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;
}

7.1.2如何创建对象
1)先声明再创建
Cat cat;//声明对象cat
cat = new Cat();//创建
2)直接创建Cat cat = new Cat();

7.1.3如何访问属性
基本语法:对象名.属性名
例如:cat.name;
类和对象的内存分配机制(重要)
在这里插入图片描述
在这里插入图片描述
7.1.4类和对象的内存分配机制
java内存结构分析
1)栈:一般存放基本数据类型(局部变量)
2)堆:存放对象(Cat cat,数组等)
3)方法区:常量池(常量,比如字符串),类加载信息
java创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10
1)先加载Person类信息(属性和方法信息,只会加载一次)
2)在堆中分配空间,进行默认初始化
3)把地址赋给p,p指向对象
4)进行指定初始化,比如p.name = ‘‘jack’’
在这里插入图片描述
7.2成员方法
在某些情况下,我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄,姓名…),我们人类还有一些行为比如:可以说话、跑步…,通过学习,还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善。
7.2.1成员方法快速入门
Method01.java

  1. 添加 speak 成员方法,输出 “我是一个好人” 2) 添加 cal01 成员方法,可以计算从 1+…+1000 的结果
  2. 添加 cal02 成员方法,该方法可以接收一个数 n,计算从 1+…+n 的结果
  3. 添加 getSum 成员方法,可以计算两个数的和
    代码
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;
	}
}

7.2.2成员方法的好处

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

7.2.3成员方法定义
访问修饰符 返回数据类型 方法名(形参列表…) {//方法体
语句;
return 返回值;
}

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

访问修饰符 (作用是控制 方法使用的范围)
如果不写默认访问,[有四种: public, protected, 默认, private]

返回数据类型

  1. 一个方法最多有一个返回值 [返回多个结果可以返回数组 ]
    例如:
public int[] getSumAndSub(int n1, int n2) {
	int[] resArr = new int[2]; //
	resArr[0] = n1 + n2;
	resArr[1] = n1 - n2;
	return resArr;
}
  1. 返回类型可以为任意类型,包含基本类型或引用类型(数组,对象)
  2. 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
  3. 如果方法是 void,则方法体中可以没有 return 语句,或者 只写 return ;

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

形参列表
1.一个方法可以有0个参数也可以有多个参数,中间用逗号隔开,比如 getSum(int n1,int n2)
2.参数类型可以为任意类型,包含基本类型或引用类型,比如 printArr(int[][] map)
3.调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型 的参数![getSum]
4.方法定义时的参数称为形式参数,简称形参;方法调用时的传入参数称为实际参数,简称实参实参和形参的类型要一致或兼容、个数、顺序必须一致!

方法体
里面写完成功能的具体的语句,可以为输入。输出、变量、运算、分支、循环、方法调用,但里面不能再定义方法!即:方法不能嵌套定义。

方法调用细节说明(!!!)
1.同一个类中的方法调用: 直接调用即可。
2.跨类中的方法A类调用B类方法: 需要通过对象名调用。比如 对象名.方法名(参数);
3.特别说明一下: 跨类的方法调用和方法的访问修饰符相关

7.2.4类的定义
class 类目{
属性(成员变量);
成员方法;
}

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(); //换行
		}
	}
}

7.3成员方法传参机制
7.3.1基本数据类型的传参机制
在这里插入图片描述

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

swap栈和main栈是独立的
在这里插入图片描述
7.3.2引用数据类型的传参机制
传的是地址

  1. 看一个案例 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();
	}
}

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

  1. 编写类 MyTools 类,编写一个方法可以打印二维数组的数据。
  2. 编写一个方法 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;
	}
}

7.4方法递归调用
7.4.1递归举例

  1. 打印问题
  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;
		}
	}
}

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

课堂练习:
1.请使用递归的方式求出斐波那契数1,1,2,3,5,8,13…给你一个整数n,求出它的值是多
2.猴子吃桃子问题: 有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个!以后每天猴子都吃其中的一半,然后再多吃一个。当到第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;
		}
	}
}

7.4.3递归调用应用实例—迷宫问题
在这里插入图片描述

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 {
	//使用递归回溯的思想来解决老鼠出迷宫
	//老韩解读
	//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 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;
				}
			}
		}
}

7.5方法重载
7.5.1基本介绍
java 中允许同一个类中,多个同名方法的存在,但要求 形参列表不一致!
比如:System.out.println(); out 是 PrintStream 类型
7.5.2重载的好处

  1. 减轻了起名的麻烦
  2. 减轻了记名的麻烦

7.5.3快速入门案例
OverLoad01.java
案例:类:MyCalculator 方法:calculate

  1. calculate(int n1, int n2) //两个整数的和
  2. calculate(int n1, double n2) //一个整数,一个 double 的和
  3. calculate(double n2, int n1)//一个 double ,一个 Int 和
  4. calculate(int n1, int n2,int n3)//三个 int 的和
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));
		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) 被调用");
	// int res = n1 + n2;
	// }
	//看看下面是否构成重载, 没有构成,而是方法的重复定义,就错了
	// public int calculate(int a1, int a2) {
	// System.out.println("calculate(int n1, int n2) 被调用");
	// return a1 + a2;
	// }
	//一个整数,一个 double 的和
public double calculate(int n1, double n2) {
	return n1 + n2;
}
//一个 double ,一个 Int 和
public double calculate(double n1, int n2) {
	System.out.println("calculate(double n1, int n2) 被调用..");
	return n1 + n2;
}
//三个 int 的和
public int calculate(int n1, int n2,int n3) {
	return n1 + n2 + n2;
	}
}

注意事项和使用细节:
1)方法名 : 必须相同
2)形参列表:必须不同(形参类型或个数或顺序,至少有一样不同,参数名无要求)
3)返回类型:无要求

7.6可变参数
7.6.1基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。就可以通过可变参数实现
7.6.2基本语法
访问修饰符 返回类型 方法名(数据类型… 形参名) {
}
7.6.3快速入门案例(VarParameter01.java)
看一个案例 类 HspMethod,方法 sum 【可以计算 2 个数的和,3 个数的和 , 4. 5, 。。】

public class VarParameter01 {
//编写一个 main 方法
	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 HspMethod {
	//可以计算 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. 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;
		}
}

注意事项和使用细节:
1)可变参数的实参可以为0个或任意多个
2)可变参数的实参可以为数组。
3)可变参数的本质就是数组
4)可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
5)一个形考列表中只能出现-个可变参数

课题练习:
有三个方法,分别实现返回姓名和两门课成绩(总分),返回姓名和三门课成绩(总分),返回姓名和五门课成绩 (总分)。封装成一个可变参数的方法
类名 HspMethod 方法名 showScore

public class VarParameterExercise {
	//编写一个 main 方法
	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;
	}
}

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

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 = 1;
	String address = "北京的猫";
	System.out.println("num=" + num);
	System.out.println("address=" + address);
	System.out.println("weight=" + weight);//属性
	}
	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);//错误
	}
}

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

7.8构造方法/构造器
7.8.1看一个需求
我们来看一个需求:前面我们在创建人类的对象时,是先把一个对象创建好后,再给他的年龄和姓名属性赋值,如果现在我要求,在创建人类的对象时,就直接指定这个对象的年龄和姓名,该怎么做? 这时就可以使用构造器。
7.8.2基本语法
[修饰符] 方法名(形参列表){
方法体;
}

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

7.8.3基本介绍
构造方法又叫构造器(constructor),是类的一种特殊的方法,它的主要作用是完成对新对象的初始化。它有几个特点:

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

7.8.4快速入门
现在我们就用构造方法来完成刚才提出的问题:在创建人类的对象时,就直接指定这个对象的年龄和姓名

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

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

课堂练习:
在前面定义的 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);
		}
		}
		/**
		* 在前面定义的 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;
		}
}

7.10this关键字
在这里插入图片描述
this 的注意事项和使用细节:

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

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/126888.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

数据防泄露之图文档及业务数据经验分享

场景描述 信息化时代发展迅速&#xff0c;数据防泄露一词也频繁的出现在我们身边。无论企业或政府单位&#xff0c;无纸化办公场景越来越多&#xff0c;数据泄露的时间也层出不穷。例如&#xff1a;世界最大职业中介网站Monster遭到黑客大规模攻击&#xff0c;黑客窃取在网站注…

跟着pink老师学JS的第三天总结

* 这个仿京东的商品放大镜效果真不好做&#xff01; 鼠标拖拽&#xff1a; * 代码&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"…

FineReport报表设计工具- 配置DB2外接数据库(1)

1. 概述 1.1 版本 报表服务器版本 功能变更 11.0 - 11.0.3 1&#xff09;首次配置外接数据库时&#xff0c;支持自行选择是否「迁移数据至要启用的数据库」 2&#xff09;迁移外接数据库的过程提示细化&#xff0c;方便用户了解迁移进度 1.2 功能简介 报表系统配置外接数…

Seata使用教程

文章目录一、Seata简介1.Seata 概念介绍2.分布式事务3.Seata核心组件4.Seata 工作流程5.Seata四大模式二、Seata实战教程1.下载资源2.配置Seata-Server3.增加相关表结构4.代码配置三、常见报错解决一、Seata简介 1.Seata 概念介绍 Seata 是一款阿里巴巴开源的分布式事务解决方…

eNSP 设备启动失败,错误代码:40 解决方案

eNSP 路由器启动失败&#xff0c;错误代码&#xff1a;40 解决方案 eNSP 路由器启动失败&#xff0c;错误代码&#xff1a;40 解决方案 文章目录eNSP 路由器启动失败&#xff0c;错误代码&#xff1a;40 解决方案一、出现错误代码&#xff1a;40二、解决方法1.确定相关的软件安…

《设计模式》外观模式

《设计模式》外观模式《设计模式》设计模式的基本原则 《设计模式》单例模式 《设计模式》工厂模式 《设计模式》原型模式 《设计模式》建造者模式 《设计模式》适配器模式 《设计模式》桥接模式 《设计模式》装饰者模式 《设计模式》组合模式 《设计模式》外观模式 定义&#…

免费刷题!初级软件测试面试题目和答案这个小程序很全

有没有软件测试面试题库小程序&#xff1f;相信这是很多准备找工作的新手测试人都想要知道的吧&#xff01; 今天&#xff0c;我就根据大家的需求&#xff0c;为大家整理了一些有关初级软件测试的面试题目以及一个可以免费刷题的题库&#xff0c;希望能帮助你们早日拿下心仪的…

UDS-10 Diagnostic and communication management functional unit

10 诊断与通信管理功能单元 来自&#xff1a;ISO 14229-1-2020.pdf 10.1概述 表22指定了诊断和通信管理功能单元。 注&#xff1a; DiagnosticSessionControl&#xff1a;客户端请求控制服务器的诊断会话。ECUReset&#xff1a;客户端强制服务器执行重置。SecurityAccess&am…

知识蒸馏原理

文章目录0.知识蒸馏&#xff08;模型压缩的一种方法&#xff09;1.蒸馏2.为什么要蒸馏3.知识的表示与迁移4.蒸馏温度T5.知识蒸馏过程6.知识蒸馏的应用场景7.知识蒸馏背后的机理8.为什么用soft targets 而不用 label smoothing?9.知识蒸馏的研究方向10.知识蒸馏代码库11.扩展阅…

回顾2022,展望2023,笔耕不辍,钟情翰墨

目录 回顾2022 博客概览 博客成就 获得测试领域优质创作者认证 获得博客专家认证 获得额外收入 创建第一个属于自己的个人社区 获得第一个实体奖牌【博客专家】 首次登榜梦想照进现实CSDN实体奖牌榜 首次参与社区新锐和社区先锋评选 开启了6个知识体系系列教程 个人…

2023春招面试:消息中间件面试题整理

RabbitMQ如何确保消息发送 &#xff1f; 消息接收&#xff1f; 开启生产者确认机制&#xff0c;确保生产者的消息能到达队列&#xff08;config机制保证消息正确到达交换机、return机制保证消息正确到达队列&#xff09;开启持久化功能&#xff0c;确保消息未消费前在队列中不会…

如何通过WindowsIIS部署网站

1.winR输入control 打开【控制面板】 2.选择程序 3.选择【启用或关闭Windows功能】 4.在【Windows功能】对话框中勾选【Internet Information Services】下的【FTP服务器】、【Web管理工具】和【万维网服务】中的所有选项&#xff0c;并点击【确定】 5.Windows功能会开始下载并…

Lambda表达式的来龙去脉,全在这篇文章里了

一. 前言部分 大家都知道Lambda表达式作为JAVA 8中提供的新特性之一&#xff0c;在现在的企业开发中已经非常的流行了。今天壹哥就通过一个具体的案例&#xff0c;来带大家一起详细地探究一下Lambda表达式是如何被提出来的&#xff0c;以及它的出现主要是用来解决什么问题的。…

乌班图(Ubuntu)单系统或者乌班图+Win双系统安装教程

单ubuntu系统安装 1、将ubuntu系统U盘插入电脑USB接口&#xff0c;建议优先插USB3.0蓝色(彩色)接口&#xff0c;这样可以保证安装过程中文件的读取速度&#xff0c;加快安装进程。 2、然后电脑关机状态下&#xff0c;开机。开机后快速按主机的快捷启动键&#xff1a; 3、在出现…

Qt编写雷达模拟仿真工具1-背景布局

一、前言 雷达模拟仿真工具&#xff0c;整体结构采用的QGraphicsView框架&#xff0c;背景布局采用的分层绘制&#xff0c;这样可以控制该需要重新绘制的重新绘制&#xff0c;不需要重新的绘制的就没必要再多余的浪费&#xff0c;这里定义了一个GraphicsBackGroundItem类继承自…

Spring框架(容器)--简介(实现原理、核心模块、组成部分)

spring框架&#xff08;容器&#xff09; spring简介 1、Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言&#xff0c;任何Java应用都可以从Spring中受益。 2、Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 3、轻量——从大小…

Creo9.0 Windows 3D建模工具

前言 creo9.0正式版是一款非常优秀的3D建模设计软件。该软件界面美观&#xff0c;提供了CAD 技术、模制造绘图、多实体建模、多体设计、实时仿真、框架和焊缝设计等一系列强大的辅助设计功能&#xff0c;通过这些功能&#xff0c;让用户轻松解决设计中带来的各种问题。 下载 …

律所管理系统的功能以及作用分别有哪些?

在全球进入信息化的时代&#xff0c;随着网络的普及与发展&#xff0c;网络所带来的信息交流与利用的优势愈发明显。尤其是随着法律制度的不断健全和人民法律意识的提高&#xff0c;涉及法律诉讼的案件也在不断地增加&#xff0c;律师事务所作为中介的法律机构&#xff0c;要处…

字符设备驱动(一)

1.Linux设备分类 linux的文件种类&#xff1a; -&#xff1a;普通文件 文件内容文件名元信息&#xff08;文件的相关属性—组织在inode的一个结构体内&#xff09; d&#xff1a;目录文件 p&#xff1a;管道文件 s&#xff1a;本地socket文件 l&#xff1a;链接文件 软链接&am…

4 内部类实例

内部类 内部类的分类&#xff1a; 成员内部类方法内部类局部内部类匿名类静态内部类 1 成员内部类 是在一个类中声明的类&#xff0c;包含内部类的是外围类 成员内部类的访问权限&#xff1a; public可以在外围类的外部使用内部类创建对象private只能在外围类的内部使用内…