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. 基础语法（二）

1.9.3 循环流程控制

1.9.3.1 while循环

1.9.3.2 for循环

1.9.3.3 循环的嵌套

1.9.3.4 跳出循环

1.10 数组

1.10.1 使用场景

1.10.2 概念解析

1.10.3 数组定义

1.10.4 数组初始化

1.10.5 数组访问

1.10.6 数组的常见操作

1.10.7 数组排序

1.10.8 二维数组

1.11 方法

1.11.1 方法的定义与调用

1.11.2 方法的参数与返回值

1.11.3 方法调用图解

1.11.4 方法的重载

1.11.5 方法的递归

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

1. 基础语法（二）

1.9.3 循环流程控制

1.9.3.1 while循环

1.9.3.2 for循环

1.9.3.3 循环的嵌套

1.9.3.4 跳出循环

1.10 数组

1.10.1 使用场景

1.10.2 概念解析

1.10.3 数组定义

1.10.4 数组初始化

1.10.5 数组访问

1.10.6 数组的常见操作

1.10.7 数组排序

1.10.8 二维数组

1.11 方法

1.11.1 方法的定义与调用

1.11.2 方法的参数与返回值

1.11.3 方法调用图解

1.11.4 方法的重载

1.11.5 方法的递归

热门文章

最新文章

相关课程

相关电子书

相关实验场景