Java语法基础（四）

方法定义及格式

---

• 在很多语言里面都有函数的定义
• 函数在Java中被称为方法

---

格式

    修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
                函数体;
                return 返回值;
        }

class FunctionDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        //方式1：单独调用
        //sum(x,y);

        //方式2：输出调用
        //System.out.println(sum(x,y));
        //System.out.println(30);

        //方式3：赋值调用
        int result = sum(x,y);
        //result在这里可以进行操作
        System.out.println(result);
    }

    /*
        需求：求两个数据之和的案例

        两个明确：
            返回值类型：int
            参数列表：2个，都是int类型。
    */
    public static int sum(int a,int b) {
            //如何实现呢?
            //int c = a + b;
            //return c;

            //c就是a+b,所以，我可以直接返回a+b
            return a + b;
    }

}

注意事项

• 方法不调用不执行
• 方法与方法是平级关系，不能嵌套定义
• 方法定义的时候参数之间用逗号隔开
• 方法调用的时候不用在传递数据类型
• 如果方法有明确的返回值，一定要有return带回一个值

没有明确返回值的函数调用

• 其实就是void类型方法的调用
• 只能单独调用

方法的重载

• 方法重载概述

  • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

• 方法重载特点

  • 与返回值类型无关，只看方法名和参数列表
  • 在调用时，虚拟机通过参数列表的不同来区分同名方法

数组

数组概念

• 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
• 数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

    格式1：数据类型[] 数组名;

    格式2：数据类型 数组名[]; 

    注意：这两种定义做完了，数组中是没有元素值的。                     

数组的初始化

---

• Java中的数组必须先初始化,然后才能使用。
• 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

---

• 数组的初始化方式

      动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
  
      静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
  

• 动态初始化

  • 格式

     数据类型[] 数组名 = new 数据类型[数组长度]; 
    

/*
    数组:存储同一种数据类型的多个元素的容器。

    定义格式：
        A:数据类型[] 数组名;
        B:数据类型 数组名[];

    举例：
        A:int[] a; 定义一个int类型的数组a变量
        B:int a[]; 定义一个int类型的a数组变量

    注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。

    如何对数组进行初始化呢?
        A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值
        B:有几种方式呢?
            a:动态初始化 只指定长度，由系统给出初始化值
            b:静态初始化 给出初始化值，由系统决定长度

    动态初始化的格式：
        数据类型[] 数组名 = new 数据类型[数组长度];

        举例：
        int[] arr = new int[3]; 

    如何获取数组中的元素呢?
        通过:
            数组名[索引]
            索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
*/
class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        //int[] a;
        //可能尚未初始化变量a
        //System.out.println(a);

        int[] arr = new int[3];
        /*
            左边：
                int:说明数组中的元素的数据类型是int类型
                []:说明这是一个数组
                arr:是数组的名称

            右边：
                new:为数组分配内存空间。
                int:说明数组中的元素的数据类型是int类型
                []:说明这是一个数组
                3:数组长度，其实也就是数组中元素的个数
        */

        System.out.println(arr); //[I@175078b 地址值。
        //我要地址值没有意义啊，我就要数据值，怎么办呢?
        //不用担心，java为你考虑到了。
        //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。
        //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引
        //通过数组名访问数据的格式是：数组名[索引];
        System.out.println(arr[0]); //0
        System.out.println(arr[1]); //0
        System.out.println(arr[2]); //0
    }
}

/*
    定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
    定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。
    定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重复赋值。
    最后，再次输出第一个数组数组名称和元素。
*/
class ArrayDemo4 {
    public static void main(String[] args) {
        //定义第一个数组
        int[] arr = new int[3];
        arr[0] = 88;
        arr[1] = 33;
        arr[2] = 66;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("----");

        //定义第二个数组
        int[] arr2 = new int[3];
        arr2[0] = 22;
        arr2[1] = 44;
        arr2[2] = 55;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println("----");

        //定义第三个数组
        int[] arr3 =  arr;
        arr3[0] = 100;
        arr3[1] = 200;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

• 静态初始化

  • 格式

    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    

  • 简化格式

    数据类型[] 数组名 = {元素1,元素2,…}; 
    

/*
    数组的静态初始化：
        格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
        简化格式：
            数据类型[] 数组名 = {元素1,元素2,…};

        举例：
            int[] arr = new int[]{1,2,3};

            简化后：

            int[] arr = {1,2,3};

    注意事项：
        不要同时动态和静态进行。
        如下格式：
            int[] arr = new int[3]{1,2,3}; //错误
*/
class ArrayDemo5 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

常见异常情况分析

/*
    数组操作的两个常见小问题：
        ArrayIndexOutOfBoundsException:数组索引越界异常
            原因：你访问了不存在的索引。

        NullPointerException:空指针异常
            原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

        作业：请自己把所有的场景Exception结尾的问题总结一下。以后遇到就记录下来。
              现象，原因，解决方案。
*/
class ArrayDemo6 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};

        //System.out.println(arr[3]);

        //引用类型的常量：空常量 null
        arr = null;
        System.out.println(arr[0]);
    }
}

Java内存分配

二维数组

定义格式

---

• 格式1：

      数据类型[][] 变量名 = new 数据类型[m][n];
  
          m表示这个二维数组有多少个一维数组
          n表示每一个一维数组的元素个数
  

• 格式2：

      数据类型[][] 变量名 = new 数据类型[m][];
  
          m表示这个二维数组有多少个一维数组
          这一次没有直接给出一维数组的元素个数，可以动态的给出。
  

• 格式3：

      数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  
  简化版格式：
  
      数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  

---

/*

    格式1：
        数据类型[][] 数组名 = new 数据类型[m][n];

        m:表示这个二维数组有多少个一维数组。
        n:表示每一个一维数组的元素有多少个。

    注意：
        A:以下格式也可以表示二维数组
            a:数据类型 数组名[][] = new 数据类型[m][n];
            b:数据类型[] 数组名[] = new 数据类型[m][n];
        B:注意下面定义的区别
            int x;
            int y;
            int x,y;

            int[] x;
            int[] y[];

            int[] x,y[];
*/
class Array2Demo {
    public static void main(String[] args) {
         //定义一个二维数组
         int[][] arr = new int[3][2];
         //定义了一个二维数组arr
         //这个二维数组有3个一维数组的元素
         //每一个一维数组有2个元素
         //输出二维数组名称
         System.out.println(arr); //地址值 [[I@175078b
         //输出二维数组的第一个元素一维数组的名称
         System.out.println(arr[0]); //地址值  [I@42552c
         System.out.println(arr[1]); //地址值  [I@e5bbd6
         System.out.println(arr[2]); //地址值  [I@8ee016
         //输出二维数组的元素
         System.out.println(arr[0][0]); //0
         System.out.println(arr[0][1]); //0
    }
}

/*
    格式2：
        数据类型[][] 数组名 = new 数据类型[m][];

        m:表示这个二维数组有多少个一维数组。
        列数没有给出，可以动态的给。这一次是一个变化的列数。
*/
class Array2Demo2 {
    public static void main(String[] args) {
        //定义数组
        int[][] arr = new int[3][];

        System.out.println(arr);    //[[I@175078b
        System.out.println(arr[0]); //null
        System.out.println(arr[1]); //null
        System.out.println(arr[2]); //null

        //动态的为每一个一维数组分配空间
        arr[0] = new int[2];
        arr[1] = new int[3];
        arr[2] = new int[1];

        System.out.println(arr[0]); //[I@42552c
        System.out.println(arr[1]); //[I@e5bbd6
        System.out.println(arr[2]); //[I@8ee016

        System.out.println(arr[0][0]); //0
        System.out.println(arr[0][1]); //0
        //ArrayIndexOutOfBoundsException
        //System.out.println(arr[0][2]); //错误

        arr[1][0] = 100;
        arr[1][2] = 200;
    }
}

/*
    格式3：
        基本格式：
            数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
        简化版格式：
            数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

        举例：
            int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
            int[][] arr = {{1,2,3},{4,5},{6}};
*/
class Array2Demo3 {
    public static void main(String[] args) {
        //定义数组
        int[][] arr = {{1,2,3},{4,5},{6}};

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println(arr[0][0]); //1
        System.out.println(arr[1][0]); //4
        System.out.println(arr[2][0]); //6

        System.out.println(arr[0][1]); //2
        System.out.println(arr[1][1]); //5
        //越界
        System.out.println(arr[2][1]); //错误
    }
}

/*
    思考题1：看程序写结果，然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。

    Java中的参数传递问题：
        基本类型：形式参数的改变对实际参数没有影响。
        引用类型：形式参数的改变直接影响实际参数。
*/
class ArgsDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //???   a:10,b:20

        int[] arr = {1,2,3,4,5}; 
        change(arr);
        System.out.println(arr[1]); //???   4
    }

    public static void change(int a,int b) { //a=10,b=20
        System.out.println("a:"+a+",b:"+b); //a:10,b:20
        a = b;  //a=20
        b = a + b; //b=40
        System.out.println("a:"+a+",b:"+b); //a:20,b:40
    }

    public static void change(int[] arr) { //arr={1,2,3,4,5};
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
        //arr={1,4,3,8,5};
    }
}

/*
        某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
    在传递过程中需要加密，加密规则如下：
        首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
        最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
        然后，把加密后的结果在控制台打印出来。

        A:把数据改进为键盘录入
        B:把代码改进为方法实现


        另一个数据的测试：
        number:1234567
        第一步：7654321
        第二步：2109876
        第三步：6109872

    知识点：
        变量
        数据类型
        运算符
        键盘录入
        语句
        方法
        数组
*/
import java.util.Scanner;

class JiaMiDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //请输入一个数据
        System.out.println("请输入一个数据(小于8位)：");
        int number = sc.nextInt();

        //写功能实现把number进行加密
        //调用
        String result = jiaMi(number);
        System.out.println("加密后的结果是："+result);
    }

    /*
        需求：写一个功能，把数据number实现加密。
        两个明确：
            返回值类型：String 做一个字符串的拼接。
            参数列表：int number
    */
    public static String jiaMi(int number) {
        //定义数组
        int[] arr = new int[8];

        //定义索引
        int index = 0;

        //把number中的数据想办法放到数组中
        while(number > 0) {
            arr[index] = number%10;
            index++;
            number /= 10;
        }

        //把每个数据加5，然后对10取得余数
        for(int x=0; x<index; x++) {
            arr[x] += 5;
            arr[x] %= 10;
        }

        //把第一位和最后一位交换
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;

        //把数组的元素拼接成一个字符串返回
        //定义一个空内容字符串
        String s = "";

        for(int x=0; x<index; x++) {
            s += arr[x];
        }

        return s;
    }
}