方法及方法的重载|数组

方法

方法:
注意:
1.方法不调用不执行
2.方法定义在类中方法外,方法不能嵌套

有返回值类型：	
public class Method02{ 
	public static void main(String[] args){ 
		//调用
		getPI();
		//赋值调用
		double d=getPI();
		System.out.println(d);
		//输出调用
		System.out.println(getPI());
		System.out.println(getSum(8,5));
	}
	//定义一个方法,返回一个pi的值
	//返回值:需要 double     参数: 没有参数
	public static double getPI(){
		System.out.println("这是一个有返回值,没有参数的方法");
		return 3.1415926;
	}
	//求2个整数的和
	//返回值:有 int		参数:2个 int a,int b
	public static int getSum(int a,int b){
		System.out.println("这是一个有返回值,有参数的方法");
		return a+b;
	}
}

无返回值类型：

public class Method03{ 
public static void main(String[] args){ 
	getSum(1,100);
}
public static void print(){
	for(int i=1;i<=9;i++){
		for(int j=1;j<=i;j++){
			System.out.print(j+"*"+i+"="+i*j+"\t");
		}
		System.out.println();
	}
}
public static void getSum(int min,int max){
	if(min>max){
		System.out.println("第一个参数不能>第二个参数");
		return;
	}
	int sum=0;
	for(int i=min;i<=max;i++){
		sum+=i;
	}
	System.out.println("sum="+sum);
	}
}

return:
1.有返回值类型方法中: 1)提前结束方法 2)带出返回值
1.没有返回值类型的方法中: 1)提前结束方法
兼容类型问题:
1.实参<=形参的数据类型
2.接收返回值变量的类型 >= 返回值类型 >= return后数据的类型

方法的重载

在同一个类中,多个方法,方法名相同,参数列表不同(方法签名不同)

参数列表不同:
1.参数个数
2.参数类型不同
3.当类型不同的时候,顺序不同也叫参数列表不同
重载方法如何调用:
根据参数进行匹配不同的方法,只看调用时候的参数列表

方法是一个类中封装的一种体现
方法的重载就是一个类中多态的一种体现

*方法的重载和修饰符有无关
*方法的重载有没有返回值类型无关
*方法的重载和返回值类型无关
*方法的重载和参数的名字无关
*方法的重载只和方法名和参数列表有关

public class OverLoad06{
public static void main(String[] args){
	//调用
	getSum(1.1,1);
	getSum(3,4,5);
}
//重载方法实现求和
public static String getSum(int a,int b){
	System.out.println("2个int类型参数的方法");
	System.out.println(a+b);
	return "";
}

public static int getSum(int a,int b){
	System.out.println("2个int类型参数的方法");
	System.out.println(a+b);
	return -1;
}


public static void getSum(int a,int b,int c){
	System.out.println("3个int类型参数的方法");
	System.out.println(a+b+c);
}

public static void getSum(double a,double b,double c){
	System.out.println("3个double类型参数的方法");
	System.out.println(a+b+c);
}

public static void getSum(double a,int b){
	System.out.println("1个double1个int类型参数的方法");
	System.out.println(a+b);
}
public static void getSum(int b,double a){
	System.out.println("1个int1个double类型参数的方法");
	System.out.println(a+b);
	}
}

方法的递归

方法中自己调用自己
不建议使用递归:可能造成内存溢出等情况,建议使用循环
public class Recursion07{
public static void main(String[] args){
System.out.println(recursion(2));
}

//实现阶乘: 5! = 5*4*3*2*1
/*
	1.方法的作用: 求某个数的阶乘 
	2.返回值: int
	3.参数: int i =5
	
	临界条件: i=1 1的阶乘就是1
	返回值: 阶乘的结果,如果参数是<0的值,返回-1
*/
public static int recursion(int i){
	if(i<=0){
		return -1;
	}
	if(i==1){
		return 1;
	}
	
	return i*recursion(i-1);
}

}

数组

[] 相同类型数据的有序集合
变量: 存储单个数据
数组: 存储多个数据

• 数组特点:

  1.数组是一个引用数据类型
  2.数组是个容器,长度一旦确定不可改变
  3.存储的所有数据类型要求一致
  4.有序,下标|索引 从0开始

• 数组的声明:

  数据类型[] 数组名; —推荐
  数据类型 数组名[]; —不推荐
  数据类型:基本|引用
  规定存放的所有数据的数据类型
  数组名:标识符

• 数组的初始化:

  动态初始化: 先创建数组,但是不赋值,后续根据需求进行赋值
  数据类型[] 数组名 = new 数据类型[长度];
  存在默认值:
  整数 0
  小数 0.0
  布尔: false
  字符: ’ ’
  引用数据类型:null

  静态初始化:创建的同时就要赋值
  数据类型[] 数组名 = new 数据类型[]{值1,值2,值3…};
  数据类型[] 数组名 ={值1,值2,值3…}; 推荐: 编写简单

  操作数组中的数据:
  数组名[下标]

  数组的长度: length
  数组名.length

  数组中的第一个数据的索引 0 ,最后一个数据的索引 数组名.length-1

• 数组的遍历:

  以此拿出数组中的每一个数据
  1.普通for循环
  2.增强for循环|foreach
  for( 数据类型 变量名: 数组名|容器名){

  }
  数据类型:数组中每一个数据的数据类型
  变量名:变量代表数组中的每一个数据,从第一个开始拿

   public class Array08{
   	public static void main(String[] args){
   	//声明
   	int[] arr1;
   	//动态初始化
   	String arr2[] = new String[5];
   	
   	boolean[] arr3 = new boolean[3];
   	//给数组中的每一个位置赋值
   	arr3[0]=true;
   	arr3[1]=false;
   	arr3[2]=true;
   	
   	//静态初始化
   	char[] arr4 = new char[]{'1','2','3','4','5'};
   	double[] arr5={1.1,2.2,3.3,4.4};
   	
   	//获取数组中的数据
   	System.out.println(arr2[0]);
   	System.out.println(arr2[1]);
   	System.out.println(arr2[2]);
   	System.out.println(arr2[3]);
   	System.out.println(arr2[4]);
   	
   	System.out.println(arr3[0]);
   	System.out.println(arr3[1]);
   	System.out.println(arr3[2]);
   	
   	System.out.println(arr4[0]);
   	System.out.println(arr4[1]);
   	System.out.println(arr4[2]);
   	System.out.println(arr4[3]);
   	System.out.println(arr4[4]);
   	System.out.println(arr4.length); //5
   	System.out.println(arr4[arr4.length-1]);
   	
   	System.out.println(arr5[0]);
   	System.out.println(arr5[1]);
   	System.out.println(arr5[2]);
   	System.out.println(arr5[3]);
   	
   	//arr4变量代表一个新的数组对象,不是原来的那一个
   	arr4=new char[]{'a','b'};
   	//arr5={4.4,5.5};
   	
   	System.out.println(arr4[0]);
   	System.out.println(arr4[1]);
   	System.out.println(arr4.length);  //2
   	
   	//普通for循环 变量i-->数组的索引
   	for( int i=0; i<=arr5.length-1; i++){
   		System.out.println(arr5[i]);
   	}
   	//增强for
   	for( double d: arr5){
   		System.out.println(d);
   	}
   	}
   }
  

测试数组中常见的异常:
1.数组索引越界异常:ArrayIndexOutOfBoundsException
如果使用了不存在的索引,会出现这个异常
2.空指针异常: NullPointerException
没有真的指向数组对象,而指向的null

二维数组

数组中定义数组,第二维数组是第一维数组的每一个数据

定义:
动态:
数据类型[][] 数组名 = new 数据类型[外层一维的长度][内层二维长度]; //一维二维同时创建
数据类型 数组名[][] = new 数据类型[外层一维的长度][];
静态:
数据类型[] 数组名[] = new 数据类型[][]{{1,2,3},{4,5}…};
数据类型[] 数组名[] ={{1,2,3},{4,5}…};

二维数组的使用方式:
数组名[一维][二维]

遍历:
循环嵌套
普通循环和增强for相互嵌套

public class ArrayDemo02{
	public static void main(String[] args){
		//动态初始化
		int[][] arr1=new int[2][3];
		//赋值
		arr1[0][0]=1;
		arr1[0][1]=2;
		arr1[0][2]=3;
		arr1[1][0]=4;
		arr1[1][1]=5;
		arr1[1][2]=6;
		//获取值
		System.out.println(arr1[0][0]);
		System.out.println(arr1[0][1]);
		System.out.println(arr1[0][2]);
		System.out.println(arr1[1][0]);
		System.out.println(arr1[1][1]);
		System.out.println(arr1[1][2]);
		
		double arr2[][] = new double[3][];
		
		arr2[0]= new double[2];
		arr2[0][0] = 1;
		arr2[0][1] = 2;
		
		arr2[1]=new double[]{3,4,5,6,7};
		//arr2[1]={1.1,2.2,3.3};
		System.out.println(arr2[0][0]);
		System.out.println(arr2[0][1]);
		System.out.println(arr2[1][0]);
		System.out.println(arr2[1][1]);
		System.out.println(arr2[1][2]);
		//System.out.println(arr2[1][3]);
		//System.out.println(arr2[1][4]);
		
		int[] arr3[] = new int[][]{{1,2,3},{4,5}}; 
		System.out.println(arr3[0][0]);
		System.out.println(arr3[0][1]);
		System.out.println(arr3[0][2]);
		System.out.println(arr3[1][0]);
		System.out.println(arr3[1][1]);
		
		char[][] arr4={{'1','2'},{'3','4','5'}};
		System.out.println(arr4[0][0]);
		System.out.println(arr4[0][1]);
		System.out.println(arr4[1][0]);
		System.out.println(arr4[1][1]);
		System.out.println(arr4[1][2]);
		
		//遍历 i外层数组的索引
		for(int i=0;i<=arr4.length-1;i++){
			for(char ch:arr4[i]){
				System.out.println(ch);
			}
		}
	}
	
}

可变参数:

个数不确定但是类型相同的多个参数
1.可以接收参数的个数为为0个,可以为多个,类型必须都相同
2.数据类型 … 参数名 …写在类型和参数名之间
3.可变参数要存在与参数列表的最后
4.操作可变参数,使用数组的数组的使用方式,在方法的内容,会默认为可变参数构建一个数组

public class Demo11 {
	public static void main(String[] args){
		test("haha",1,2);
	}
	
	//计算多个整数的和
	public static void test(String str,int ... b){
		int sum=0; //存储数据和
		for(int i:b){
			sum+=i;
			System.out.println(i);
		}
		System.out.println(sum);
	}
}

java类

Arrays :

封装了一些用来操作数组的常用功能
1.导包 java.util包下的Arrays,需要导包
2.Arrays.功能名字()

public class ArrayDemo03{
	public static void main(String[] args){
		//定义两个数组
		int[] arr1={5,2,6,4,1,3,7};
		int[] arr2={1,2,3,4,5,6,7};
		
		System.out.println(arr1);
		System.out.println(arr2);
		
		//需求:想要在打印数组名的时候,可以给打印数组中的所有内容
		//static String toString(int[] a) 返回指定数组内容的字符串表示形式。 
		System.out.println(Arrays.toString(arr1));
		
		//比较两个数组中所有的数据是否相同
		//static boolean equals(int[] a, int[] a2)  如果两个指定的 int 型数组彼此相等，则返回 true。 
		System.out.println(arr1==arr2);
		System.out.println(Arrays.equals(arr1,arr2));
		
		//排序: static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序 
		System.out.println(Arrays.toString(arr1));
		Arrays.sort(arr1);
		System.out.println(Arrays.toString(arr1));
		//根据字符的unicode比较
		String[] arr3=new String[]{"b","ab","a","bc","abc"};
		System.out.println(Arrays.toString(arr3));
		Arrays.sort(arr3);
		System.out.println(Arrays.toString(arr3));
		
		//二分查找法: 要求先升序排序再查找
		//static int binarySearch(int[] a, int key) 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 
	System.out.println(	Arrays.binarySearch(arr2,-2));  //-1
	
		//static int[] copyOf(int[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。 
		//如果新数组的长度比原数组长度小,是截取,比原数组长度大,是填充,使用默认值填充
		System.out.println(Arrays.toString(Arrays.copyOf(arr2,10)));  //默认从0开始
		
		/*
			static float[] copyOfRange(float[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。   结束位置不包含
		*/
		System.out.println(Arrays.toString(Arrays.copyOfRange(arr1,2,7)));
		
		/*
		static String deepToString(Object[] a) 
          返回指定数组“深层内容”的字符串表示形式。 
		static boolean deepEquals(Object[] a1, Object[] a2) 
          如果两个指定数组彼此是深层相等 的，则返回 true。 
		  
		  只对二维数组使用
		*/
		int[][] arr5={{9,8,7},{6,5},{4,3,2,1}};
		int[][] arr6={{9,8,7},{6,5},{4,3,2,1}};
		System.out.println(Arrays.toString(arr5));
		System.out.println(Arrays.toString(arr6));
		System.out.println(Arrays.deepToString(arr5));
		
		System.out.println(Arrays.equals(arr5,arr6));
		System.out.println(Arrays.deepEquals(arr5,arr6));
		
		//static void fill(float[] a, int fromIndex, int toIndex, float val)  将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。 
	}
	
}