• 方法重载：overloading method
• 在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义；
• 返回值 不能 作为重载的条件。 如果两个函数名字相同 参数相同 仅返回值不同 则不能同时定义
  如：
  public void method(int a){…}
  public void method(char c){…}

/**
方法（函数）
方法的重载:在同一个类中，方法名相同，参数列表不同，返回值不能作为重载的条件。
*/
import java.util.Scanner;
public class Test5{
public static void main(String[] args){

int result = add(10,20);
System.out.println(result);
}

public static int add(int a,int b){
return a+b;
}
public static float add(float a,float b){
return a+b;
}
public static float add(int a,float b){
return a+b;
}
}

四种：
一、使用默认的初始值来初始化数组中的每一个元素加粗样式
语法：数组元素类型 [] 数组名 = new 数组元素类型[数组中元素的个数（数组的长度）];
如：int [] scores = new int[3];
二、先声明，然后再赋予默认的初始值。
语法：数组元素类型 [] 数组名;
数组名= new 数组元素类型[数组中元素的个数（数组的长度）];
如：int [] scores;
scores = new int[3];
三、先声明，然后再使用指定的值进行初始化。
语法：数组元素类型 [] 数组名 = new 数组元素类型[]{元素1，元素2,…};
如：int [] scores = new int[]{56,78,98};
四、将第三种写法可以简化为（使用数组常量值给数组进行赋值）
语法：数组元素类型 [] 数组名 = {元素1，元素2,…};
如：int [] scores = {56,78,98};****

数组的遍历
1.5以后Java新增foreach循环和可变参数。

for(int x:scores){
System.out.println(x);
}

遍历方式二：使用增强for循环【foreach循环】
语法：for(数组中元素的类型 变量:数组名){
数组中元素的类型 临时变量 = 变量;
}

结合方法的定义，可以用可变参数来代替数组作为参数。

public static void print(int … 变量名){
//可变参数在使用时作为数组使用。
}

/**
数组的遍历

*/
import java.util.Scanner;
public class Test7{
public static void main(String[] args){

int[] scores = {59,75,83,93,100};
System.out.println("数组的长度："+scores.length);

//for遍历
int len = scores.length;/*这里不直接使用for(int i=0;i<scores.length;;i++) 降低效率 每次都要计算数组长度*/
for(int i=0;i<len;i++){ /*要int len = scores.length;将其定义出来 这样每次访问的是常量 效率提高*/

int score = scores[i];
System.out.println(score);
}
System.out.println(scores);

System.out.println("-----------------");
//forearch JDK1.5之后新增的特性
//=======================================
for(int x:scores){
System.out.println(x);
}System.out.println("--------------");
//调用方法
//print(scores);
//print2(59,75,83,93,100); 这样就是任意多个数都可以放到print2输出 所以是可变的 没有规定个数

//print3(null);

print4(scores);

//new关键字表示创建一个数组，
int[] nums = new int[]{1,2,3,4,5};

}

public static void print(int[] x){
int len = x.length;
for(int i=0;i<len;i++){

System.out.println(x[i]);
}
}

//JDK1.5可变参数
//可变参数只能是参数列表中的最后一个 就是不能放前边print2(int... x， int k)这样不会得到k 都放到第一个参数里了，x里面了
//可变参数作为数组使用
public static void print2(int k,int... x){
int len = x.length;
for(int i=0;i<len;i++){

System.out.println(x[i]);
}
}

//测试数组的异常NullPointerException(空指针)
public static void print3(int[] x){
// java.lang.NullPointerException
//当一个变量为null（没有赋值时）时，我们去调用了该变量的属性和方法
System.out.println("数组的长度为："+x.length);
}
//测试数组的异常,数组下标越界
// java.lang.ArrayIndexOutOfBoundsException
public static void print4(int[] x){
for(int i=0;i<=x.length;i++){
System.out.println(x[i]);
}
}
}

//测试数组的异常NullPointerException(空指针)
print3(null);

当一个变量为null（没有赋值时）时，我们去调用了该变量的属性和方法 就会发生空指针异常

测试数组的异常,数组下标越界

java.lang.ArrayIndexOutOfBoundsException

内存分析

数组内存结构分析：数组是引用类型，会存放在堆内存中。

Random r = new Random();//创建一个可以生成随机数的工具

r.nextInt(50);/获取50以内的整型随机数/

/**
数组示例：1、猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数。

*/
import java.util.Scanner;
import java.util.Random; //生成伪随机数
public class Test8{
public static void main(String[] args){

int[] nums = new int[5];

int len = nums.length;

Random r = new Random();//创建一个可以生成随机数的工具

for(int i=0;i<len;i++){

nums[i] = r.nextInt(50);/*获取50以内的整型随机数*/

}

Scanner input = new Scanner(System.in);
System.out.println("请输入你要猜的数：(50以内)");
int userNum = input.nextInt();

boolean flag = false;
for(int x:nums){
if(userNum==x){
flag = true;
break;
}
}

if(flag){
System.out.println("恭喜你，猜对了");
}else{
System.out.println("没猜对，加油！");
}

}
}

/**
二维数组示例:JAVA中没有真正的多维数组，多维数组的表示方式是数组中的元素还是数组。
一起来参加屌丝程序员大赛吧，有3个班级各3名学员参赛，
记录每个学员的成绩，并计算每个班的平均分。

*/
import java.util.Scanner;
public class Test10{
public static void main(String[] args){

int[][] scores = {{78,98,88},{87,96,85},{67,78,89}};
int classLen = scores.length;
for(int i=0;i<classLen;i++){
int sum = 0;
int count = scores[i].length;
for(int j=0;j<count;j++){
sum+=scores[i][j];
}
int avg = sum/count;
System.out.println("第"+(i+1)+"班的平均成绩是："+avg);
}
}
}

/*
78  98  88
87  96  85
67  78  89

*/