1. 基础语法（二）-阿里云开发者社区

逻辑: variable是一个变量,取值类型可以是byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
如果表达式的值和某一个case后面的值相同了, 就会执行这个case后面的语句; 如果表达式的值没有和任意的一个case后面的值相同, 则执行default后面的语句
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句。

案例代码

import java.util.Scanner;
public class SwitchDemo {
  public static void main(String[] args) {
    // 创建键盘录入数据
    Scanner sc = new Scanner(System.in);
    // 给出提示
    System.out.println("请输入一个整数(1-7)：");
    int weekDay = sc.nextInt();
    // 用switch语句实现判断
    switch (weekDay) {
    case 1:
      System.out.println("星期一");
      break;
    case 2:
      System.out.println("星期二");
      break;
    case 3:
      System.out.println("星期三");
      break;
    case 4:
      System.out.println("星期四");
      break;
    case 5:
      System.out.println("星期五");
      break;
    case 6:
      System.out.println("星期六");
      break;
    case 7:
      System.out.println("星期日");
      break;
    default:
      System.out.println("你输入的数据有误");
      break;
    }
  }
}

注意

在switch-case语句中有穿透性, 即: 如果variable的值和某一个value匹配了, 会执行从这个case开始, 一直到switch语句结束, 后面所有的代码, 且跳过后面的case匹配; 为了避免穿透, 可以使用关键字break来跳出switch语句。

1.9.3 循环流程控制

1.9.3.1 while循环

while语句

while (condition) {
    // 循环体
}

逻辑: 每次循环线判断condition, 如果为true, 循环体执行, 然后再判断condition; 直到condition为false, 循环结束。

do {
    // 循环体
} while (condition);

逻辑: 先执行一次循环体, 然后再判断循环条件是否成立

案例代码

public class WhileDemo {
  public static void main(String[] args) {
    //while循环实现
    int x=1;
    while(x<=5) {
      System.out.println("HelloWorld");
      x++;
    }
  }
}

public class DoWhileDemo {
  public static void main(String[] args) {
    int x=1;
    do {
      System.out.println("HelloWorld");
      x++;
    }while(x<=5);
  }
}

1.9.3.2 for循环

基础语法

for (循环起点; 循环条件; 循环步长) {
    循环体
}

先执行循环起点, 一般用与定义一个控制循环的变量, 或者给这个变量一个初始值
再判断循环条件是否成立, 如果循环条件成立, 执行循环体, 再执行循环步长, 然后重新判断循环条件
如果循环条件不成立, 循环结束

案例代码

public class ForDemo {
  public static void main(String[] args) {
    //需求：在控制台输出5次HelloWorld
    //原始做法
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("HelloWorld");
    System.out.println("----------");
    //用for循环改进
    for(int x=1; x<=5; x++) {
      System.out.println("HelloWorld");
    }
  }
}

注意事项
关于语法省略

for循环的小括号中由三部分组成, 这三个部分都可以省略:
循环起点: 变量的定义可以放在循环外
循环条件: 如果省略, 默认是true, 可以在循环体中控制跳出循环
循环步长: 可以在循环体中控制步长

关于大括号

如果循环体中只有一句语句, 循环体大括号可以省略; 但是出于规范, 一般我们也不省略

/*
 * 需求：求出1-100之间偶数和
 * 
 * 分析：
 *    A:定义求和变量，初始化值是0
 *    B:获取1-100之间的偶数，用for循环实现
 *    C:拿到每一个获取的数据进行判断看是否是偶数
 *      如果是偶数，就累加。
 *    D:输出求和变量
 */
public class ForTest3 {
  public static void main(String[] args) {
    //定义求和变量，初始化值是0
    int sum = 0;
    //获取1-100之间的偶数，用for循环实现
    for(int x=1; x<=100; x++) {
      //拿到每一个获取的数据进行判断看是否是偶数
      if(x%2 == 0) {
        //如果是偶数，就累加。
        sum += x;
      }
    }
    //输出求和变量
    System.out.println("sum:"+sum);
  }
}

逻辑:

先执行循环起点, 一般用与定义一个控制循环的变量, 或者给这个变量一个初始值

再判断循环条件是否成立, 如果循环条件成立, 执行循环体, 再执行循环步长, 然后重新判断循环条件

如果循环条件不成立, 循环结束。

1.9.3.3 循环的嵌套

/*
 * 需求：在控制台打印九九乘法表
    1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6 3*3=9
    ...
 */
public class ForForTest2 {
  public static void main(String[] args) {
    //先打印一个9行9列的星形(列是变化的)
    for(int x=1; x<=9; x++) {
      for(int y=1; y<=x; y++) {
        System.out.print("*");
      }
      System.out.println();
    }
    System.out.println("------------");
    /*
    1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6 3*3=9
    ...
    */
    for(int x=1; x<=9; x++) {
      for(int y=1; y<=x; y++) {
        //\t:转移字符，表示一个tab键的位置
        System.out.print(y+"*"+x+"="+y*x+"\t");
      }
      System.out.println();
    }
  }
}

1.9.3.4 跳出循环

break

break用在循环中, 表示跳出循环; 如果用在多层循环中, 只会跳出当前的一层循环；

/*
 * 如何使用：
 *    A:跳出单层循环
 *    B:跳出多层循环，用带标签的语句格式。
 */
public class BreakDemo {
  public static void main(String[] args) {
    //break可以用于结束当前的循环。
    for(int x=1; x<=5; x++) {
      if(x == 3) {
        break;
      }
      System.out.println("HelloWorld");
    }
    System.out.println("-----------------------");
    //如果是多层循环，break到底结束的是哪个循环呢?
    //break结束的是离他最近的那个循环
    //如果我要跳出外层循环，可不可以呢?
    //可以。如何实现呢?
    //带标签的语句：
    //格式：标签名:语句
    wc:for(int x=1; x<=3; x++) {
      nc:for(int y=1; y<=4; y++) {
        if(y == 2) {
          break wc;
        }
        System.out.print("*");
      }
      System.out.println();
    }
  }
}

continue

continue用在循环中, 表示继续循环, 从continue开始, 后面所有的代码不执行, 直接进入下次循环；

循环标签

一般用在多层循环中, 可以给每一个循环都添加一个标签; 可以配合break语句, 直接结束指定的循环. 或者配合continue语句, 直接终止指定循环的执行, 立即进入下次循环；

/*
 * break和continue的区别：
 *    break:跳出整个循环
 *    continue:跳出这一次的操作，进入下一次的执行
 */
public class ContinueDemo {
  public static void main(String[] args) {
    for(int x=1; x<=5; x++) {
      if(x == 3) {
        continue;
      }
      System.out.println("HelloWorld"+x);
    }
  }
}

1.10 数组

1.10.1 使用场景

数组是存储多个变量(元素)的东西(容器)

这多个变量的数据类型要一致

1.10.2 概念解析

数组是一个容器，是一个用来存储指定数据类型的多个元素的容器；

数组是一个定长容器，一旦实例化完成，长度不能修改；

1.10.3 数组定义

格式：

数据类型[] 数组名;
数据类型数组名[];

A:int[] a; 定义一个int类型的数组，数组名是a
B:int a[]; 定义一个int类型的变量，变量名是a数组

注意：Java中的数组必须先初始化,然后才能使用。

1.10.4 数组初始化

数组初始化：

Java中的数组必须先初始化,然后才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

动态初始化：

初始化时只指定数组长度，由系统为数组分配初始值。

注意：

数组元素的类型是基本类型中的整数类型（byte、short、int 和 long），则数组元素的初始化值是 0。
数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的初始化值是 0.0。
数组元素的类型是基本类型中的字符类型（char），则数组元素的初始化值是‘\u0000’。
数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的初始化值是 false。
数组元素的类型是引用类型（类、接口和数组），则数组元素的初始化值是 null。

//格式：数据类型[] 数组名 = new 数据类型[数组长度];
//数组长度其实就是数组中元素的个数。
//定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
//数组元素的初始化值为0
int[] arr = new int[3];
for (int elem : arr) {
    System.out.println(elem);
}

静态初始化：

初始化时指定数组元素，即给出初始化值，由系统决定长度;

int[] number = new int[]{1, 2, 3, 5, 8};
int[] number = {1,2,3,5,8};

1.10.5 数组访问

元素访问：

通过下标来访问

数组中元素的下标是从0开始的

数组中元素的下标范围: [0, 数组.length - 1]

注意:

在访问数组中元素的时候, 注意下标的范围, 不要越界!!!

public class ArrayDemo {
  public static void main(String[] args) {
  int[] arr = {10，20，30};
  System.out.println("获取第一个元素："+arr[0]);
  System.out.println("获取最后一个元素："+arr[arr.length-1]);
  System.out.println("获取下标为3的元素："+arr[3]);
  }
}

遍历数组:

使用循环遍历下标的方式

int[] array = {1, 2, 3};
for (int index = 0; index < array.length; index++) {
    System.out.println(array[index]);
}

使用增强for循环

int[] array = {1, 2, 3};
for (int ele : array) {
    System.out.println(ele);
}

1.10.6 数组的常见操作

//求一组数据的最大值、最小值、均值等
public class Example{
    public static void main(String[] args) {
        int score[] = { 67, 89, 87, 69, 90, 100, 75, 90 }; // 初始化数组
        int max = 0; // 定义变量保存到最大值
        int min = 0; // 定义变量保存到最小值
      int sum = 0;
      float count = 0.0;
        max = min = score[0]; // 把第1个元素的内容赋值给max和min
        for (int x = 0; x < score.length; x++) { // 循环求岀最大和最小
            if (score[x] > max) { 
                max = score[x]; 
            }
            if (score[x] < min) { 
                min = score[x];
            }
          sum = sum+score[x];
          count = count+1;
        }
        System.out.println("最高成绩：" + max); 
        System.out.println("最低成绩：" + min);
        System.out.println("平均成绩：" + sum/count);
    }
}

1.10.7 数组排序

选择排序

固定一个下标, 然后用这个下标对应的元素依次和后面每一个下标的元素进行比较

int[] array = {1, 3, 5, 7, 9, 0, 8, 6, 4, 2};
for (int index = 0; index < array.length - 1; index++) {
    for (int compare = index + 1; compare < array.length; compare++) {
        if (array[index] < array[compare]) {
            int temp = array[index];
            array[index] = array[compare];
            array[compare] = temp;
        }
    }
}

冒泡排序

依次比较数组中两个相邻的元素

int[] array = {1, 3, 5, 7, 9, 0, 8, 6, 4, 2};
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length - 1 - i; j++) {
        if (array[j] < array[j + 1]) {
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    } 
}

1.10.8 二维数组

二维数组定义的内部逻辑

二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。

二维数组的定义

type arrayName[][];    // 数据类型 数组名[][];
int arr[][];

或

type[][] arrayName;    // 数据类型[][] 数组名;
int[][] arr

初始化二维数组

二维数组可以初始化，和一维数组一样，可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下：

type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

使用第一种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：

int[][] temp = new int[][]{{1,2},{3,4}};

上述代码创建了一个二行二列的二维数组 temp，并对数组中的元素进行了初始化。图 1 所示为该数组的内存结构。

图1 二维数组内存结构

使用第二种方式声明 int 类型的二维数组，然后初始化该二维数组。代码如下：

int[][] temp = new int[2][2];

使用第三种方式声明 int 类型的二维数组，并且初始化数组。代码如下：

int[][] temp = new int[2][];

获取单个元素

在上部分使用的前 2 种方式创建并初始化了一个二行二列的 int 类型数组 temp。当需要获取二维数组中元素的值时，也可以使用下标来表示。语法如下：

arrayName[i-1][j-1];

其中，arrayName 表示数组名称，i 表示数组的行数，j 表示数组的列数。例如，要获取第二行第二列元素的值，应该使用 temp[1][1]来表示。这是由于数组的下标起始值为 0，因此行和列的下标需要减 1。

通过下标获取 class_score 数组中第二行第二列元素的值与第四行第一列元素的值。代码如下：

public static void main(String[] args) {    double[][] class_score = {{10.0,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}};    System.out.println("第二行第二列元素的值："+class_score[1][1]);    System.out.println("第四行第一列元素的值："+class_score[3][0]);}

执行上述代码，输出结果如下：

第二行第二列元素的值：98.0
第四行第一列元素的值：99.5

获取全部元素

在一维数组中直接使用数组的 length 属性获取数组元素的个数。而在二维数组中，直接使用 length 属性获取的是数组的行数，在指定的索引后加上 length（如 array[0].length）表示的是该行拥有多少个元素，即列数。

如果要获取二维数组中的全部元素，最简单、最常用的办法就是使用 for 语句。在一维数组全部输出时，我们使用一层 for 循环，而二维数组要想全部输出，则使用嵌套 for 循环（2 层 for 循环）。

使用 for 循环语句遍历 double 类型的 class_score 数组的元素，并输出每一行每一列元素的值。代码如下：

public static void main(String[] args) 
{    
double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };    
for (int i = 0; i < class_score.length; i++) 
{ // 遍历行        
for (int j = 0; j < class_score[i].length; j++) 
{            
System.out.println("class_score[" + i + "][" + j + "]=" + class_score[i][j]);       
}   
}}

上述代码使用嵌套 for 循环语句输出二维数组。在输出二维数组时，第一个 for 循环语句表示以行进行循环，第二个 for 循环语句表示以列进行循环，这样就实现了获取二维数组中每个元素的值的功能。

获取整行元素

除了获取单个元素和全部元素之外，还可以单独获取二维数组的某一行中所有元素的值，或者二维数组中某一列元素的值。获取指定行的元素时，需要将行数固定，然后只遍历该行中的全部列即可。

编写一个案例，接收用户在控制台输入的行数，然后获取该行中所有元素的值。代码如下：

public static void main(String[] args) {   
double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };    
Scanner scan = new Scanner(System.in);    
System.out.println("当前数组只有" + class_score.length + "行，您想查看第几行的元素？请输入：");    int number = scan.nextInt();    
for (int j = 0; j < class_score[number - 1].length; j++) 
{        
System.out.println("第" + number + "行的第[" + j + "]个元素的值是：" 
+ class_score[number - 1][j]);    }}

获取整列元素

获取指定列的元素与获取指定行的元素相似，保持列不变，遍历每一行的该列即可。

编写一个案例，接收用户在控制台中输入的列数，然后获取二维数组中所有行中该列的值。代码如下：

public static void main(String[] args) {    
  double[][] class_score = { { 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 } };    
  Scanner scan = new Scanner(System.in);    
  System.out.println("您要获取哪一列的值？请输入：");    
  int number = scan.nextInt();    
  for (int i = 0; i < class_score.length; i++) {        
    System.out.println("第 " + (i + 1) + " 行的第[" + number + "]个元素的值是" + class_score[i][number]);    }}

1.11 方法

1.11.1 方法的定义与调用

方法的定义语法

[访问权限修饰符] [其他的修饰符] 返回值类型 方法名([参数列表]) {
    // 方法体
}

修饰符目前记住 public static
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于接收调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码
return 结束方法，把返回值带给调用者

方法的调用

方法中的代码存放在方法区, 默认不会执行, 如果需要执行的话, 需要将方法压栈. 体现出的形式就是调用方法
调用方法直接使用方法的名字即可
方法的执行顺序依照在栈中的顺序执行
方法调用的本质就是在方法调用处，使用传入的参数，插入执行方法的代码

public class MethodDemo {
  public static void main(String[] args) {
    //方法调用
    int result = sum(10,20)
    System.out.println("result:"+result);
  }
  /*
   * 需求：求两个数据之和的案例
   */
  public static int sum(int a,int b) {
    int c = a + b;
    return c;
  }
}

1.11.2 方法的参数与返回值

参数

参数, 其实就是定义在参数列表中的变量, 我们可以在方法体中直接使用这个变量
有参数的方法, 在调用的时候必须给每一个参数赋值

返回值

返回值, 是一个程序运行的结构, 配合return关键字一起使用
return关键字: 表示返回一个值, 并结束方法;

return的返回值, 一定要和方法声明部分的返回值类型相匹配
return也可以用在void返回值类型的方法中, 表示结束方法
如果方法体中有分支结构, 需要保证每一个分支上都有结果返回

1.11.3 方法调用图解

1.11.4 方法的重载

如果一个类中的不同方法, 满足以下两点要求, 他们之间的关系就是重载

方法名相同
参数不同(数量不同, 类型不同)

方法重载特点

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

/*
 * 方法重载：在同一个类中，出现了方法名相同的情况。
 * 
 * 方法重载的特点：
 *    方法名相同，参数列表不同。方法重载与返回值无关。
 * 
 *    参数列表不同：
 *      参数的个数不同。
 *      参数对应的数据类型不同。
 * 
 * 注意事项：
 *    在调用方法的时候，java虚拟机会根据方法名及参数列表的不同来区分方法。
 */
public class MethodDemo {
  public static void main(String[] args) {
    //定义两个变量
    int a = 10;
    int b = 20;
    //求和
    int result = sum(a,b);
    System.out.println("result:"+result);
    //定义变量
    int c = 30;
    //int result2 = sum2(a,b,c);
    int result2 = sum(a,b,c);
    System.out.println("result2:"+result2);
  }
  /*
  public static int sum(int x,int y) {
    return x + y;
  }
  */
  public static float sum(float a,float b) {
    return a + b;
  }
  //求三个数据的和
  /*
  public static int sum2(int a,int b,int c) {
    return a + b + c;
  }
  */
  public static int sum(int a,int b,int c) {
    return a + b + c;
  }
  //求两个数据的和
  public static int sum(int a,int b) {
    /*
    int c = a + b;
    return c;
    */
    return a + b;
  }
}

1.11.5 方法的递归

递归, 就是方法调用自己, 或者方法之间的循环调用; 在使用递归的时候一定要找到递归的出口, 否则循环调用自己的话, 会出现异常 StackOverlowException

public class Factor {
    public static int getFactorial(int n) {
        if (n >= 0) {
            if (n == 0) {
                System.out.println(n + "!=1");
                return 1;
            } else {
                System.out.println(n);
                int temp = n * getFactorial(n - 1);
                System.out.println(n + "!=" + temp);
                return temp;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        getFactorial(4);
    }
}

1. 基础语法（二）