方法，数组

方法：

定义：

	    	1.有返回值类型的方法  
			        修饰符 返回值类型 方法名(参数列表){
				               具体功能的代码;
				               return 返回值;
		         	}
		    2.没有返回值类型的方法
	                修饰符 void 方法名(参数列表){
		                      方法体语句;
		                 return; //可以写可以不写
	              }
	                     void:标识没有返回值类型的方法
	                     return:提前结束方法
	
调用方法:
	直接调用:方法名(参数列表);	

具体说明：

      说明:
				修饰符:  访问权限修饰符 public static(默认,具体面向对象讲)
			 返回值类型:  方法运算后结果的数据类型 (基本数据类型|引用数据类型)
				方法名:  方法的名字. 调用方法必须使用方法名调用
					   标识符->遵循标识符的要求
			  参数列表:  参数个数可以是0个,可以是多个
				 参数:  定义方法的时候,如果未知的数据|不确定的|可变的数据,定义在参数列表上 
					参数定义时,相当于一个局部变量的声明 
				作用域:  当前所定义的方法中
					数据类型 参数名,数据类型 参数名, ...
				{}:解决具体功能的代码
				return:1)提前结束方法 2)带出返回值:返回值返回给方法的调用者

方法的调用： 方法名(参数列表);->逐行执行方法中的代码
1)直接调用 简单,但是无法拿到返回值
2)赋值调用 数据类型 变量名=方法名();
3)输出调用 System.out.println(方法名());

方法的参数：
1）形式参数|形参: 定义方法的时候,()中的参数,局部变量的声明
2）实际参数|实参: 调用方法的时候,()中的内容,局部变量的赋值
实参和形参要一一对应
没有形参,不能传实参

方法的重载

定义：在同一个类中,多个方法,方法名相同,参数列表不同(方法签名不同)
构成条件：
参数列表不同:
1.参数个数
2.参数类型不同
3.当类型不同的时候,顺序不同也叫参数列表不同
方法签名: 方法名+参数列表 -->标识一个方法的唯一
重载方法如何调用:
根据参数进行匹配不同的方法,只看调用时候的参数列表
如何判定方法的重载：

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

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

方法的递归：

定义：方法中自己调用自己
递归头: 停止自己调用自己的条件
递归体: 自己调用自己

	临界条件: 停止自己调用自己的条件,递归头
	递归前进段:还没有到临界条件之前自己调用自己的阶段
	递归后退段:把结果返回给上一层
	
	不建议使用递归:可能造成内存溢出等情况,建议使用循环

return:

1.有返回值类型方法中: 1)提前结束方法 2)带出返回值
1.没有返回值类型的方法中: 1)提前结束方法
如果在一个方法中遇到return,能执行到的return后面不能写内容
不可达语句:

			1.return
			2.死循环的后面
			3.break
			4.while..false
			5.continue

兼容类型问题:
1.实参<=形参的数据类型
2.接收返回值变量的类型 >= 返回值类型 >= return后数据的类型

数组

定义：相同类型数据的有序集合
变量: 存储单个数据
数组: 存储多个数据
数组特点:
1.数组是一个引用数据类型
2.数组是个容器,长度一旦确定不可改变
3.存储的所有数据类型要求一致
4.有序,下标|索引 从0开始

数组的声明:

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

数组的初始化:

 动态初始化: 先创建数组,但是不赋值,后续根据需求进行赋值
		数据类型[] 数组名 = new 数据类型[长度];
		存在默认值:
				 整数 0 
				 小数 0.0
				 布尔: false
				 字符: ' '
				 引用数据类型:null
	
	静态初始化:创建的同时就要赋值
		数据类型[] 数组名 = new 数据类型[]{值1,值2,值3...};
		数据类型[] 数组名 ={值1,值2,值3...};  推荐: 编写简单

数组的遍历:
以此拿出数组中的每一个数据
1.普通for循环
2.增强for循环|foreach
for( 数据类型 变量名: 数组名|容器名){
}
数据类型:数组中每一个数据的数据类型
变量名:变量代表数组中的每一个数据,从第一个开始拿

	//普通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

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

回顾:
	1.方法***
		定义和使用  ***
		重载  ***
		递归  了解
		
	2.数组
		定义和使用 ***
		数组特点 ***
		数组的遍历,区别
		可变参数
		数组中会遇到的异常