Java-day09(面向对象上2 匿名对象方法的重载值传递可变个数形参递归方法 )

最新推荐文章于 2022-04-12 11:23:11 发布

vid。

最新推荐文章于 2022-04-12 11:23:11 发布

阅读量212

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_44742328/article/details/108325291

版权

Java 专栏收录该内容

49 篇文章 2 订阅

订阅专栏

一、理解“万事万物皆对象”

1.在Java语言范畴中.我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。
>Scanner，String等
>文件：File
>网络资源：URL
2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在java层面交互时，都体现为类、对象.

二、内存解析的说明

1.引用类型的变量，只肯呢个存储两类值，地址值或null（含变量类型).
在这里插入图片描述

三、匿名对象

1.理解：我们创建的对象，没有显式的赋给一个变量名，即匿名对象.
2.特征：匿名对象只能调用一次.
3.使用:如下

public class InstanceTest {
public static void main(String[] args) {
	
	phone p = new phone();
	p.sendEmail();
	p.playgame();
	
	//匿名对象
	new phone().sendEmail();
	new phone().playgame();
	
	new phone().price = 1999;
	new phone().show();//0.0 与上一行代码是两个对象
	
	phonemall mall = new phonemall();
	//匿名函数的使用
	mall.show(new phone());			
	}
}

class phonemall{
	public void show(phone a) {
		a.sendEmail();
		a.playgame();
	}
}

class phone{
	double price;
	
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	
	public void playgame() {
		System.out.println("打游戏");
		}
	
	public void show() {
		System.out.println("手机价格为："+price);
	}
}

开发中，我们一般这样用：
在这里插入图片描述
这里就相当于将一个匿名对象赋给了一个有名的对象.在show函数里面可以多次使用，但是在函数外只能的使用一次.

四、功能函数与调用函数分开

package com.acoffee.java;

public class Arraytest {
	public static void main(String[] args) {
		Arraypackage util = new Arraypackage();
		int[] arr = new int[] {32,1,23,45,42,-23,-40,332};
		int max = util.getMax(arr);
		System.out.println("最大值："+max+"\t");
		
		System.out.print("排序前：");
		util.print(arr);
		
		util.sort(arr);
		System.out.print("排序后：");
		util.print(arr);
	}
}

public class Arraypackage {
	//求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for(int i = 1;i < arr.length; i++) {
			if(maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}
	
	//求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for(int i = 1; i < arr.length; i++) {
			if(minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}
	
	//求数组的总和
	public int getSum(int[] arr) {
		int sum = 0;
		for(int i = 0; i < arr.length; i++) {
			sum += arr[i]; 
		}
		return sum;
	}
	
	//求数组的平均值
	public int getAverage(int[] arr) {
		return getSum(arr)/arr.length;
	}
	
	//反转数组
	public void reverse(int[] arr) {
		for(int i = 0; i < arr.length/2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}
	
	//复制数组
	public int[] copy(int[] arr) {
		int[] arr1 =new int[arr.length];
		for(int i = 0;i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return arr1;
	}
	
	//数组排序
	public void sort(int[] arr) {
		//冒泡排序
		for(int i = 0; i < arr.length - 1; i++)
			for(int j = 0; j < arr.length - 1 - i;j++ ) {
				if(arr[j] > arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	
	//遍历数组
	public void print(int[] arr) {
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}
	
	//查找指定元素
	public int getIndex(int[] arr,int dest) {
		for (int i = 0; i < arr.length; i++) {
			if(dest == arr[i]) {
				return i;
			}
		}
		return -1;
	}
}

执行结果：
在这里插入图片描述
但是这个只能对int型数组进行操作，如果我们要对string型的数组进行操作，我们只能重新写一个string方法的数组。

public void sort(int[] arr)

跟上述的排序名字是一样的但是传的参数不一样，即方法的重载.

方法的重载

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

“两同一不同”：同一个类、相同方法名.
参数列表不同：参数个数不同，参数类型不同.
2.举例：
Arrays类中重载的dort/binarySearch()
3.判断是否重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。
4.在通过对象调用方法时，如何确定某一个指定的方法：
方法名 → 参数列表

public class OverLoadTest {
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1,2);
	}
	//如下四个方法都是重载
	public void getSum(int i,int j) {
		System.out.println("1");
	}	
	
	public void getSum(double d1,double d2) {
		System.out.println("2");
	}
	public void getSum(String s,int i) {
		System.out.println("3");	
	}
	public void getSum(int i,String s) {
		System.out.println("4");		
	}
}

其实println也是一种重载
在这里插入图片描述

可变个数形参

/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 *   2.1 可变个数形参的格式：数据类型 ... 变量名
 *   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *   2.5 可变个数形参在方法的形参中，必须声明在末尾
 * 	 2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。
 * 
 */
public class MethodArgsTest {
	public static void main(String[] args) {
		
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
		test.show("aaa","bbb");
		
	}
	
	public void show(int i) {
		System.out.println(i);
	}
	
	public void show(String...stus) {
		for(int i = 0; i < stus.length; i++) {
		System.out.println(stus[i]);
		}
	}
	public void show(int i,String...stus){
	
	}
}

方法参数的值传递机制

在这里插入图片描述
形参是基本数据类型：

public class ValueTest {
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		
		ValueTest t = new ValueTest();
		t.swap(m, n);
		System.out.println(m +","+ n);//10,20
	}
	
	public void swap(int m,int n) {
		int temp = m;
		m = n;
		n = temp;
		System.out.println(m +","+ n);//20,10
	}
}

这里运行方法后是没有交换成功的原因是：这里的情况就是实参直接将自己的值传给了形参，而不是地址值，所以形参交换了而实参并没有交换.因为这里的参数是基本数据类型

形参是引用数据类型：

public class ValueTest1 {
	public static void main(String[] args) {
		Data data = new Data();
		
		data.m = 10;
		data.n = 20;
		
		System.out.println("m ="+ data.m +",n = "+data.n);//10,20
		ValueTest1 test = new ValueTest1();
		test.swap(data);
		System.out.println("m ="+ data.m +",n = "+data.n);//20,10
	}
	public void swap(Data data) {
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}

class Data{
	int m;
	int n;
}

这种就交换成功了，因为这里直接是让形参也指向了与实参一样的地址，所以就交换成功了.

但是如果是string类型的就不是这种情况了.

public class ValueTranferTest{
	public static void main(String[] args){
		String s1 = "Hello";
		ValueTransferTest test = new ValueTranferTset();
		test.change(s1);

		System.out.println(s1);//Hello
	}
	public void change(String s){
		s = "hi";
	}
}

String 是引用数据类型但是我们输出的为什么不是hi呢？
在这里插入图片描述
String创建的对象在方法区,原因如图.
练习：

结果是：15 0 20

练习题：

一：
在这里插入图片描述
二：

public class Circle {
	double radius;
	
	public double findArea() {
		return Math.PI*radius*radius;
	}
}

public class PassObject {
	public static void main(String[] args) {
		PassObject test = new PassObject();
		
		Circle c = new Circle();
		
		test.printAreas(c,5);
		System.out.println("now radius is   "+ c.radius);
		
	}
	public void printAreas(Circle c ,int time) {
		
		System.out.println("Radius\t\tArea");
		
		for(int i = 1; i <= time; i++) {
			c.radius = i;
			System.out.println(c.radius+ "\t\t" +c.findArea());
			
		}
		c.radius = time + 1;
	}
}

执行结果：
在这里插入图片描述

递归（recursion）方法

public class recursion {
	public static void main(String[] args) {
		//递归方法1（求和）
		recursion rec = new recursion();
		int sum1 = rec.getSum(100);
		System.out.println(sum1);
		
		//递归方法2（求乘积）
		int sum2 = rec.getSum1(10);
		System.out.println(sum2);
		//打印1 - 100之间所有自然数之和
		int sum = 0;
		for(int i = 1;i <= 100;i++) {
			sum += i;
		}
		System.out.println(sum);
	}
	//用递归的方法来完成1-100之间所有自然数的相加
	public int getSum(int n) {
		if(n == 1) {
			return 1;
		}else{
			return n + getSum(n - 1);
		}
	}
	//递归方法完成乘积
	public int getSum1(int n) {
		if(n == 1) {
			return 1;
		}else {
			return n*getSum1(n - 1);	
		}
	}
}

执行结果：
在这里插入图片描述

每日一练：

1. 什么是方法的重载？
“两同一不同”：同一个类、相同方法名；参数列表不同。
如何调用确定的方法：方法名→参数列表

2. 说明Java方法中的参数传递机制的具体体现？
基本数据类型：数据值
引用数据类型：地址值 (含变量的数据类型)
Person p1 = new Person(); eat();age
User u1 = p1;//编译错误 (逆向思维、反证法)
u1.eat() u1.age

3. 成员变量和局部变量在声明的位置上、是否有默认初始化值上、是否能有权限修饰符修饰上、内存分配的位置上有何不同？

4. 谈谈return关键字的使用
① 结束方法 ② 针对于有返回值的方法，return + 返回数据

vid。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-day09(面向对象上2 匿名对象方法的重载值传递可变个数形参递归方法 )

一、理解“万事万物皆对象”1.在Java语言范畴中.我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。>Scanner，String等>文件：File>网络资源：URL2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在java层面交互时，都体现为类、对象.二、内存解析的说明1.引用类型的变量，只肯呢个存储两类值，地址值或null（含变量类型).三、匿名对象1.理解：我们创建的对象，没有显式的赋给一个变量名，即匿名对象.2.特
复制链接

扫一扫