Java基础语法-方法与数组

1.通过分析,明确需求
2.整理相关的知识点
3.梳理实现流程
4.借助断点调试解决问题

---

方法
就是一个小功能.把一段代码存起来,以后可以重复使用.
相当于JavaScript 里的函数

    static void printB() {//创建一个方法叫planB, 前面必须加入一个static
        System.out.println("b");
        System.out.println("b");
        System.out.println("b");
        System.out.println("b");
    }
    
    
    //main方法
    public static void main(String[] args) {
    
        printB();//调用方法
    }

---

方法注意点

 注意点:
    1.方法-必须声明到类(class)当中
     2.创建的方法必须要定义到其他方法之外(跟其他方法是兄弟关系)
     3.定义方法不分先后顺序
     4.如果一个方法前面有static,那么在该方法当中调用其他的方法前面也应该有static
         5.一个类当中可以写多个方法
         6.方法名称不能一样
         7.方法必须要先定义再执行
         与JavaScript相比较,明显强大和复杂很多,声明形参必须要声明它的类型
         static void printB(int a ,int b)

    static void printB() {
        System.out.println("b");
        System.out.println("b");
        System.out.println("b");
        System.out.println("b");
    }
    
    
    //main方法  功能:程序一进来,就会自动执行
    public static void main(String[] args) {
    
        printB();
    }

---

方法的完整形式:

     [修饰符] 返回值类型 方法名([形式参数...]){
     方法体(要重复使用的代码)
            [return 值;]
        }

     [  ]中可选
     void  返回值为空,什么都不返回,如果有返回值,里面必须得要有return

/**
     * 求两数之和
     * @param n  第一个数
     * @param m  第二个数
     */

    static void sum(int n,int m) {//创建方法(形参:在定义方法是,自己起的名字)
        int res= n+m;
        System.out.println(res);
    }

 public static void main(String[] args) {
        sum(1,2);//调用方法(实参:在调用方法时,传入的实际的值)
    }
在此处声明的变量,只在方法当中有效.出了方法,就没有效果.外界的名称也不会影响里面

static String stringConcat(String str1,String str2) {   //static  后面要定义String类型
//      System.out.println(str1+str2);
        return str1+str2;
    }
return后面是什么类型,那么定义返回值时,在生命是,就要定义什么类型 

public static void main(String[] args) {
        String ziFuChuan = stringConcat("hello", "world");// ziFuChuan 接收了返回值
        System.out.println(ziFuChuan);
    }
定义方法时,返回什么类型,就必须得要使用什么类型接接收

定义了有返回值,接不接收返回值都可以

---

方法重载
调试的时候,F5是进入方法内部,F6是进入下一步

在同一个类中,允许方法名称相同,方法参数不同
方法的重载解决了,功能相同,参数不同,就不需要定义多个方法名称了

---

数组
作用:帮我们存放相同类型的东西
1.存放的东西必须是相同的数据类型
2.存放的东西都是有序的,可以通过脚标来获取存的内容

数组格式:
要存放的数据类型[] 数组的名称 = new 要存放的数据类型[] {存放指定数据类型的内容}

数组初始化:

静态初始化:在创建数组的时候,就已经确定了有多少个元素,并且把元素都放在数组当中
                int ages[];//先定义
                ages=new int[] {10,20,3,0,45};//再赋值,(初始化)
                如果不初始化,数组是不能使用的;

动态初始化:一开始不知道要存哪些数据,所以先定义一个指定空间大小

        String[] allPerson=new String[100];
        
        allPerson[0]="张三";
        allPerson[1]="ls";
        allPerson[2]="ww";
        allPerson[3]="wc";
        
        //ArrayIndexOutOfBoundsException:数组越界
        String person=allPerson[101];//超出100
        System.out.println(person);

数组的遍历
获取数组元素的个数:数组名称.length

//打印所有同学
        String[] names = new String[] {"fk","jkkd","kjsakd","ls","kksd"};
        
        //遍历数组(把数组当中的每一个元素都给取出来)
        for(int i=0;i<names.length;i++) {
            System.out.println(names[i]);
        }

数组练习题
        String[] names = new String[] { "fk", "jkkd", "kjsakd", "ls", "kksd", "jksfj", "jdkfjksd" };
        //打印  ["fk","jkkd","kjsakd","ls","kksd"] 出来

        String res = "[";

        // 1.遍历每一个元素,与res进行拼接

        for (int i = 0; i < names.length; i++) {

            res = res + names[i];

            // 2.每遍历一个元素,res后面加一个","

            if (i == names.length - 1) {
                
                // 3.如果是最后一个元素,就不需要拼接","
                // 4.所有元素遍历完毕,再王res之后拼接 "]"
                res = res + "]";

            } else {
                res = res + ",";
            }

        }

        System.out.println(res);

---

二维数组
在数组当中存放的每一个元素又是一个数组(数组中又存数组)

        int[] classAge1=new int[] {18,19,20,17};//一维数组
        int[] classAge2= {18,19,20};//可以简写成这样子
        int[] classAge3= {18,19};
        
        //整个年级的年龄
        int[][] allClass= new int[][] {classAge1,classAge2,classAge3};//二维数组
        int[][] allClass= new int[][] {
            {18,19,20,17},
            {18,19,20},
            {18,19}
        };

        //把二维数组的值都打印出来
        for(int i=0;i<allClass.length;i++) {
            int[] array = allClass[i];//用一个定义数组来接收二维数组存放的值
            for(int j=0;j<array.length;j++) {
                System.out.println(array[j]);
            }
        }

---

变量的作用域

    static void num() {
        int b = 10;
    }

    public static void main(String[] args) {

        /**
         * 1.变量的作用域:生效(能使用)的范围
         * 
         * 生效范围是:在创建变量的大括号当中生效.超过了大括号就不生效(不能再使用了) 
                 * 2.在方法内部定义的变量,跟外界没有任何关系
         */
        num();
        
        {// 代码块
            int b = 20;
            System.out.println(b);
        } // b过完大括号就没有了

        int b = 30;//所以下面定义b是可以的,如果把b放在代码块上面就会报错,因为在上面定义了b,下面就不能在定义了

    }

---

Foreach遍历数组

        int[] ages = { 10, 20, 30 };

        //遍历数组:foreach   for (数据类型 遍历出来的元素 : 数组的名称)
        //弊端:不能知道当前的脚标是多少
        for (int i : ages) {//是一个语法糖,写的时候简单,编译的时候还是一样的
            System.out.println(i);//10,20,30
        }

用翻编译工具看Foreach语法糖内部的执行过程
    public static void main(String args[])
    {
        int ages[] = {
            10, 20, 30
        };
        int ai[];//定义一个新数组
        int k = (ai = ages).length;//给k赋值ages数组的长度     //ai等于ages这个数组
        for (int j = 0; j < k; j++)  //int j = 0; j < ages.length; j++
        {
            int i = ai[j];//i=ages[j]
            System.out.println(i);
        }

    }

---

方法的可变参数

// 方法的重载
    /*
     * static int sum(int a, int b) { int res = a + b; return res; } static int
     * sum(int a, int b,int c) { int res = a + b +c; return res; }
     */
    /*static int sum(int[] args) {//把数组当做参数进行传递
        int res = 0;
        for (int i = 0; i < args.length; i++) {
            res += args[i];
            
        }
        
        System.out.println(res);
    }*/
    
    //可变参数(它是数组参数的一种简写,会自动把...转成数组)
    static void sum(int...args) {//语法糖
        int res = 0;
        for (int i = 0; i < args.length; i++) {
            res += args[i];
            
        }
        System.out.println(res);
    }
    
    
    public static void main(String[] args) {
//      sum(1, 2);
        int[] params={1,2,3};
        sum(params);
        sum(1,2,3,4);
    }