Java开发Day09

最新推荐文章于 2024-09-14 18:46:05 发布

Madelana

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量124

点赞数

文章标签： java

本文链接：https://blog.csdn.net/madelana/article/details/104879524

版权

一、回顾——方法的定义和调用

定义格式：

public static void 方法名称（）{
	方法体
}

调用格式

方法名称();

注意事项：
3-1. 方法定义要在main()函数外且先后顺序无所谓
3-2. 方法定义必须是挨着的，不能在一个方法的定义内部定义另外一个方法（方法定义不能嵌套）
3-3. 方法定义之后，自己不会执行，如果希望执行，一定要在main()函数中调用

示例：打印一个20行5列的*号

public static void main(String[] args){
/**
*调用方法
*/
	printMethod();
}
/**
*定义方法
*/
public static void printMethod(){
	for(int rows = 0; rows<20; rows++){
		for(int colums = 0; colums<5; colum++){
/**
*在同一行打印*号
*/
		System.out.print("*");
	}
/**
*起换行作用
*/
	System.out.println();
}
}

二、方法的定义与调用

方法其实就是若干个语句的功能集合
参数和返回值：

方法好比是一个工厂
参数就是原料——进入方法的数据
返回值就是产出物——从方法中出来的数据

定义方法的完整形式

/**
*修饰符：现阶段的固定写法——public static 
*返回值类型：方法最终产生的数据结果是什么类型
*方法名称；方法的名字，命名规则和变量一样——小驼峰命名法
*参数类型：进入方法的数据是什么类型的
*参数名称：进入方法的数据对应的变量名称
*参数如果有多个，用，分隔
*return：两个作用（1）停止当前方法（2）将返回值还给调用处
*返回值：方法执行后产生的数据结果，return后面的返回值必须和方法
*名称前面的返回值类型相对应
*/
修饰符 返回值类型 方法名称（参数类型 参数名称，···）{
	方法体
	return 返回值；
}

方法的三种调用格式
（1）单独调用：方法名称（参数）；
（2）打印调用：System.out.println(方法名称（参数）);
（3）赋值调用：数据类型变量名称 = 方法名称（参数）；
注意：此前学习的方法，返回值类型为void，这种方法只能单独调用，不能进行打印调用或者赋值调用
示例：定义一个两个int类型的数字相加的方法

/**
*三要素：
*返回值类型；int
*方法名称；sum
*参数列表：int a, int b
*/
public static void main(String[] args){
	int a = 1;
	int b = 2;
/**
*单独调用，但是返回的结果并没有打印，只是简单的返回至此
*/
	sum(a,b);
/**
*打印调用，方法返回的结果将会被打印出来
*/
	System.out.println(sum(a,b));
/**
*赋值调用，返回的结果将被赋值给变量result
*/
	int result = sum(a,b);
	System.out.println(result);
}
/**
*定义方法
*/
public static int sum(int a, int b){
	int result;
	result = a + b;
	return result;
}

对比有参数和无参数：
（1）有参数：小括号当中有内容。当一个方法需要一些数据条件才能完成任务的时候，就是有参数。例如两个数字相加，必须知道这两个数字是谁才能进行相加的任务
（2）无参数：小括号当中留空。当一个方法不需要任何数据条件，自己能独立完成任务，就是无参数。例如定义一个方法，打印固定10次的HelloWorld

public static void main(String[] args){
/**
*调用有参方法
*/
	double result = multiple(10,20,30);
	System.out.println(result);
/**
*调用无参方法
*/
	printString();
}
/**
*定义一个有参数的方法：三个数字相乘
*/
public static double multiple(double a, double b, double c){
	double result = a*b*c;
	return result;
}
/**
*定义一个无参数的方法：打印10次文本字符串
*/
public static void printString(){
	for(int i = 0; i<10; i++){
		System.out.println("I still love you,GM"+i);
	}
}

对比有返回值和无返回值
（1）有返回值：你（自定义方法）帮我（main方法）算，算完之后把结果告诉我。例如：定义一个方法，用来求出三个数字之和
（2）无返回值：自定义方法自己做完就OK了，不用告诉main方法。例如：定义一个方法，用来打印两个数之和
（3）注意事项：对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用；但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用

public static void main(String[] args){
	double result;
/**
*调用有返回值的方法
*/
	result = getsum(10,20,30);
	System.out.println(result);
/**
*调用无返回值的方法
*/
	printSum(10,20);
}
/**
*有返回值的方法，返回double类型的值。谁调用我，我就把结果告诉谁
*/
public static double getsum(double a, double b, double c){
	double result;
	result = a + b + c;
	return result;
}
/**
*定义一个无返回值的方法：打印两个数之和。我没有返回值，即使调用我了，我也只是自己一个人把活干完就行了
*/
public static void printSum(double a, double b){
	double sum = a+b;
	System.out.println(sum);
}

有无返回值总结：
方法有无返回值对比

三、方法练习

定义一个方法，用来判断这两个数字是否相等。

三要素：
返回值类型：boolean
方法名称：isSame
参数列表：int a,int b

public static void main(String[] args){
/**
*将打印false
*/
	System.out.println(isSame(10,20));
}
public static boolean isSame(int a, int b){
	return a==b;
}

定义一个方法，用来求出1~100之间整数的和的结果

三要素：
返回值：有返回值，int
方法名称：getSum
参数列表:数据范围已经固定，所以不需要主方法告诉我任何条件、任何数据，所以不需要参数

public static void main(String[] args){
	System.out.println("结果是："+getSum());
}
public static int getSum(){
	int sum = 0;
	for(int i = 1; i<=100; i++){
	sum += i;
	}
	return sum;
}

定义一个方法，打印指定次数的HelloWorld

返回值：只是打印，没有什么结果要告诉调用处
方法名称：printCount
参数列表：到底要打印多少次？你必须告诉我要打印多少次。因此参数及类型是int a

public static void main(String[] args){
	int a = 10;
/**
*无返回值的方法只能单独调用
*/
	printCount(a);
}
public static void printCount(int a){
	for(int i = 0; i<a;i++){
		System.out.println("HelloWorld"+(i+1));
	}
}

四、使用方法的注意事项

方法应该定义在类当中，main方法之外，而且方法定义不能嵌套
方法定义的前后顺序无所谓
方法定义之后不会自动执行，如果希望执行，一定要在main方法中调用：单独调用、打印调用、赋值调用
如果方法有返回值，那么必须要写上 return 返回值；
return后面的返回值的数据类型，必须和方法的返回值类型相对应
对于一个void没有返回值的方法，return后面不能写返回值，只能写return ;

public static void method2{
/**
*可以不写return，如果非要写，return后面就不能写返回值
*在这里的return ；只是结束方法的执行而已
*/
	return ;
}

一个方法可以有多个return，但是必须保证每次只有一个return被执行

public static int getMax(int a, int b){
	if(a>b){
		return a;
	}
	else{
		return b;
	}
}

五、方法的重载(OverLoad)

概念：多个方法的名称一样，但是参数列表不一样
参数列表不一样的含义：

参数个数不同
参数类型不同
参数的多类型顺序不同

方法重载与下列因素无关：

与参数名称无关
与方法的返回值类型无关

public static void main(String[] args) {
/*
*调用有4个参数的那个方法
*/
        System.out.println(sum(10,20,30,40));
/*
*调用有3个参数的方法
*/

          System.out.println(sum(10,20,30));
/*
*调用有2个参数的方法
*/
            System.out.println(sum(10,20));
/*
*调用双精度浮点型参数的方法
*/
            System.out.println(sum(10.0,20.0));
/*
*调用先double后int参数的那个方法
*/
              System.out.println(sum(10.0,20));
/*
*调用先int后double参数的那个方法
*/
                System.out.println(sum(10,20.0));
    }

    public static int sum(int a, int b){
        System.out.println("两个参数");
        return a+b;
    }

    public static int sum(int a, int b, int c){
        System.out.println("三个参数");
        return a+b+c;
    }

    public static int sum(int a, int b, int c, int d){
        System.out.println("四个参数");
        return a+b+c+d;
    }
    public static int sum(double a, double b){
    System.out.println("这是双精度浮点型的参数");
    return (int)(a+b);
    }
    public static int sum(int a, double b){
    System.out.println("这是先int后double的");
    return (int)(a+b);
    }
      public static int sum(double a, int b){
    System.out.println("这是先double后int的");
    return (int)(a+b);
    }

六、方法重载练习

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

 public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        short c = 20;
        short d = 20;
        int e = 1;
        int f = 2;
        long g = 23;
        long h = 20;
        System.out.println(isSame(a, b));
        System.out.println(isSame((short)20, d));
        System.out.println(isSame(e, f));
        System.out.println(isSame(10L, (long)10));

    }

    public static boolean isSame(int a,int b){
        System.out.println("两个int类型的参数");
        return a==b;
    }

    public static boolean isSame(short a,short b){
        System.out.println("两个short类型的参数");
        boolean same;
        if(a==b)
        {
            same = true;
        }
        else{
            same = false;
        }
        return same;
    }

    public static boolean isSame(long a,long b){
        System.out.println("两个long类型的参数");
        boolean same = a==b?true:false;
        return same;
    }
    public static boolean isSame(byte a,byte b){
        System.out.println("两个byte类型的参数");
        if(a==b){
            return true;
        }
        else{
            return false;
        }
    }

模拟输出语句中的println方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名println

//当我们查看println()的源码的时候，我们会发现当我们调用输出的时候，其实就是println()方法进行了多种数据类型的重载
public class OverLoadPrint {
    public static void main(String[] args) {
        String str="I love you, GM.";
        myPrint(100);
        myPrint(str);
        myPrint(10L);
        myPrint((short)3);
        myPrint(10.0);
        myPrint((float)30);
        myPrint(true);
        myPrint('a');
        myPrint("I love China!!!");

    }

    public static void myPrint(String str){
        System.out.println(str);
    }

    public static void myPrint(int a){
        System.out.println(a);
    }

    public static void myPrint(long a){
        System.out.println(a);
    }

    public static void myPrint(short a){
        System.out.println(a);
    }

    public static void myPrint(char ch){
        System.out.println(ch);
    }

    public static void myPrint(double a){
        System.out.println("double"+a);
    }

    public static void myPrint(float a){
        System.out.println("float"+a);
    }

    public static void myPrint(boolean is){
        System.out.println(is);
    }

}