数组+方法

java的数组与js的数组基本一致，不同点大都在于命名方式。数组分为一维和二维数组，区别在于二维数组是两个一维数组嵌套。因为数组是固定不可修改的长度，所以修改麻烦。

数组部分分为：

1、命名

一维数组：数据类型【】 数组名=new 数据类型【元素个数或数组长度】；

int 【】x=new int[100];
输入不存在的数组，报错，不定义的数组，报0,一次只能一个数组
第二种：
静态初始化：定义几个变量长度是几个
double[] arr =new double[]{1.1,2.5,6.3};
第三种：可以更改
String[] arr={"你好","快乐","啦啦"};

2、遍历数组
    for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
            }

3、求最值，最值的思路在于确定第一个为最大值，让剩余数组与其比较，输出最大值，用到for循环合if判断

{
        //求数组最大值.让第一个值当最大值 ，不停的与arr【0】进行对比
        int[]arr={70,90,40,7,8,41};
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
        if(arr[i]>arr[0]){
        max=arr[i];//每次将最大的arr【i】值给max
            }
        }
        System.out.println(max);
    }

二、二维数组：

1、定义二维数组 外面是二维数组new装的是二维数组的容器，arr是地址集合
        int[][] arr=new int[2][3];
        下表赋值
        arr[0][0]=21;
        arr[0][1]=22;
        arr[1][1]=23;
        打印的是二维数组中的第一个一维数组arr【0】的地址
        System.out.println(arr[0]);
        System.out.println(arr);
        整个二维数组地址
2、第二种定义方式
        int arr[][] =new int[2][];
        int [] a1={1,2,3};//a1存储的地址
        int [] a2={4,5,6};
        arr[0]=a1;//偷梁换柱之术，将定义的a1数组赋值到arr【0】
        arr[1]=a2;
        System.out.println(arr[0][0]);
注意需要将定义的数组值赋值到
3、第三种
        int [][] arr={{1,2},{2,3,4},{5}};
双层循环遍历 关键点在于让内层循环小于等于外层循环
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"");
            }
         System.out.println( );
        }

案例：

        /*String [] arr={"蒙四","赵六","李四","张三","王五","李明"};
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
            }
            Random sc=new Random();
            int b=sc.nextInt(6);
            System.out.println("随机点名："+ arr[b]);*/

          String [] arr={"蒙四","赵六","李四","张三","王五","李明"};
                    Random sc=new Random();
                    int b=sc.nextInt(6);
                for(int i=0;i<arr.length;i++){
                    System.out.println(arr[i]);
                    if(i==b){
                        System.out.println("随机点名："+ arr[i]);
                            }
                        }

 二、方法

方法=解决问题的方法

调用方法写在main方法里面，自己可以调用许多个方法

方法的语法格式：

修饰符 返回值类型  方法名（参数类型 形参1，形参2...）{

执行语句；

返回值return

}

例如：

//main方法
public static void main(String[] args) 
    {    Scanner sc=new Scanner(System.in);
        /*double c=sc.nextInt();
        System.out.println("请输入一个值:");
        //小转大自动转 
        double a=getArea(c);
        System.out.println("面积是"+a);*/
        //接收返回值和方法中定义的数值类型有关，若是不接受返回值则无法输出结果
        }

//写一个方法计算圆的面积
                                //形参类型名称r
    public static double getArea(double r){
        //double area=3.14*r*r;
        //math类pi
        double area =Math.PI* r*r;
        //除去void都需要返回值
        return area;
        }

为了练习方法的定义，总共有四个方向，

1.无参数无返回值

class Work 
{
    public static void main(String[] args) 
    {//无返回值无参数只需要调用方法名和（）；
        yuan()；
    }
    public static void yuan(){
    
    for(int i=0;i<=3;i++){
        for(int j=0;j<=3;j++){
            System.out.print("*");
            }
        System.out.println(  );
        }      
    }
}

2.无返回值，有参数

class Work2 
{
    public static void main(String[] args) 
    {    //无返回值，有参数
         xing(2,5);
        
        
    }
    public static void xing(int m,int n){
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                System.out.print("*");
                }
            System.out.println( );
            }
    }
}

3.有返回值，无参数

import java.util.Scanner;
class Work1java 
{ //有返回值无参数
    public static void main(String[] args) 
    {
        zhi();
    }
        public static int zhi(){
            
        Scanner sc= new Scanner(System.in);
        int a=sc.nextInt();
        System.out.println(a);
        return a;

        }

}

4.有参数有返回值

class Work3 
{//有参数有返回值
    public static void main(String[] args) 
    {
    double d=fan(2,3,5);//调取方法fan传实参给形参

        System.out.println(d);
    }
    public static double fan(double a,double b,double c){
        
        double avg=(a+b+c)/3;
            return avg;
    }
}

方法的重载
为了减少方法定义的多余，在一个类中定义多个名称相同方法，即参数的个数不同，类型不同，顺序不同，与返回值无关，与变量标识符也无关。如method(int x)与method(int x,int y) 不同；method(int x)与meth(double x)；metd(int x,double y)与metd(double x,int y)

方法的重载是一个类里面好几个相同的方法名。
参数的传递
即调用方法时，形参接收的数值对实参的影响。
当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际参数不影响   int double boolean char string
当调用方法时，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对实际参数有影响 

（引用数据类型是除了四个基本类型之外的所有数据类型，引用类型 就是只变量中存储的不是值而是一个内存中的地址的数据类型。也就是说 变量中存储了这个变量的值所在内存中的地址 每次调用这个变量都是引用这个地址而得到真正的值 所以叫引用类型，如Scanner Random Student s=new Student（）；）
如数组是形参接收到main方法中调用的数据，通过方法调用，将传递的值通过数组下标即地址赋值。

三、集合和方法的搭配使用

之前我们都是在单独的使用集合，或者将所有的执行语句放在main方法里面，这样是非常冗余，而我们学了方法之后，知道可以自己建立自定义方法，将执行语句和调用方法分开。可以搭配起来做一些案例。

如前面的库存管理系统

点名系统：

import java.util.Scanner;
class Demo03 
{
    public static void main(String[] args) 
    {
        //定义数组，数字一旦定义，长度不可更改
        Scanner sc=new Scanner(System.in);
        int z=sc.nextInt();
        System.out.println("请输入数字点名：");
        String[] arr=new String[7];
        save(arr);
        show(arr);
    }
    //存储所有同学姓名 a=arr=地址 a[下标]相当于给arr[下标]赋值
    public static void save(String [] a){
        a[0]="李明";
        a[1]="张三";
        a[2]="王五";
        a[3]="王二";
        a[4]="刘明";
        a[5]="钱七";
        a[6]="暴富";
    }
    //总览全班姓名 a=arr=地址相当于给arr遍历
    public static void show(String [] a){
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }

        //随机点名其中一人，打印到控制台
        public static void yin(String [] a){
            
        }
}

库存管理系统：

import java.util.Scanner;
class Work7 
{
    public static void main(String[] args) 
    {    
        Scanner sc= new Scanner(System.in);
        //int a=sc.nextInt();
        int [] arr3={5,10,15};
        System.out.println(arr3[0]);
        int num;
    int num=sc.nextInt();
    switch(num){
    case 1:  
        ku(arr3);
        break;
    case 2:
    arr3[0]=sc.nextInt();
    arr3[1]=sc.nextInt();
    arr3[2]=sc.nextInt();

    ku(arr3);
        break;
    case 3:
        break;
        default:
            alert("您的输入有误，请重新输入");
            break;
    }
        public static void ku(int[] arr4){
        String []arr={"MAC","THINK","ASUS"};
        double [] arr1={13.3,14.0,15.6};
        int [] arr2={6988.88,5999.99,4999.5};
        System.out.println(arr4[0]);
        System.out.println(arr4[1]);
        System.out.println(arr4[2]);
        }
    
    }
}

因为我们要修改的是数字int[]arr4，所以将整个数组放到main方法中，方便每次调用，而通过调用方法，将int【】arr3ku（arr3）作为实参传到各个方法中（调取方法传参的写法==方法名（实参）；），通过ku方法中形参int【】arr4的接收进行等价替换，arr4=arr3，最终输出的arr4[0]=arr[0]=5；