java 方法&数组

最新推荐文章于 2023-03-20 19:34:53 发布

uiki1230

最新推荐文章于 2023-03-20 19:34:53 发布

阅读量127

点赞数

分类专栏： JAVA 文章标签： java 后端

本文链接：https://blog.csdn.net/uiki1230/article/details/109134118

版权

JAVA 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

java 方法&数组

一、方法

1.1 方法概述

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我
们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
(方法就是完成特定功能的代码块)

1.2 方法的定义

定义格式：

修饰符 返回值类型 方法名 （参数列表）
｛ 代码（方法体）... 
   return ; ｝

定义格式解释：

修饰符：目前固定写法 public static
返回值类型用于限定返回值的数据类型
方法名一个名称，为了方便我们调用方法
参数类型限定调用方法时传入参数的数据类型
参数名是一个变量，接收调用方法时传入的参数
方法体完成功能的代码
return 结束方法以及返回方法指定类型的值
返回值程序被return带回的结果，返回给调用者

规则：

1）返回值类型明确功能结果的数据类型
修饰符返回值类型方法名（参数列表）｛代码（方法体）… return ; ｝
2）参数列表明确有几个参数，以及参数的类型

1.2.2例题求两数之和

public class Method_Demo2 
{ 
     public static void main(String[] args) 
{ // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数 
 // 并接收方法计算后的结果，返回值 
   int sum = getSum(5, 6); 
   System.out.println(sum); 
}
/*定义计算两个整数和的方法 返回值类型，
计算结果是int 参数：不确定数据求和，
定义int参数.参数又称为形式参数 */ 
  public static int getSum(int a, int b)
{
    return a + b; 
} 
}

1.3 有明确返回值的方法调用

有明确返回值的方法调用：
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式

方法定义注意事项
方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有return带回一个值

例题：

键盘录入两个数据，返回两个数中的较大值
键盘录入两个数据，比较两个数是否相等
键盘录入三个数据，返回三个数中的最大值

import java.util.Scanner;

public class HomeTest {

 
    public static void main(String[] args) {
        
         Scanner src = new Scanner(System.in);
	
		System.out.println("请输入第一个 int 类型数据:");
		int n1= src.nextInt();
		System.out.println("请输入第二个 int 类型数据:");
		int n2= src.nextInt();
		System.out.println("请输入第三个 int 类型数据:");
        int n3=src.nextInt();

		System.out.println("请输入第一个 int 类型数据:");
		int m= src.nextInt();
		System.out.println("请输入第二个 int 类型数据:");
		int n= src.nextInt();
		System.out.println("请输入第一个 int 类型数据:");
		int x= src.nextInt();
		System.out.println("请输入第二个 int 类型数据:");
		int y= src.nextInt();
		System.out.println("请输入第三个 int 类型数据:");
        int z=src.nextInt();
        
        //调用已经写好的方法 将实参传递进去
		int max =getMax(n1,n2,n3);//实参 ：n1 , n2 , n3由键盘录入的数据 
		boolean flag =compare(m,n);
		int max2=getMax1(x,y,z);
		
		//有返回值方法的输出 由赋值调用法输出
		System.out.println("Rusult1:"+max );
		System.out.println("------------------------" );
		System.out.println("Rusult:2"+flag);
		System.out.println("------------------------" );
		System.out.println("Rusult3:"+max2 );
	
        
    
	}
	//方法一：三目运算法
	//比较三个数最大值
	//有明确返回值类型的方法
	public static int getMax(int a,int b, int c)
		{   
			int temp = (a > b) ? a : b ;
		     int max = (temp > c) ? temp : c ;
		     return max ;
		}
		//判断两个数是否相等
		public  static boolean compare(int a,int b)
		{   
		    //
			return (a == b)?true:false;
		}
		//方法二：if....else
		//比较三个数最大值
		public static int getMax1(int a, int b, int c)
		{
			int max1 = 0;
			if(a >b)
			{
				if(a>c)
				{
					max1 = a;
				}else{
					max1 = c;
				}
			}else
			{
				if(b > c)
				{
					max1 = b;
				}else{
					max1 = c;
				}
			}
			return max1;
		}
}

1.4 没有明确返回值的方法调用

没有明确返回值的函数调用
其实就是void类型方法的调用
只能单独调用

例题：

1. 键盘录入行数和列数，输出对应的星形
2. 键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表



import java.util.Scanner;
class NoReturnDemo
{
	public static void main(String [] args)
	{   
	    //创建键盘录入对象
		Scanner src = new Scanner(System.in);
		
		//5行4列的星星矩阵
		//原始方法
		for(int i = 0; i <=5 ;i++)
		{
			for(int a = 0; a <=4; a++ )
			{
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println("-----------------------");
		
		//设定了 一个 打印*矩阵的 无返回值方法 现在进行 传参 就可进行使用
		printStar(4,9);
		System.out.println("-----------------------");
		//由键盘录入想打印几几乘法表的列数，并由定义好的方法实现
	    System.out.println("请您输入数列：");
		int k =src.nextInt();
		NN(k);
	}
	//无返回值的NN乘法表方法
	public static void NN(int k)
	{
		for(int w = 1; w <= k;w++)
		{
			for(int r=1; r <=w; r++)
			{
				System.out.print(w+"*"+r+"="+(w*r)+"\t");
			}
			System.out.println();
		}
	}
	//打印*的方法
	public static void printStar(int m, int n)
	{
		for(int x = 0; x <=m ;x++)
		{
			for(int y = 0; y <=n; y++ )
			{
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

1.5 方法重载

1.5.1 方法重载概述

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

1.5.2方法重载的特点

返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法

**例题：**判断哪些方法是重载关系。

public static void open(){} //正确重载
public static void open(int a){} //正确重载
static void open(int a,int b){} //与第8个冲突
public static void open(double a,int b){} 正确重载
public static void open(int a,double b){}//与第6个冲突
public void open(int i,double d){} //与第五个冲突
public static void OPEN(){} //它不报错，但它不是重载
public static void open(int i,int j){}//与第3个冲突

二、数组

2.1 数组概述

数组概念：
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义的格式：

格式1：数据类型[] 数组名;
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素值的。

2.2 数组的初始化

数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

2.3 动态初始化

初始化时只指定数组长度，由系统为数组分配初始值

格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

2.4 静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度。


格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

2.5数组中常见的两个小问题

数组越界异常
原因：使用数组时数组的索引值超出了数组的长度范围
解决：修改角标值即可。
空指针异常
原因：空指针异常,大部分就是你在使用对象的时候这个对象是一个null值.这时就会报出空指针异常.
解决：有一个null的对象调用了方法,使得系统提示空指针异常.那么就修改对应的出现了null的对象.

例题：

1)自定义一个数组,静态初始化 ,将数组遍历(依次输出数组中的每一个元素),将遍历使用功能完成!
输出的格式：[元素1,元素2，元素3…]

class ArryDemo3
{
	public static void main(String [] args)
	{int [] arr1 = {121,123,143,145,156,2244,555,667,887,88,99,2,3,4,5,6,9};
		 System.out.println(arr1.length);
		 System.out.println("----------------------------------------");
		 printArry(arr1);
	}
	//定义一个无返回值类型的方法 
	//遍历数组
	public static void printArry(int []arr1)
	 {
		 System.out.print("{") ;
		 for(int i=0; i<arr1.length; i++)//i是索引(角标)
		 {
		 
			if(i == arr1.length -1){
				
				System.out.println(arr1[i] +"}") ;
			}else{
				
				System.out.print(arr1[i] +", ") ;
			}
		 
		 }
	 }
	}

2)自定义数组{13,87,24,65,15}，获取获取最值(获取数组中的最大值最小值),将获取的最大值和最小值分别使用功能完成!

//无返回值方法实现
import java.util.Scanner;
class FunctionDemo1
{
	public static void main(String [] args)
	{
		int [] arr = {13,87,24,65,15};
		
		compareMax(arr);
		compareMin(arr);
	}
	public static void compareMax(int [] arr)
	{
		int index=0;
	    int max=arr[index];
		for(int i=0;i<arr.length;i++)
		{
			if(arr[i]>max)
		{
			//index = i;
			max =arr[i];
		}
		
		}
		System.out.println("max:"+max);
	}
	public static void compareMin(int [] arr)
	{
		int index=0;
	    int min=arr[index];
		for(int i=0;i<arr.length;i++)
		{
			if(arr[i]<min)
		{
			//index = i;
			min =arr[i];
		}
		
		}
		System.out.println("min:"+min);
	}
}

3)查询数组中的元素在数组索引值

/*
	数组的元素基本查找:
	   查询数组中的元素在数组索引值!  (有一定的耗时:从头查到末尾)
	   
	   查询的数组: 可以无序的,也可以有序
	   {11,22,33,44,55} ; 有序的
	   {13,87,65,24,57} ;//无序
	   
	   
	  假设:
		int[] arr =   {13,87,65,24,57}  ;
		
		查询65这个元素在数组中的出现的索引值!
*/

class ArrayTest5{
	public static void main(String[] args){
		
		//创建一个数组,静态初始化
		int[] arr =   {13,87,65,24,57}  ;
		
		//1)查询65这个元素在数组中的出现的索引值!（使用方法來完成）
		int index = getIndex(arr,65) ;
		System.out.println("index:"+index) ;
		System.out.println("------------") ;
		int index2 = getIndex(arr,650) ;
		System.out.println("index2:"+index2) ;
		System.out.println("------------") ;
		
		int index3 = getIndex2(arr,300) ;
		System.out.println("index3:"+index3) ;
		System.out.println("------------") ;
		int index4 = getIndex2(arr,13)  ;
		System.out.println("index4:"+index4) ;
	}
	
	//方式2:
	/*
		假设思想:
			1)假设找不到   
				定义一个变量 
				int index = -1 ;
			2)遍历数组,获取到每一个元素
				如果当前元素和要查询的元素一致的话
						改变index的值(将当前元素所在的角标值赋值给index)
						break ;
						
			3)找不到,直接返回index
	*/
	public static int getIndex2(int[] arr,int key){
		//假设找不到   
		int index = -1 ;
		//遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//获取到每一个元素
			//和key进行比较
			if(arr[x] == key){
				//找到了,改变index的值
				index = x ;
				break ;
			}
		}
		return index ;
	}
	
	/*
		两个明确:
		  1)明确返回值类型: int类型
		  2)明确参数类型以及参数个数:
		        int类型  两个参数: int[] arr , int key(元素)
	*/
	//参数1:要查询的数组
	//参数2:要查询的元素
	//方式1
	public static int getIndex(int[] arr,int key){
		//1)先去遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//每一个元素都获取到了
			//如果arr[x] 和可以 相等的话
			//直接返回x :角标即可!
			if(arr[x] == key){ //查询到了,返回x
				return x ;
			}
		}
		//写逻辑判断:
			//两种:true,成立
			//false,不成立

			//如果找不到,Java中给定一个负数即可!
			return -1 ;
	}
}

4)数组中元素逆序

/*
	数组的应用:
			数组的元素逆序	
	int[] arr = {13,87,65,24,57} ;
	
	中心思想:
		将13  arr[0]--57 arr[arr.length-1]互换
		将87 arr[1]---24 arr[arr.length-1-1]互换....
		...
		保证  数组的长度/2		
	
*/

class ArrayTest3{
	public static void main(String[] args){
			
			//创建一个数组,静态初始化!
			int[] arr = {13,87,65,24,57} ;
			System.out.println("数组逆序前:  ") ;
			printArray(arr) ;
			System.out.println("----------------") 
			System.out.println("数组逆序后:  ") ;
			reverse(arr) ;//逆序方法
			printArray(arr) ;//遍历(输出结果)
			
			
	}
	
	
	//定义一个方法:逆序的方法
	//两个明确
	//明确返回值类型:没有具体返回值类型 void代替
	//明确参数类型以及参数个数:int[] arr
	public static void reverse(int[] arr){
	
		//遍历数组:保证角标值小于数组长度/2
		for(int x = 0 ; x < arr.length/2 ; x ++){
			//中间变量方式互换
			int temp = arr[x] ;
			arr[x] = arr[arr.length-1-x] ; //后面的元素和前面的互换
			arr[arr.length-1-x] = temp ;
		}
		
		
	}
	
	
	
	//数组的遍历功能:
	public static void printArray(int[] arr){
		System.out.print("[") ;
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(x == arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				System.out.print(arr[x] +", ") ;
			}
		}
	}
}

5）数组元素查表法

/*
	数组元素查表法
	
			数组名称[index:角标]访问元素
	
	假设:
		字符串数组:  数据类型[] 数组名称 = new 数据类型[]{元素1,....} ;
		String[] strs = {"星期一","星期二",
						"星期三","星期四","星期五","星期六","星期天"} ;
	
需求:键盘录入数据:查询当前星期几
*/
//导包
import java.util.Scanner ;
class ArrayTest4{
	public static void main(String[] args){
		
		//字符串数组
		String[] strs = {"星期一","星期二",
						"星期三","星期四","星期五","星期六","星期天"} ;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请您输入一个数据(0-6):") ;
		int index = sc.nextInt() ;
		
		System.out.println("你要查询的是:"+strs[index]) ;
	}
}

2.6冒泡排序算法

冒泡排序思想 
		
两两比较,将较大的值往后放;第一次比较完毕,最大值就出现在最大索引处!
依次这样比较:
		
	规律:
		第一次:有0个不比
	    第二次:有1个不比
		...
		...
		比较的次数:数组长度-1次

class WayOfMaopao
{
	public static void main(String[] args)
	{ //定义数组，静态初始化
		int []arr ={24, 69 , 87 ,57,13};
		System.out.println("排序前：");
		printArry(arr);
		System.out.println("---------");
		System.out.println("排序后：");
		sort(arr);
		printArry(arr);
	}
	public static void printArry(int [] arr)
	{
		System.out.print("[");
		for(int  i = 0; i<arr.length-1 ; i++)
		{
			if(i==arr.length -1)
			{
			System.out.println(arr[i]+"]");
			}else
			{
				System.out.print(arr[i]+" ,");
			}
		
		}
	}
	public static void sort(int []arr)
	{
		for(int x =0; x< arr.length-1;x++)
		{
			for(int y=0; y<arr.length-1-x;y++)
			{
				if(arr[y]>arr[y+1])
				{
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] =temp;
				}
			}
		}
	}
}

2.7选择排序

package com.qianfeng_array;
/*
 * 选择排序的思想:
 * 		使用数组中0角标对应的元素依次和后面元素进行比较,小的值往前放,
 * 第一次比较完毕,最小值出现在最小索引处,依次这样比较,1角标对应的元素依次和后面元素比较.... ...
 * 
 * 规律:
 * 		比较的次数:数组长度-1次
 * */
public class ArrayDemo {

	public static void main(String[] args) {
		
		//创建一个数组,静态初始化
		int[] arr = {87,69,57,13,24} ;
		
		//排序之前
		System.out.println("排序之前:");
		//遍历 的功能
		printArray(arr) ;
		System.out.println("----------------------------");
		//单独调用
		System.out.println("使用方法完成,排序后:");
		selectSort(arr);
		
		//遍历
		printArray(arr);
	
	}
	
	//方法定义
	public static void selectSort(int[] arr) {
		for(int x = 0 ; x < arr.length-1 ;x ++) {//x=0,1,2,3
			for(int y = x +1 ; y < arr.length ; y ++) { //将元素一一获取进行排序
				if(arr[y] < arr[x]) {
					int temp = arr[x] ;
					arr[x] = arr[y] ;
					arr[y] = temp ;
				}
			}
		}
	}

	//遍历的功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x = 0 ; x < arr.length ; x ++) {
			//判断
			if(x == arr.length-1) {
				System.out.println(arr[x] + "]");
			}else {
				System.out.print(arr[x] +", ");
			}
		}
	}
}

2.8二维数组

2.8.1 二维数组概述

Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一
个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。由此可见：其实二维数组其实就是
一个元素为一维数组的数组。

2.8.2二维数组定义格式

格式1

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数 
举例： int[][] arr = new int[3][2]; 
定义了一个二维数组arr 
这个二维数组有3个一维数组，
名称是arr[0],arr[1],arr[2] 
每个一维数组有2个元素，
可以通过arr[m][n]来获取 表示获取第m+1个一维数组的第n+1个元素

格式2

数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组 
这一次没有直接给出一维数组的元素个数，可以动态的给出。 
举例： 
int[][] arr = new int[3][]; 
arr[0] = new int[2]; 
arr[1] = new int[3] ;
arr[2] = new int[1];

格式3

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式： 数据类型[][] 变量名 = {{元素…},{元素…},{元素…}}; 
举例： int[][] arr = {{1,2,3},{4,6},{6}};

2.8.3杨辉三角

/*
二维数组的应用:杨辉三角形
输出:
1
1 1
1 2 1
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1

//导包
import java.util.Scanner ;
class Array2Test{
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并接收数据
		System.out.println("请您输入一个数据:") ;
		int n = sc.nextInt() ;
		
		//定义二维数组,动态初始化
		int[][] arr = new int[n][n] ;
		
		//给二维数组中的数据赋值(给任何的一列和最后一列赋值) 
		//将定义二维数组遍历
		for(int x = 0 ; x < arr.length ; x ++){
			//赋值 
			//任何的一列和最后一列都是1
			arr[x][0] = 1 ;
			arr[x][x] = 1 ;
		}
		
		for(int x = 2 ;x < arr.length ; x ++){
			//内层循环
		
			for(int y = 1 ; y <=x -1; y ++){
				//中间的数据的值等于上一行的前一列+上一行的本列之和
				arr[x][y] = arr[x-1][y-1] + arr[x-1][y] ;
				
			}
		}
		
		//跟99乘法表规律:y的角标值 y<=x 的值
		for(int x = 0 ; x < arr.length ; x ++){
			for(int y = 0 ; y <=x ; y ++){ //x = 0 (第一行), y=0(第一列)  ,y<=1(0,1)
				System.out.print(arr[x][y] +"\t") ; //arr[0][0] arr[1][1]
			}
			System.out.println() ;
		}
	}
}

例题：

公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

import java.util.Scanner;
class ArryDemo
{
	public static void main(String[] args)
	{
		int [][]arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		int sum=printArry(arr);
		System.out.println("sum:"+sum);
		//printArry1(arr);
	}
	public static int  printArry(int [][]arr)
	{
		int sum = 0;
	for(int i = 0; i<arr.length;i++)
	{
		
			for(int x = 0;x<arr[i].length;x++)
		{   
	        sum +=arr[i][x];
		}
	}
	   return sum;
	}  
}

][y] ;

		}
	}
	
	//跟99乘法表规律:y的角标值 y<=x 的值
	for(int x = 0 ; x < arr.length ; x ++){
		for(int y = 0 ; y <=x ; y ++){ //x = 0 (第一行), y=0(第一列)  ,y<=1(0,1)
			System.out.print(arr[x][y] +"\t") ; //arr[0][0] arr[1][1]
		}
		System.out.println() ;
	}
}

}


**<u>例题：</u>**

公司年销售额求和
	某公司按照季度和月份统计的数据如下：单位(万元)
	第一季度：22,66,44
	第二季度：77,33,88
	第三季度：25,45,65
	第四季度：11,66,99

import java.util.Scanner;
class ArryDemo
{
public static void main(String[] args)
{
int [][]arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum=printArry(arr);
System.out.println(“sum:”+sum);
//printArry1(arr);
}
public static int printArry(int [][]arr)
{
int sum = 0;
for(int i = 0; i<arr.length;i++)
{

		for(int x = 0;x<arr[i].length;x++)
	{   
        sum +=arr[i][x];
	}
}
   return sum;
}

}

uiki1230

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

java 方法&数组

java 方法&数组

文章目录

一、方法

1.1 方法概述

1.2 方法的定义

1.2.2例题求两数之和

1.3 有明确返回值的方法调用

1.4 没有明确返回值的方法调用

1.5 方法重载

1.5.1 方法重载概述

1.5.2方法重载的特点

二、数组

2.1 数组概述

2.2 数组的初始化

2.3 动态初始化

2.4 静态初始化

2.5数组中常见的两个小问题

例题：

2.6冒泡排序算法

2.7选择排序

2.8二维数组

2.8.1 二维数组概述

2.8.2二维数组定义格式

2.8.3杨辉三角