Scanner

  • java.util.Scanner人机交互的工具类，可以通过Scanner获取用户的输入
  • 基本语法Scanner s = new Scanner(System.in);
  • 通过Scanner类的 next()与nextLine()方法获取输入的字符串，在读取前，一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。 ```java package com.java.base; import java.util.Scanner;

public class Scan { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println(“请输入：”); // next 方法中间输入的空格后面的会忽略掉 / 其他的有： hasNextInt() hasNextFloat() 🤖….. / if (scanner.hasNextLine()) { String str = scanner.nextLine(); System.out.println(“输出内容为：” + str); }

  1.     scanner.close();
  2. }

}

  1. > 输出结果如下
  3. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/13002623/1650699053966-da9a58a4-3bac-459a-8e95-864426f2453d.png#clientId=ue1f7fb73-7bb2-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u6ddd5116&margin=%5Bobject%20Object%5D&name=image.png&originHeight=184&originWidth=289&originalType=binary&ratio=1&rotation=0&showTitle=false&size=7909&status=done&style=none&taskId=u79af5f18-f2a6-43c7-9377-0ddedcd8cad&title=)
  5. - 用户输入计算输出demo
  6. ```java
  7. package com.java.base;
  9. import java.util.Scanner;
  11. public class Scanplus {
  12.     public static void main(String[] args) {
  13.         Scanner scanner = new Scanner(System.in);
  14.         double sum = 0;
  15.         int m = 0;
  16.         while(scanner.hasNextDouble()) {
  17.             double x = scanner.nextDouble();
  18.             m++;
  19.             sum += x;
  20.         }
  21.         System.out.println(m + "个数字的和"+ sum);
  22.         System.out.println(m + "个数字的平均" + sum/m);
  23.         scanner.close();
  24.     }
  25. }

流程

顺序结构

  • java的基本结构就是顺序结构，除非特殊指明，否则就按照顺序一句一句执行
  • 顺序结构是最简单的算法结构
  • 语句与语句之间，框与框之间是自上而下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

Java基础(第二篇) - 图1

选择结构

Java基础(第二篇) - 图2

多选择结构

  • if …else if…else

  • switch

    语法

  • for

  • while
  • do…while
  • switch
  • ….

    方法

    ```java // 修饰符(可选) 返回值 方法名 (参数类型 参数名) {return 返回值;} public static void main(String[] args) {

}

  1. <a name="Y3NWr"></a>
  2. ### 方法的重载
  4. 1. 重载就是在一个类中，有相同的函数名称，但形参不同的函数
  5. 2. 方法重载的规则
  6. - 方法名称必须相同
  7. - 参数列表必须不同（个数不同、类型不同、参数的排列顺序不同等）
  8. - 仅仅返回类型不同不足以成为重载的方法
  9. 3. 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，已选择对应的方法，如果匹配失败，则编译器报错。
  10. ```java
  11. package com.java.base;
  14. /*
  15. *
  16. */
  17. public class Reload {
  18.     public static void main(String[] args) {
  19.         double max = max(2.0, 2);
  20.         System.out.println(max);
  21.     }
  22.     public static double max (double num1, double num2) {
  23.         double res = 0.0;
  24.         if(num1 == num2) {
  25.             return 0;
  26.         }
  28.         if(num1 > num2) {
  29.             res = num1;
  30.         }else {
  31.             res = num2;
  32.         }
  33.         return res;
  34.     }
  36.     public static int max (int num1, int num2) {
  37.         int res = 0;
  38.         if(num1 == num2) {
  39.             return 0;
  40.         }
  42.         if(num1 > num2) {
  43.             res = num1;
  44.         }else {
  45.             res = num2;
  46.         }
  47.         return res;
  48.     }
  50. }

命令行传参

  1. package com.java.base;
  3. public class Command {
  4.     public static void main(String[] args) {
  5.         for (int i = 0; i < args.length; i++) {
  6.             System.out.println("args[" + i + "]:" + args[i]);
  7.         }
  8.     }
  9. }

编译java文件

  1. > javac Command.java
  2. > cd src //切换到src目录下
  3. > java com.java.base.Command this is my args //<this is my args>为参数

image.png

可变参数

  • 从java1.5开始，Java支持传递同类型的可变参数给一个方法
  • 在方法声明中，在指定参数类型后加一个省略号（…）
  • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明 ```java package com.java.base;

public class Var { public static void main(String[] args) { Var var = new Var(); var.test(1, 11.0); } public void test(int x, double …i) { System.out.println(i[0]); } }

  1. <a name="Iynfa"></a>
  2. ### 递归
  4. - 调用方法自身（自己调自己）
  5. - 递归结构包含两个部分
  6.    1. 递归头：什么时候不调用自身的方法。如果没有头，将陷入死循环
  7.    2. 递归体：什么时候调用自身
  8. ```java
  9. package com.java.base;
  11. public class Recursion {
  12.     public static void main(String[] args) {
  13.         System.out.println(f(5));
  14.     }
  15.     public static int f(int n) {
  16.         if(n == 1) {
  17.             return 1;
  18.         }else {
  19.             return n * f(n - 1);
  20.         }
  21.     }
  22. }

数组

  1. // 变量类型 变量的名称 = 变量的值
  2. int[] nums; //声明一个数组
  4. // 数组类型
  5. int num2[];
  7. nums = new int[10]; //创建一个数组 10个元素大小的数组
  8. /*
  9.     为数组元素赋值
  10. */
  11. nums[0] = 1;
  12. nums[1] = 2;
  13. ....
  14. nums[9] = 10;
  16. // int[] nums = new int[10];

基本特点

  • 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
  • 其元素必须是相同类型，不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包扩基本类型和引用类型。
  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中的对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。 ```java package com.java.base;

public class Array { public static void main(String[] args) { int[] nums = {1, 2 ,3, 4, 5}; int[] res = reverse(nums); for (int i = 0; i < res.length; i++) { System.out.print(res[i]); } } public static int[] reverse(int[] arr) { int[] result = new int[arr.length]; for (int i = 0, j = arr.length -1; i < arr.length; i++, j—) { result[j] = arr[i]; } return result; } }

  1. <a name="KOKtx"></a>
  2. ### Arrays类
  3. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/13002623/1650708778054-fd4155ac-0f4c-4dfb-83ba-5d35ebbf343e.png#clientId=ubb5738ae-d5c0-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=638&id=u453bfee0&margin=%5Bobject%20Object%5D&name=image.png&originHeight=957&originWidth=2297&originalType=binary&ratio=1&rotation=0&showTitle=false&size=237480&status=done&style=none&taskId=ud39a19a7-a838-45d9-be1f-f78f878ace6&title=&width=1531.3333333333333)
  4. <a name="VujsD"></a>
  5. ### 冒泡排序
  6. ```java
  7. package com.java.base;
  9. import java.util.Arrays;
  11. public class Array {
  12.     public static void main(String[] args) {
  13.         int[] nums = {7, 2 ,3, 4, 5};
  14.         int[] popRes = popSort(nums);
  15.         System.out.println(Arrays.toString(popRes));
  16.     }
  18.     public static int[] popSort(int[] arr) {
  19.         int temp = 0;
  21.         // 外层循环，判断要走多少次
  22.         for (int i = 0; i < arr.length - 1; i++) {
  23.             boolean flag = false; //通过flag减少没有意义的比较
  24.             // 内层循环， 判断两个数字，如果第一个比第二个大，交换位置
  25.             for (int j = 0; j < arr.length -1 - i; j++) {
  26.                 if(arr[j + 1] < arr[j]) {
  27.                     temp = arr[j];
  28.                     arr[j] = arr[j + 1];
  29.                     arr[j + 1] = temp;
  30.                     flag = true;
  31.                 }
  32.             }
  33.             if (flag) {
  34.                 break;
  35.             }
  36.         }
  37.         return arr;
  38.     }
  39. }

static关键字详解

  1. private static int age; // 静态
  2. private double score; // 非静态
  4. Student s1 = new Student();
  5. s1.age;
  6. s1.score;
  7. Student.age;
  8. Student.score; // 无法访问