【JavaSE（二）】Java语法基础（下）

2018-05-09 本文已影响183人苍云横渡

原文地址：https://www.cloudcrossing.xyz/post/34/

1 方法

1.1 方法的概述

方法，简单的说就是完成特定功能的代码块（注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法）。

格式：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
    方法体语句;
    return 返回值;
}

格式解释：

修饰符：目前就用 public static，后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便调用该方法
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
- 实参：实际参与运算的数据
- 形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者

注意：

要明确返回值类型：结果的数据类型
方法与方法是平级关系，不能嵌套定义
参数列表：参数的个数及对应的数据类型，参数之间用逗号隔开
如果方法有明确的返回值，一定要有return带回一个值

方法的调用：

class FunctionDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        
        //方式1：单独调用，没有意义（void类型的方法可以单独调用）
        //sum(x,y);
    
        //方式2：输出调用（void类型会报错：此处不允许使用 '空' 类型）
        //System.out.println(sum(x,y));
        //System.out.println(30);
    
        //方式3：赋值调用（void类型会报错：非法的表达式开始）
        int result = sum(x,y);
        //result在这里可以进行操作
        System.out.println(result);
    }
    
    public static int sum(int a,int b) {
            //int c = a + b;
            //return c;
            return a + b;
    }
    
}

1.2 方法重载

在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

参数列表不同：

A：参数个数不同
B：参数类型不同

class FunctionDemo {
    public static void main(String[] args) {
        //jvm会根据不同的参数去调用不同的功能
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
        System.out.println(sum(10.5f,20f));
    }

    //需求1:求两个数的和
    public static int sum(int a,int b) {
        System.out.println("int");
        return a + b;
    }
    
    //需求2:求三数的和
    public static int sum(int a,int b,int c) {
        return a + b + c;
    }
    
    //需求3:求四个数的和
    public static int sum(int a,int b,int c,int d) {
        return a + b + c + d;
    }
    
    //需求3:求两个浮点数的和
    public static float sum(float a,float b) {
        System.out.println("float");
        return a + b;
    }
}

2 数组

2.1 数组概述

数组是存储同一种数据类型的多个元素的容器。每一个元素都有索引，从0开始，最大索引是长度-1。

数组既可以存储基本数据类型，也可以存储引用数据类型。

定义格式：

A：数据类型[] 数组名; （推荐）
B：数据类型数组名[];

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

数组的初始化：

java中的数组必须先初始化然后才能使用
A：动态初始化。只给长度，系统给出默认值
- 举例：int[] arr = new int[3];
B：静态初始化。给出值，系统决定长度
- 举例：int[] arr = new int[]{1,2,3}; 或者 int[] arr = {1,2,3};

2.2 数组内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

A：栈，通常保存方法中的参数，局部变量。每一个线程包含一个栈区，只保存基本数据类型的对象和自定义对象的引用（不是对象），对象都存放在共享堆中；每个栈中的数据（基本数据类型和对象引用）都是私有的，其他栈不能访问；
B：堆，存储所有new出来的，即存储的全部是对象。每个对象都包含一个与之对应的class的信息（class的目的是得到操作指令）。jvm只有一个堆区，被所有线程共享，不存放基本类型和对象引用，只存放对象本身。
C：方法区(面向对象部分详细讲解)，又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。方法区中包含的都是在程序中永远的唯一的元素
D：本地方法区(系统相关)
E：寄存器(CPU使用)

注意：

a：局部变量在方法定义中或者方法声明上定义的变量
b：栈内存和堆内存的区别
- 栈：数据使用完毕，就消失。比如局部变量
- 堆：每一个new出来的东西都有地址，每一个变量都有默认值
  - byte,short,int,long——0
  - float,double——0.0
  - char——'\u0000'
  - boolean——false
  - 引用类型——null
C：数据使用完毕后，在垃圾回收器空闲的时候回收

（1）定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。

定义一个数组的内存图

（2）定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。

定义两个数组的内存图

（3）定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。

三个数组(两个栈变量指向同一个堆内存)

2.3 数组常用操作

（1）遍历

public static void printArray(int[] arr) {
    for(int x=0; x<arr.length; x++) {
        System.out.println(arr[x]);
}

注意：数组提供了一个属性length，用于获取数组的长度。格式：数组名.length。

（2）最值

public static int getMax(int[] arr) {
    //从数组中任意的找一个元素作为参照物
    int max = arr[0];
    //然后遍历其他的元素
    for(int x=1; x<arr.length; x++) {
    //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
        if(arr[x] > max) {
            max = arr[x];
        }
    }
    //最后参照物里面保存的就是最大值。
    return max;
}
    
public static int getMin(int[] arr) {
    //从数组中任意的找一个元素作为参照物
    int min = arr[0];
    //然后遍历其他的元素
    for(int x=1; x<arr.length; x++) {
    //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。
        if(arr[x] < min) {
            min = arr[x];
        }
    }
    //最后参照物里面保存的就是最小值。
    return min;
}

（3）逆序

方式1：
public static void reverse(int[] arr) {
    for(int x=0; x<arr.length/2; x++) {
        int temp = arr[x];
        arr[x] = arr[arr.length-1-x];
        arr[arr.length-1-x] = temp;
    }
}
                
方式2：
public static void reverse(int[] arr) {
    for(int start=0,end=arr.length-1; start<=end; start++,end--) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

（4）查表

public static String getString(String[] strArray,int index) {
    return strArray[index];
}

（5）基本查找

方式1：
public static int getIndex(int[] arr,int value) {
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            return x;
        }
    }
    return -1;
}
                
方式2：
public static int getIndex(int[] arr,int value) {
    int index = -1;
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;
        }
    }
    return index;
}

2.4 二维数组

二维数组是一个元素是一位数组的数组。

格式：

A：数据类型[][] 数组名 = new 数据类型[m][n];
B：数据类型[][] 数组名 = new 数据类型[m][];
C：数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
D：数据类型[][] 数组名 = {{...},{...},{...}};

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

二维数组格式A的内存图解

二维数组格式B的内存图解

二维数组格式D的内存图解

二维数组的遍历：外循环控制的是二维数组的长度，其实就是一维数组的个数。内循环控制的是一维数组的长度。

class Array2 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};  //arr[0]就是第一个数组，arr[0] = {1,2,3};
        printArray2(arr);
        System.out.println("--------------");
        int[][] arr2 = {{1,2,3},{4,5},{6}};
        printArray2(arr2);
    }
    
    public static void printArray2(int[][] arr) {
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {  //arr[x]就是第x-1个数组
                System.out.print(arr[x][y]+" ");
            }
            System.out.println();
        }
    }
}

举个二维数组的应用例子

/*

    需求：打印杨辉三角形(行数可以键盘录入)
    
    1
    1 1 
    1 2 1
    1 3 3 1
    1 4 6 4 1 
    1 5 10 10 5 1

    分析：看这种图像的规律
        A:任何一行的第一列和最后一列都是1
        B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
    
    步骤：
        A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
          这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值
            从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据：");
        int n = sc.nextInt();
        
        //定义二维数组
        int[][] arr = new int[n][n];
        
        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }
        
        //按照规律给其他元素赋值
        //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的，就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始，因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }
        
        //遍历这个二维数组。
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}

3 参数传递问题

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

#运行结果：
a:10,b:20
a:10,b:20
a:20,b:40
a:10,b:20
4

4 语言基础综合练习

某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：

首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，最后将第一位和最后一位数字交换。请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来。

题目要求：
        A:数据是小于8位的整数
            定义一个int类型的数据
            int number = 123456;
        B:加密规则
            a:首先将数据倒序
                结果 654321
            b:然后将每位数字都加上5，再用和除以10的余数代替该数字
                结果 109876
            c:最后将第一位和最后一位数字交换
                结果 609871
        C:把加密后的结果输出在控制台
        
        通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。
        不是直接写成这个样子的：
            int[] arr = {1,2,3,4,5,6};
            
        如何把数据转成数组呢?
            A:定义一个数据
                int number = 123456;
            B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?
                int[] arr = new int[8]; //不可能超过8
                在赋值的时候，我用一个变量记录索引的变化。
                定义一个索引值是0
                int index = 0;
            C:获取每一个数据
                int ge = number%10
                int shi = number/10%10
                int bai = number/10/10%10
                
                arr[index] = ge;
                index++;
                arr[index] = shi;
                index++;
                arr[index] = bai;
                ...

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