java 方法&数组

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带回一个值

例题：

1. 键盘录入两个数据，返回两个数中的较大值

2. 键盘录入两个数据，比较两个数是否相等

3. 键盘录入三个数据，返回三个数中的最大值

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;
}  

}