Javase面向对象2：可变参数、重载、方法参数传递、递归、对象数组

疯丰

已于 2022-05-10 08:26:14 修改

阅读量122

点赞数 1

分类专栏：大数据之javase基础文章标签： java 开发语言

于 2022-05-06 22:22:28 首次发布

本文链接：https://blog.csdn.net/weixin_43498449/article/details/124619876

版权

大数据之javase基础专栏收录该内容

29 篇文章 7 订阅

订阅专栏

1. 笔记

1.1 可变参数

1.可变参数
    对数组的参数做的简化操作（在调用处有简化）
    语法：数据类型...变量名
    注意：
        a.可变参数当做数组去使用就可以
        b.一个方法中可变参数必须是参数列表的最后一个
        c.可变参数的实参都必须符合数据类型
    练习：
        1.n个数int中找最大值
        2.n个字符串拼接（无缝拼接）  javabigdatamysql
        3.n个字符串拼接（有间隔符拼接） java+bigdata+mysql

1.2 方法的重载

1.方法的重载 ☆
   最终的好处：解决我们相同类型方法，起方法名的问题
   方法的要求：在同一个类中，不允许出现两个相同的方法
   要求：
       a.同一个类中，方法名可以相同
       b.但是形参列表必须不同（个数，顺序 ——> 类型）任何一个不同就可以
       c.和返回值无关
       d.和访问修饰符无关（还没讲）
   重载方法调用的时候，先找完全符合的，找不到完全符合的，找兼容的！
   如果有多个兼容的就报错！
   同类型的数组和可变参数是相同的东西

1.3 方法参数传递

1.参数的传递机制
  形参：在方法定义位置，指定的形式参数
  实参：在调用方法时，需要指定实际的参数
  参数的传递机制：实参赋给形参的过程

1.4 递归方法

1.递归（需要方法的知识）
  属于循环的一种？
  1.1 直接递归
      方法自己调用自己
  1.2 间接递归
      A->B->C->A
      java.lang.StackoverflowError  内存溢出错误
   递归一定要有窗口！
      需求：打印3次好好学习，天天向上！并且将该需求的内存图画出

   出现宕机:
      ①优化代码
      ②加机器

1.5 对象数组

对象数组的技术要求和普通数组都是一样的！
int[] arras=new int[5];  //基本数据类型的数据
String[] strs=new String[5]; //引用数据类型的数组
Person[] pers=new Person[5]; //引用数据（自定义）类型的数组
    对象数组的默认值是null
    该数组的元素，存储的是Person对象（Person对象的地址）

2. 练习

2.1 可变参数练习

练习一：找最大值

需求：定义求1-n个整数中的最大值

public class ChangeArgs_Exer1 {
	public static void main(String[] args) {
		Count c = new Count();
		System.out.println(c.max(1));
		System.out.println(c.max(5,3,2,6));
	}
}
class Count{
	public int max(int num, int... others){
		int max = num;
		for (int i = 0; i < others.length; i++) {
			if(max < others[i]){
				max = num;
			}
		}
		return max;
	}
}

练习二：字符串拼接

需求：定义将n个字符串进行拼接，如果没有传入字符串，那么返回空字符串

public class ChangeArgs_Exer2 {
	public static void main(String[] args) {
		StringUtil su = new StringUtil();
		System.out.println(su.concat());
		System.out.println(su.concat("hello","world"));
	}
}
class StringUtil{
	public String concat(String... args){
		String str = "";
		for (int i = 0; i < args.length; i++) {
			str += args[i];
		}
		return str;
	}
}

练习三：字符串拼接2

需求：定义将n个字符串进行拼接，每一个字符串之间使用某字符进行分割，如果没有传入字符串，那么返回空字符串

public class ChangeArgs_Exer4 {
	public static void main(String[] args) {
		StringUtil su = new StringUtil();
		System.out.println(su.concat('+'));
		System.out.println(su.concat('+',"hello","world"));
	}
}
class StringUtil{
	public String concat(char seperator, String... args){
		String str = "";
		for (int i = 0; i < args.length; i++) {
			if(i==0){
				str += args[i];
			}else{
				str += seperator + args[i];
			}
		}
		return str;
	}
}

2.2 方法的重载练习

方法重载练习一：比较连个数据是否相等

需求：比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试。

public class Method_Demo6 {
    public static void main(String[] args) {
        //创建
        Count c = new Count();
        
        //定义不同数据类型的变量
        byte a = 10;
        byte b = 20;
        short c = 10;
        short d = 20;
        int e = 10;
        int f = 10;
        long g = 10;
        long h = 20;
        // 调用
        System.out.println(c.compare(a, b));
        System.out.println(c.compare(c, d));
        System.out.println(c.compare(e, f));
        System.out.println(c.compare(g, h));
    }
}

class Count {
        // 两个byte类型的
    public boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 两个short类型的
    public boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 两个int类型的
    public boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    // 两个long类型的
    public boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

方法重载练习二：求各种最大值

用重载实现：定义方法求两个整数的最大值

定义方法求三个整数的最大值

定义方法求两个小数的最大值

//求两个整数的最大值
public int max(int a,int b){
    return a>b?a:b;
}
	
//求三个整数的最大值
public int max(int a, int b, int c){
    return max(max(a,b),c);
}
	
//求两个小数的最大值
public double max(double a, double b){
    return a>b?a:b;
}

方法重载练习三：判断两个方法是否是合理的重载方法

//判断如下两个方法是否构成重载：是
class StringUtil{
	public String concat(char seperator, String... args){
		String str = "";
		for (int i = 0; i < args.length; i++) {
			if(i==0){
				str += args[i];
			}else{
				str += seperator + args[i];
			}
		}
		return str;
	}
	public String concat(String[] args){
		String str = "";
		for (int i = 0; i < args.length; i++) {
			str += args[i];
		}
		return str;
	}
}

//判断如下两个方法是否构成重载：不是
class Count{
	public int getSum(int... nums){
		int sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
	public int getSum(int[] nums){
		int sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
}

class Test06_Overload_Problem2{
	public static void main(String[] args){
		Count c = new Count();
		System.out.println(c.sum(1,2));//(int a, int b)
		System.out.println(c.sum(1,2,3));//(int... args)和(int a, int... args)都兼容，就有问题了
	}
}
//Count类编译没问题，但是调用者有问题
class Count{
	public int sum(int a, int b){
		return a+b;
	}
	public int sum(int... args){
		int sum = 0;
		for(int i=0; i<args.length; i++){
			sum += args[i];
		}
		return sum;
	}
	public int sum(int a, int... args){
		int sum = a;
		for(int i=0; i<args.length; i++){
			sum += args[i];
		}
		return sum;
	}	
}

2.3 递归方法练习

练习一：求n！

public class RecursionMethod2{
	public static void main(String[] args) {
		Count c = new Count();
		
		int jieCheng = c.jieCheng(10);
		System.out.println("10的阶乘是：" + jieCheng);
	}
}
class Count{
	public int jieCheng(int n){
		if(n <= 1){
			return 1;
		}else{
			return n * jieCheng(n-1);
		}
	}
}

练习二：计算斐波那契数列（Fibonacci）的第n个值

规律：一个数等于前两个数之和，

f(0) =1，

f(1) = 1，

f(2) = f(0) + f(1) =2，

f(3) = f(1) + f(2) = 3,

f(4) = f(2) + f(3) = 5

...

f(n) = f(n-2) + f(n-1);

public class RecursionMethod3{
	public static void main(String[] args) {
		Count c = new Count();
		
		System.out.println("f(10)：" + c.f(10));
		System.out.println("f方法被调用的总次数：" + c.total);
	}
}
class Count{
	int total = 0;
	public int f(int n){
		total++;
		if(n <= 1){
			return 1;
		}else{
			return f(n-2) + f(n-1);
		}
	}
}

2.4 对象数组练习

练习一：对象数组的内存图分析

练习二：

（1）定义学生类Student

声明姓名和成绩实例变量，

getInfo()方法：用于返回学生对象的信息

（2）测试类ObjectArrayTest的main中创建一个可以装3个学生对象的数组，并且按照学生成绩排序，显示学生信息

public class ObjectArrayTest {
	public static void main(String[] args) {
		Student[] arr = new Student[3];
		arr[0] = new Student();
		arr[0].name = "张三";
		arr[0].score = 89;
		
		arr[1] = new Student();
		arr[1].name = "李四";
		arr[1].score = 84;
		
		arr[2] = new Student();
		arr[2].name = "王五";
		arr[2].score = 85;
		
		for (int i = 1; i < arr.length; i++) {
			for (int j = 0; j < arr.length-1; j++) {
				if(arr[j].score > arr[j+1].score){
					Student temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i].getInfo());
		}
	}
}
class Student{
	String name;
	int score;
	public String getInfo(){
		return "姓名：" + name + ",成绩：" + score;
	}
}

class Test18_ObjectArrayExer2_2{
	public static void main(String[] args){
		//创建一个可以装3个学生对象的数组
		Student[] arr = new Student[3];//只是申明这个数组，可以用来装3个学生，此时里面没有学生对象
		
		//从键盘输入
		java.util.Scanner input = new java.util.Scanner(System.in);
		for(int i=0;i<arr.length; i++){
			System.out.println("请输入第" + (i+1) + "个学生信息：");
			arr[i] = new Student();
			
			System.out.print("姓名：");
			arr[i].name = input.next();
			
			System.out.print("成绩：");
			arr[i].score = input.nextInt();
		}
		
		//先显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i].getInfo());
		}
		
		System.out.println("------------------------------------------");
		//冒泡排序
		for(int i=1; i<arr.length; i++){
			for(int j=0; j<arr.length-i; j++){
				//arr[j] > arr[j+1]//错误的
				if(arr[j].score > arr[j+1].score){
					//交换两个元素，这里是两个学生对象，所以temp也得是Student类型
					Student temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		//再显示一下目前的顺序
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i].getInfo());
		}
	}
}
class Student{
	String name;
	int score;//使用int或double都可以
	
	public String getInfo(){
		return "姓名：" + name +"，成绩：" + score;
	}
}

练习三：

（1）定义圆Circle类，包含radius半径属性，getArea()求面积方法，getPerimeter()求周长方法，String getInfo()返回圆对象的详细信息的方法

（2）在测试类中创建长度为5的Circle[]数组，用来装5个圆对象，并给5个圆对象的半径赋值为[1,10)的随机值

class Test16_ObjectArray{
	public static void main(String[] args){
		//要在数组中存储5个圆对象
		//声明一个可以用来存储圆对象的数组
		Circle[] arr = new Circle[5];
		//for(int i=0; i<arr.length; i++){
		//	System.out.println(arr[i]);
		//}
		//System.out.println(arr[0].radius);//NullPointerException
		
		//给元素赋值
		//元素的类型是：Circle，应该给它一个Circle的对象
		//arr[0] = 1.2;//错误的
		//arr[0]相当于它是一个Circle类型的变量，也是对象名
		/*
		arr[0] =  new Circle();
		arr[0].radius = 1.2;
		System.out.println(arr[0].radius);
		*/
		
		//创建5个对象，半径随机赋值为[1,10)的随机值
		//Math.random()==>[0,1)
		//Math.random()*9==>[0,9)
		//Math.random()*9+1==>[1,10)
		for(int i=0; i<arr.length; i++){
			arr[i] = new Circle();//有对象才有半径
			arr[i].radius = Math.random()*9+1;
		}
		
		
		//遍历显示圆对象的信息
		for(int i=0; i<arr.length; i++){
			//arr[i]是一个Circle的对象，就可以调用Circle类中的属性和方法
			System.out.println(arr[i].getInfo());
		}
	}
}
class Circle{
	double radius;
	public double getArea(){
		return 3.14 * radius * radius;
	}
	public double getPerimeter(){
		return 3.14 * 2 * radius;
	}
	public String getInfo(){
		return "半径：" + radius +"，面积：" + getArea() + "，周长：" + getPerimeter();
	}
}

疯丰

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Javase面向对象2：可变参数、重载、方法参数传递、递归、对象数组

目录1. 笔记1.1 可变参数1.2 方法的重载1.3 方法参数传递1.4 递归方法1.5 对象数组2. 练习2.1 可变参数练习2.2 方法的重载练习2.3 递归方法练习2.4对象数组练习1. 笔记1.1 可变参数1.可变参数对数组的参数做的简化操作（在调用处有简化）语法：数据类型...变量名注意： a.可变参数当做数组去使用就可以 b.一个方法中可变参数必须是参数列表的最后一..
复制链接

扫一扫