Java从入门到精通(一）

dir：列出点钱目录下的文件以及文件夹
md：创建目录
rd：删除目录
cd：进入指定目录
cd..：退回到上一级目录
cd/：退回到根目录
del：删除文件
exit：退出 DOS 命令行

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello, World!");
    }
}

// 编译错误
String s = 123;
// 编译错误
int i = (int)"123";

/*
    运算符之一：算术运算符
        + - + - * / % (前)++ ++(后) (前)-- --(后) +
*/
public class AriTest {
    public static void main(String[] args) {
        // 除号：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        // 2
        System.out.println(result1);
        int result2 = num1 / num2 * num2;
        // 10
        System.out.println(result1);
        double result3 = num1 / num2;
        // 2.0
        System.out.println(result3);
        // 2.0
        double result4 = num1 / num2 + 0.0;
        // 2.4
        double result5 = num1 / (num2 + 0.0);
        // 2.4
        double result6 = (double) num1 + num2;
        System.out.println(result5);
        System.out.println(result6);
        // 取余：%
        // 结果数的符号与被模数相同
        // 开发中，经常使用 % 来判断能否被除尽的情况
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);
        int m2 = -12;
        int n2 = 5;
        System.out.println("m1 % n1 = " + m2 % n2);
        int m3 = 12;
        int n3 = -5;
        System.out.println("m1 % n1 = " + m3 % n3);
        int m4 = -12;
        int n4 = -5;
        System.out.println("m1 % n1 = " + m4 % n4);
        // (前)++：先自增1，后运算
        // ++(后)：先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a1 = " + a1 + ", b1 = " + b1);
        System.out.println("a2 = " + a2 + ", b2 = " + b2);
        int a3 = 10;
        a3++;
        int b3 = a3;
        // 注意点：自增1不会改变本身变量的数据类型
        short s1 = 10;
        s1++;
        System.out.println(s1);
        byte b = 127;
        b++;
        System.out.println("b = " + b);
        // (前)--：先自减1，后运算
        // --(后)：先运算，后自减1
        int a4 = 10;
        int b4 = --a4;
        System.out.println("a4 = " + a4 + ", b4 = " + b4);
        int a5 = 10;
        int b5 = --a5;
        System.out.println("a5 = " + a5 + ", b5 = " + b5);
    }
}

/*
 * 运算符之二：赋值运算符
 * = += -= *= /= %=
 */
public class SetValueTest {
  public static void main(String[] args) {
    // =:赋值符号
    int i1 = 10;
    int j1 = 10;
    int i2, j2;
    // 连续赋值
    i2 = j2 = 10;
    int i3 = 10, j3 =10;
    int num1 = 10;
    num1 += 2; // num1 = num1 + 2;
    System.out.println(num1);
    int num2 = 10;
    num2 %= 5; // num2 = num2 % 5;
    System.out.println(num2);
    short s1 = 10;
    // 不会改变变量本身的数据类型
    s1 += 2;
    System.out.println(s1);
    // 开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10)
    // 方式1：num = num + 2;
    // 方式2：num += 2; (推荐)
    // 开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10)
    // 方式1：num = num + 1;
    // 方式2：num += 1;
    // 方式3：num++; (推荐)
    // 练习1
    int i = 1;
    i *= 0.1;
    // 0
    System.out.println(i);
    i++;
    // 1
    System.out.println(i);
    // 练习2
    int m = 2;
    int n = 3;
    n *= m++;
    // 3
    System.out.println("m = " + m);
    // 6
    System.out.println("n = " + n);
    // 练习3
    int n1 = 10;
    n1 += (n1++) + (++n1);
    // 32
    System.out.println( n1);
  }
}

/*
 * 运算符之三：比较运算符
 * ==  != > < >= <= instanceof
 * 结论：
 * 1.比较运算符的结果是 boolean 类型
 * 2.区分 == 和 =
 */
public class CompareTest {
  public static void main(String[] args) {
    int i = 10;
    int j = 20;
    System.out.println(i == j); // false
    System.out.println(i = j); // 20
    boolean b1 = true;
    boolean b2 = false;
    System.out.println(b2 == b1); // false
    System.out.println(b2 = b1); // true
  }
}

Account acct1 = new Account(1000);
Account acct2 = new Account(2000);
boolean b1 = acct1 == acct2; // 比较两个 Account 是否是同一账户
boolean b2 = acct1 != acct2;

/**
* Filename : LogicTest.java
* Author : keke
* Creation time : 下午8:06:50 2021年10月30日
* Description : 运算符之四：逻辑运算符
*         && & || | ！ ^
* 说明：
* 1.逻辑运算符操作的都是 boolean 类型的变量
*/
public class LogicTest {
  public static void main(String[] args) {
    // 区分 & 与 &&
    // 相同点：
    // 1.& 与 && 的运算结果相同
    // 2.当符号左边为 true 时，二者都会执行符号右边的运算
    // 不同点：
    // 当符号左边为 false 时，& 会执行符号右边的运算，&& 不会执行符号右边的运算
    // 开发中，推荐使用 &&
    boolean b1 = true;
    b1 = false;
    int num1 = 10;
    if (b1 & (num1++ > 0)) {
      System.out.println("我现在在北京");
    }else {
      System.out.println("我现在在南京");
    }
    System.out.println("num1 = " + num1);
    boolean b2 = true;
    b2 = false;
    int num2 = 10;
    if (b2 && (num2++ > 0)) {
      System.out.println("我现在在北京");
    }else {
      System.out.println("我现在在南京");
    }
    System.out.println("num2 = " + num2);
    // 区分：| 与 ||
    // 相同点：
    // 1.| 与 || 的运算结果相同
    // 2.当符号左边为 false 时，二者都会执行符号右边的运算
    // 不同点：
    // 当符号左边为 true 时，| 会执行符号右边的运算，|| 不会执行符号右边的运算
    // 开发中，推荐使用 ||
    boolean b3 = false;
    b3 = true;
    int num3 = 10;
    if (b3 | (num3++ > 0)) {
      System.out.println("我现在在北京");
    }else {
      System.out.println("我现在在南京");
    }
    System.out.println("num3 = " + num3);
    boolean b4 = false;
    b4 = true;
    int num4 = 10;
    if (b4 || (num4++ > 0)) {
      System.out.println("我现在在北京");
    }else {
      System.out.println("我现在在南京");
    }
    System.out.println("num4 = " + num4);
  }
}

/**
* Filename : BitTest.java
* Author : keke
* Creation time : 下午8:42:10 2021年10月30日
* Description : 运算符之五：位运算符（了解）& | ~ ^ << >> >>>
* 结论：
* 1.位运算符操作的都是整型的数据
* 2.<<：在一定范围内，向左移1位，相当于乘以2
*   >>：在一定范围内，右移1位，相当于除以2
*
* 面试题：最高效的计算 2 * 8 ？ 2 << 3 或 8 << 1
*/
public class BitTest {
  public static void main(String[] args) {
    int i = 21;
    i = -21;
    System.out.println("i << 2 = " + (i << 2));
    System.out.println("i << 3 = " + (i << 3));
    System.out.println("i << 26 = " + (i << 26));
    System.out.println("i << 27 = " + (i << 27));
    System.out.println("i >> 2 = " + (i >> 2));
    int m = 12;
    int n = 5;
    System.out.println("m & n = " + (m & n));
    System.out.println("m | n = " + (m | n));
    System.out.println("m ^ n = " + (m ^ n));
    // 练习：交换两个变量的值
    int num1 = 10;
    int num2 = 20;
    System.out.println("num1 = " + num1 + ", num2 =" + num2);
    // 方式一：定义临时变量 （推荐）
    int temp = num1;
    num1 = num2;
    num2 = temp;
    System.out.println("num1 = " + num1 + ", num2 =" + num2);
    // 方式二：
    // 好处：不用定义临时变量
    // 弊端：
    // 1、相加操作可能超出存储范围
    // 2.有局限性：只能适用于数值类型
    num1 = num1 + num2;
    num2 = num1 - num2;
    num1 = num1 - num2;
    System.out.println("num1 = " + num1 + ", num2 =" + num2);
    // 方式三：使用位运算符
    num1 = num1 ^ num2;
    num2 = num1 ^ num2;
    num1 = num1 ^ num2;
    System.out.println("num1 = " + num1 + ", num2 =" + num2);
  }
}

/**
* Filename : SanYuanTest.java
* Author : keke
* Creation time : 下午9:16:12 2021年10月30日
* Description : 运算符之六：三元运算符
* 1.结构：(条件表达式) ? 表达式1 : 表达式2
* 2.说明
*   1.条件表达式的结果为 boolean 类型
*   2.根据条件表达式真或假，决定执行表达式1，还是表达式2
*     如果表达式为 true，则执行表达式1
*     如果表达式为 false，则执行表达式2
*   3.表达式1和表达式2要求是一致的
*   4.三元运算符是可以嵌套的
* 3.凡是可以使用三元运算符的地方，都可以改写成 if-else
* 4.如果程序既可以用三元运算符，也可以用 if-else，那么优先选择三元运算符
*   原因：简洁、执行效率高
*/
public class SanYuanTest {
  public static void main(String[] args) {
    // 获取两个整数的较大值
    int m = 12;
    int n = 5;
    int max = m > n ? m : n;
    System.out.println(max);
    double num = m > n ? 2 : 1.0;
    // m > n ? 2 : "n大"; // 编译错误
    // 不建议
    String maxStr = m > n ? "m 大" : m == n ? "m 和 n 相等" : "n 大";
    System.out.println(maxStr);
    // 获取三个数的最大值
    int n1 = 12;
    int n2 = 30;
    int n3 = -43;
    max = n1 > n2 ? n1 > n3 ? n1 : n3 : n2;
    System.out.println(max);
    if (m > n) {
      System.out.println(m);
    }else {
      System.out.println(n);
    }
  }
}

if(条件表达式){
    执行表达式
}

if(条件表达式){
    执行表达式1
}else if(条件表达式){
    执行表达式2
}
...
else{
  执行表达式n
}

switch(表达式){
    case 常量1:
        执行语句1;
        // break;
    case 常量2:
        执行语句2;
        // break;
    ...
    default:
        执行语句n;
        // break;
}

1
do{
    3
    4;
}while(2);

for(;;){
}
while(true){
}

package day05;
/**
* Filename : ForForTest.java
* Author : keke
* Creation time : 下午1:47:24 2021年11月1日
* Description :
* 嵌套循环的使用
* 1.嵌套循环：将一个循环结构 A 声明在另一个循环结构 B 的循环体中，就构成了嵌套循环
* 2.外层循环：循环结构 B
*   内层循环：循环结构 A
* 3.说明
*   1.内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
*   2.假设外层循环需要执行 m 次，内层循环需要执行 n 次，此时内层循环的循环体一个执行了 m * n 次
*   3.外层循环控制行数，内层循环控制列数
*/
public class ForForTest {
  public static void main(String[] args) {
    for(int i = 1; i <= 4; i++) {
      for(int j = 1; j <= 6; j++) {
        System.out.print('*');
      }
      System.out.println();
    }
    for(int i = 0; i < 5; i++) {
      for(int j = 0; j <= i; j++) {
        System.out.print('*');
      }
      System.out.println();
    }
    for(int i = 0; i < 5; i++) {
      for(int j = 1; j <= 5 - i; j++) {
        System.out.print('*');
      }
      System.out.println();
    }
    System.out.println("==============================================");
    for(int i = 0; i < 5; i++) {
      for(int j = 0; j <= i; j++) {
        System.out.print('*');
      }
      System.out.println();
    }
    for(int i = 0; i < 5; i++) {
      for(int j = 2; j <= 5 - i; j++) {
        System.out.print('*');
      }
      System.out.println();
    }
  }
}

package day05;
/**
* Filename : NineNineTable.java
* Author : keke
* Creation time : 下午2:31:29 2021年11月1日
* Description :
* 九九乘法表
*/
public class NineNineTable {
  public static void main(String[] args) {
    for (int i = 1; i < 10; i++) {
      for(int j = 1; j <= i; j++) {
        System.out.print(j + " * " + i + " = " + i * j + "\t");
      }
      System.out.println();
    }
  }
}

package day05;
/**
* Filename : PrimeNumberTest2.java
* Author : keke
* Creation time : 下午2:41:08 2021年11月1日
* Description :
* 100以内所有的质数
* 质数：只能被1和它本身整除的自然数，又叫素数 --> 从2开始，到这个数-1结束为止，都不能被这个数本身整除
* 最小的质数：2
*/
public class PrimeNumberTest2 {
  public static void main(String[] args) {
    // 获取当前时间的毫秒数
    long start = System.currentTimeMillis();
    label:
    for(int i = 2; i <= 1000; i++) {
      for(int j = 2; j <= Math.sqrt(i); j++) {
        // i 被 j 除尽
        if (i % j == 0) {
          continue label;
        }
      }
      // 能执行到此步骤的，都是质数
      System.out.print(i + " ");
    }
    System.out.println();
    long end = System.currentTimeMillis();
    System.out.println(end - start);
  }
}

package day04;
import java.util.Scanner;
/**
* Filename : ScannerTest.java
* Author : keke
* Creation time : 下午3:23:13 2021年10月31日
* Description :
* 如何从键盘获取不同类型的变量：需要使用 Scanner 类
* 具体实现步骤：
* 1.导包：import java.util.Scanner;
* 2.Scanner 实例化：Scanner scanner = new Scanner(System.in);
* 3.调用 Scanner 类的相关方法（next() 和 nextXxx()），来获取指定类型的变量
* 注意：
* 需要根据相应的方法，来输入指定类型的值，如果深入到数据类型与要求的类型不匹配，则报异常 InputMismatchException
* 导致程序终止
*/
public class ScannerTest {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入你的姓名：");
    String name = scanner.next();
    System.out.println(name);
    System.out.print("请输入你的年龄：");
    int age = scanner.nextInt();
    System.out.println(age);
    System.out.print("请输入你的体重：");
    double weight = scanner.nextDouble();
    System.out.println(weight);
    System.out.print("是否单身：");
    boolean isLove = scanner.nextBoolean();
    System.out.println(isLove);
    // 对于 char 型的获取，Scanner 没有提供相关的方法。只能获取一个字符串
    System.out.print("请输入你的性别：");
    // 获取索引为0位置上的字符
    char genderChar = scanner.next().charAt(0);
    System.out.println(genderChar);
  }
}

// 1.一维数组的声明和初始化
int[] ids;
// 1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001, 1002, 1003, 1004};
int dids = {1001, 1002, 1003, 1004}; // 类型推断
// 1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
// 错误的写法
// int[] arr1 = new int[];
// int[5] arr1 = new int[];
// int[] arr1 = new int[3]{1, 2, 3};

// 数组的角标（或索引）从0开始，到数组的长度-1结束
names[0] = "王铭";
names[1] = "王赫";
names[2] = "张学良";
names[3] = "张居龙";
names[4] = "王宏志";

// 静态初始化
int[][] arr1 = new int[][] {{1, 2, 3}, {4, 5}, {6, 7, 8}};
// 动态初始化
String[][] arr2 = new String[3][2];
String[][] arr3 = new String[3][];
// 错误的情况
// String[][] arr4 = new String[][3];
// 正确
int arr4[][] = new int[3][];
int[] arr5[] = new int[3][];
// 类型推断
int[] arr6[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};