java-第一阶段-JavaSE-Day06-方法、方法的重载。数组、数组的应用_.利用方法的重载,在一个类中,定义多个方法可以求出两个int整数, 两个double小数,-CSDN博客

本文链接：https://blog.csdn.net/huangluyang123/article/details/120421797

一、方法

（一）方法的概述

1.方法的概念

具有某种特定功能的代码段；某代码功能经常使用，因此使用大括号，将这段代码包起来，起个名字。

2.方法的处

1）提高代码的复用性

2）提高代码的封装性，大括号中的内容，其他调用者看不到也无法直接访问，但是可以调用

3）简化了软件设计的思维难度

（二）方法的创建

1.格式

修饰符返回值类型方法名称（参数列表）{

方法体语句；

return 语句；

}

2.详细解释

1）修饰符：目前全部写成public static

2）返回值类型：表示方法运行结果的数据类型，当方法功能运行完毕，有可能会有产出，就需要将产出的数据类型作为方法的返回值类型，返回给调用者，如果不需要返回结果，使用关键字void，表示方法没有任何返回值类型。

3）方法名称：合法标识符即可，小驼峰命名法

4）参数列表：从方法外传入的数据。如果有多个，用逗号连接

5）方法体语句：真正要完成该方法功能的执行逻辑

6）return 语句：最终产出的结果，要返回给调用者，使用return语句返回 return 数据；如果没有任何生产内容void，可以不写return或者写return；用于表示方法结束。

示例：

public class Demo01	{
	public static void main(String[] args) {
		//定义一个方法，求任何两个整数的和
  		//定义一个方法，打印HelloWorld
		//调用方法输出两个数的和，并给出参数值
		System.out.println(sum(10,20));
  		//调用无返回值方法
		printHello();
	}
 //定义求和方法，有返回值，返回值类型int，两个参数a，b
	public static int sum(int a,int b){
		int r=a + b;
  		//return返回语句，有返回值的方法中必须有
		return r;
	}
 //定义无返回值方法，直接调用，可以不写return。
	public static void printHello(){
		System.out.println("HelloWorld");
	}
}

（三）方法调用

1.格式：

有参数：方法名称（实际参数）；

无参数：方法名（）；

2.方法调用的三种形式

3.方法调用的总体特点

方法不调用，就不执行，只要调用就会执行。

示例：

public class Demo02 {
	public static void main(String[] args) {
		int a=10,b=20;
  		//赋值调用
		int max = getMax(a,b);
  		//打印调用
		System.out.println(max);
  		//直接调用
		daBaoJian(18);
	}
	public static int getMax(int a,int b){
		int max=a > b?a : b;
		return max;
	}
	public static void daBaoJian(int age){
		if(age>=18){
			System.out.println("成年");
		}else{
			System.out.println("未成年");
		}
	}
}

（四）方法定义注意事项

1.方法定义注意事项

1）方法不能嵌套定义，不能在一个方法中直接写另一个方法

2）方法的先后没有区别，都是平级关系

3）方法可以嵌套调用（在一个方法中调用另一个方法），甚至可以自己调用自己（危险）

2.参数列表

1)形式参数(形参):在定义方法时使用,需要加上数据类型的参数，也就是对于变量进行声明.各个变量之间，使用逗号分隔.

例如:sum(int a，int b)此时a和b就是形式参数，就是为了告诉方法的调用者，你调用方法需要传入什么类型数据，形参和变量还是有区别的:形参定义的时候也没有赋值,但是可以在方法使用.变量不赋值不能使用.

2)实际参数(实参):在方法调用时使用的数据,不能加上数据类型的参数，也就是对于变量进行赋值.各个实际参数之间，也使用逗号分隔,顺序必须和定义的方法的形式参数的顺序一致，数据类型也要和定义的形参类型一致.

调用传入的实际数据,就是实参.

3.return语句：

1) return 语句表示方法结束了，也同时表示方法的产出结果.

2)如果方法没有具体的返回内容(也就是返回值类型是void),可以写成return;, 表示提前结束方法，此时的return语句可以省略,返回值类型必须写成void.

3) 如果方法有具体的返回内容,那么return后面就需要加上返回具体数据,返回值类型必须和return语句后面数据的数据类型一致.

4)谁来调用当前方法，return语句就将当前方法的数据结果返回给谁.

5)return语句作用范围内,后面不要写代码,否则编译报错.

（五）方法的练习

我们根据是否有返回值和是否有参数，把方法分为四类：

示例：

public class Demo03 {
	public static void main(String[] args) {
		buyWine1();
		int b = buyWine2();
		System.out.println(b);
		buyWine3(2);
		System.out.println(buyWine4(10));
	}
 //无返回值，无参数
	public static void buyWine1(){
		System.out.println("买了个寂寞");
	}
 //有返回值，无参数
	public static int buyWine2(){
		return 1;
	}
 //无返回值，有参数
	public static void buyWine3(int a){
		System.out.println("跑路");
	}
 //有返回值，有参数
	public static int buyWine4(int money){
		return money/3;
	}
}

（六）方法的重载

1.方法的重载：Overload

概念：在同一个类中，多个方法：方法名相同，参数列表不同，与返回值类型无关的多个方法之间的关系，称为重载。

2.举例

示例：

public class Demo04 {
	public static void main(String[] args) {
 		//想做什么计算只需要记一个方法名getSum即可
		System.out.println(getSum(10,20));
	}
	public static int getSum(int a,int b){
		return a+b;
	}
	public static int getSum(int a,int b,int c){
		return a+b+c;
	}
	public static double getSum(double a,double b){
		return a+b;
	}
	public static double getSum(int a,double b){
		return a+b;
	}
	public static double getSum(double a,int b){
		return a+b;
	}
}

二、数组

（一）数组概述

1.数组含义：集中存储一组想同类型数据的容器

2.数组的特点：

1）存储数据长度固定的容器，也就是数组一旦定义，他的长度就不能变化了。

2）存储数据的数据类型要一致

数组常和for循环结合使用，提高操作的简便性

（二）创建数组

1.静态初始化

在创建数组时，直接将元素确定的定义方式，程序不需要运行，就明确的知道数组的每个元素是什么。

格式：

数组类型[] 数组名 = new 数据类型[]{元素1，元素2，...，元素n}；

简化格式：

数据类型[] 数组名 = {元素1，元素2，...，元素n}；

注意事项：

1）在第二个方括号中不能写数组元素个数；

2）元素值的罗列，元素和元素之间使用逗号隔开；

3）罗列出来的元素值，数据类型必须和声明数组时的数据类型一样。

示例:

public class Demo07 {
	public static void main(String[] args) {
 		//定义数组
		int[] arr={1,2,3};
  		//打印数组元素
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		
	}
}

2.动态初始化

含义：只指定数组长度，不指定数组元素值

数组定义：

数据类型[] 数组名称 = new 数据类型[数组长度]；

数据类型数组名称[] = new 数据类型[数组长度]；

详细解释：

数据类型：创建的数组容器可以存储什么数据类型

[]：表示数组，数组标志。

数组名称：数组本身也是一个变量，用于存储数组地址的变量名

=：赋值符号，将数组的地址赋值给数组名称

new：关键字，创建数组使用的关键字，用于在堆内存中给数组开辟存储数据的空间

数据类型：和前一个保持一致

数组长度：表示数组容器中可以存储多少个元素

示例：

public class Demo05 {
	public static void main(String[] args) {
 		//定义数组，数组长度为5
		int[] arr1=new int[5];
		System.out.println(arr1);
  		//length打印数组长度
		System.out.println(arr1.length);
  		//给数组元素值，索引从零开始
		arr1[0]=10;
		arr1[1]=20;
		arr1[2]=30;
		arr1[3]=40;
		arr1[4]=50;
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println(arr1[3]);
		System.out.println(arr1[4]);
		int arr2[]=new int[5];
		System.out.println(arr2);
	}

（三）数组的访问格式

1.元素：指的是数组中每个数据

2.索引。每个元素都有自己的编号，从0开始，这个自动编号成为索引，可以通过数组的索引访问数组中的元素。索引范围：0~数组长度-1.

3.数组的长度属性（元素的个数）：每个数组都具有长度。数组名.length

4.索引访问数组中的元素：

数组名[索引] = 数值；为数组中的元素赋值 arr[0] = 10;

变量 = 数组名 [索引]；获取数组中的元素 a = arr[0];

示例：

public class Demo06 {
	public static void main(String[] args) {
		int[] arr1=new int[3];
		arr1[0]=1;
		arr1[1]=2;
		arr1[2]=3;
		int a = arr1[0];
		System.out.println(a);
	}
}

练习：

1.定义一个5个元素数组,通过键盘录入的方式为每个元素赋值. 并求出所有元素的和.

import java.util.Scanner;
public class Home4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] array=new int[5];
		int sum = 0;
		for(int i = 0;i < array.length;i++){
			array[i]=sc.nextInt();
		}
		for(int i = 0;i < array.length;i++){
			sum += array[i];
		}
		System.out.println(sum);
	}
}

2.利用方法的重载,在一个类中,定义多个方法可以求出两个int整数, 两个double小数, 两个long整数的最小值.

public class Home3 {
	public static void main(String[] args) {
		System.out.println(min(3,4));
		System.out.println(min(3.0,4.0));
		System.out.println(min(10,40));
	}
	public static int min(int a,int b){
		int min = a<b?a:b;
		return min;
	}
	public static double min(double a,double b){
		double min = a<b?a:b;
		return min;
	}
	public static long min(long a,long b){
		long min = a<b?a:b;
		return min;
	}
}