安装jdk

1. 百度java官网找到对应的版本下载jdk

2. 配置环境变量：

   1. 电脑高级系统设置 -> 环境变量

   2. 系统变量 -> 新建

   3. 找到系统变量中的Path -> 新建

      注意：jdk11以上的版本中没有jre文件夹，在jdk路径下打开命令提示符执行以下语句可生成jre文件夹。

      bin\jlink.exe --module-path jmods --add-modules java.desktop --output jre

   4. 完成后在命令提示符输入命令查看java版本

      java -version

      成功! :smiley:

注释

单行注释--//

public class Hello {
    public static void main(String[] args){
        // 单行注释
    }
}

多行注释--/ 注释 /

public class Hello {
    public static void main(String[] args){
        /*
        多
        行
        注
        释
        */
    }
}

文档注释--/* 文档注释 /

public class Hello {
    public static void main(String[] args) {
        /**
         * @Description Hello
         * @Author lwh
         */
    }
}

#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
#parse("File Header.java")
/**
 * @time ${DATE} ${TIME}
 * @author LWH
 */
 
public class ${NAME} {
    public static void main(String[] args){
        
    }
}

数据类型

• 八大基本类型

public class hello {
    public static void main(String[] args) {
        // 八大数据类型
        // 整数类型
        byte b = 20;
        short s = 30;
        int i = 40;
        long l = 50L; //Long类型一般在数字后面加L
        
        // 浮点类型
        float f = 0.1F; //float类型一般在数字后面F
        double d = 0.2;
        
        // 字符类型
        char c = 'a';

        // 布尔类型
        boolean bl = true;

        // 字符串
        String st = "你是谁"; //String 不是关键字，是一个类

    }
}

• 引用类型：八大基本类型外的数据类型，叫做引用类型。

类型转换

低---------------------------------------------------->高

byte，short，char -> int -> long -> float -> double

• 强制类型转换：(类型)变量名 高->低

public class demo01 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;
        
        System.out.println(i);//128
        System.out.println(b);//-128      
    }
}

• 自动类型转换：低->高

public class demo01 {
    public static void main(String[] args) {
        int i = 128;
        double d = i;

        System.out.println(i);//128
        System.out.println(d);//128.0
    }
}

运算符

• 算数运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&，||，!

public class Demo03 {
    public static void main(String[] args) {
        //算数运算符
        int a = 15;
        int b = 20;
        int e = 0;
        //e++|++e -> 自增：e = e + 1
        int x = e++;//执行后自增
        int y = ++e;//执行前自增
        //-- 自减
        System.out.println(a + b);//35
        System.out.println(a - b);//-5
        System.out.println(a * b);//300
        System.out.println(a / (double) b);//0.75
        System.out.println(b % a);//m模运算(取余) 5

        System.out.println(x);//0
        System.out.println(y);//2

        //关系运算符
        int c = 25;
        int d = 30;
        System.out.println(c > d);//false
        System.out.println(c < d);//true
        System.out.println(c == d);//false
        System.out.println(c != d);//true

        //逻辑运算符
        boolean t = true;
        boolean f = false;
        System.out.println(t && f);//false 与：两个变量全为真，结果为true
        System.out.println(t || f);//true 或：两个变量其中一个为真，结果为true
        System.out.println(!(t && f));//true 非：取反
    }
}

Scanner

• next()：

  • 1、一定要读取到有效字符后才可以结束输出。
  • 2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或结束符。
  • 4、next()不能得到带有空格的字符串。

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收:");

        // 使用next方式接收
        String str = scanner.next();
        System.out.println("输出的内容为:"+str);

        // 凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

结果：

使用next方式接收:
hello world
输出的内容为:hello

• nextLine()：

  • 1、以Enter为结束符，nextLine()方法返回的是输入回车之前的所有字符串。
  • 2、可以获得空白。

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接收:");

        // 使用next方式接受
        String str = scanner.nextLine();
        System.out.println("输出的内容为:"+str);

        // 凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

结果：

使用nextLine方式接收:
hello world
输出的内容为:hello world

选择结构

• if单选择结构

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        if (s.equals("Hello")) {
            System.out.println(s);
        }

        System.out.println("End");

        scanner.close();
    }
}

结果：

请输入内容：
Hello
Hello
End
===========
请输入内容：
abc
End

• if双选择结构

import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        // 考试分数大于60及格，小于60不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score>=60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
        
        scanner.close();
    }
}

结果：

请输入成绩：
60
及格
===========
请输入成绩：
59
不及格

• if多选择结构

import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        // 考试分数大于60及格，小于60不及格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score==100) {
            System.out.println("满分");
        } else if (score<100 && score>=90) {
            System.out.println("A");
        }  else if (score<90 && score>=80) {
            System.out.println("B");
        }  else if (score<80 && score>=70) {
            System.out.println("C");
        }  else if (score<70 && score>=60) {
            System.out.println("D");
        } else if (score<60 && score>=0) {
            System.out.println("不及格");
        } else {
            System.out.println("不合法成绩");
        }

        scanner.close();
    }
}

结果：

请输入成绩：
100
满分
===========
请输入成绩：
59
不及格
===========
请输入成绩：
86
B
===========
请输入成绩：
110
不合法成绩

switch多选择结构

public class Demo4 {
    public static void main(String[] args) {
        // case穿透 因此每一个case都要加一个break
        // switch 匹配一个具体的值
        char grade = 'C';

        switch (grade) {
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            case 'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知");
        }
    }
}

结果：

及格

在java SE7之后switch支持String类型的匹配

public class Demo05 {
    public static void main(String[] args) {
        String name = "国栋";

        switch (name) {
            case "大碗鱼":
                System.out.println("番薯黎噶");
                break;
            case "国栋":
                System.out.println("国家栋梁之才");
                break;
            default:
                System.out.println("啥也不是");
        }
    }
}

结果：

国家栋梁之才

因为case匹配到相等的值后会执行后面所有的语句，所以要在每一个case最后加上一个break

循环结构

• while循环

public class Demo01 {
    public static void main(String[] args) {
        // 计算1到100总和

        int i = 0;
        int sum = 0;

        while (i<100) { //i小于100时循环
            sum += i
            i++;
            System.out.println(i);
        }
    }
}

结果：

5050

• do...while循环

public class Demo02 {
    public static void main(String[] args) {
        // 计算1到100总和

        int i = 0;
        int sum = 0;

        do {
            sum += i;
            i++;
        } while (i<=100);
        System.out.println(sum);
    }
}

结果：

5050

• while与do...while的区别：

  • while先判断后执行；do...while先执行后判断
  • do...while总是保证循环体至少会被执行一次

public class Demo03 {
    public static void main(String[] args) {
        int a = 0;

        while (a < 0) {
            System.out.println("执行了while" + a);
            a++;
        }
        System.out.println("=====================");
        do {
            System.out.println("执行了do...while" + a);
            a++;
        } while (a < 0);
    }
}

结果：

=====================
执行了do...while0

• for循环

public class demo02 {
    public static void main(String[] args) {
        // 计算1到100 奇数和与偶数和
        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                oddSum += i;
            } else {
                evenSum += i;
            }
        }

        System.out.println("奇数和：" + oddSum);
        System.out.println("偶数和：" + evenSum);
    }
}

结果：

奇数和：2500
偶数和：2550

• 数组集合中的for循环

public class Demo05 {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50}; // 数组

        // 遍历数组的元素
        for (int x : numbers) {
            System.out.println(x);
        }
    }
}

结果：

10
20
30
40
50

break & continue

• break：在任何循环语句的主体中，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩下的语句。

public class Demo01 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 100) {
            i++;
            System.out.print(i + "\t");
            if (i == 5) {
                break;
            }
        }
    }
}

结果：

1    2    3    4    5    

• continue：在循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断。

public class Demo02 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 50) {
            i++;
            if (i % 2 == 0 || i % 3 == 0 || i % 5 == 0) {
                continue;
            }
            System.out.print(i + "\t");
        }
    }
}

结果：

1    7    11    13    17    19    23    29    31    37    41    43    47    49    

方法(函数)

• 方法是解决一类问题的步骤的有序组合。
• 方法包含于类或对象中。
• 方法在程序中被创建，在其他地方被引用。
• 原则：一个方法只完成1个功能，这样有利于后期扩展。

public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 10);
        System.out.println(max);
    }

    // 比大小
    public static int max(int num1, int num2) {
        int result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }
}

结果：

num1=num2
0

方法的重载

• 重载：在一个类中，有相同的函数名称，但形参不同的函数。

• 方法的重载规则：

  • 方法名称必须相同。
  • 参数列表必须不同(个数不同、类型不同、参数排列顺序不同等)。
  • 方法的返回类型可以相同也可以不相同。
  • 仅仅返回类型不同不足以成为方法的重载。

public class Demo02 {
    public static void main(String[] args) {
        int max_int = max(10, 20);
        double max_double = max(10.0, 20.0);
        System.out.println(max_int);
        System.out.println(max_double);
    }

    // 比大小
    public static int max(int num1, int num2) {
        int result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }

    public static double max(double num1, double num2) {
        double result = 0;

        if (num1 > num2) {
            result = num1;
        } else if (num2 > num1) {
            result = num2;
        } else {
            System.out.println("num1=num2");
            return 0; // return:终止方法
        }
        return result;
    }
}

结果：

20
20.0

可变参数(不定项参数)

• 在方法声明中，指定参数类型后加一个省略号(...)。
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo04 {
    public static void main(String[] args) {
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        //排序
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

结果：

The max value is 56.5
The max value is 3.0

递归

• 方法自己调用自己。

• 递归两部分：

  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
  • 递归体：什么时候需要调用自身方法。

public class Demo06 {
    public static void main(String[] args) {
        // 阶乘
        System.out.println(f(5));
    }
    // 1! 1
    // 5! 5*4*3*2*1
    private static int f(int n) {
        if (n==1) {
            return 1;
        } else {
            return n*f(n-1);
        }
    }
}

结果：

120

数组

• 数组是相同类型数据的有序集合。
• 数组描述的是相同类型的若干个数据，按照一定先后次序排列组合而成。
• 每一个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问。

数组声明创建

public class Demo01 {
    public static void main(String[] args) {
        // 数组声明创建
        int[] nums = new int[10];
        // 给数组中元素赋值
        nums[0] = 1;

        System.out.println(nums[0]);
        System.out.println(nums[1]); // 没有赋值的元素以默认值输出 
    }
}

结果：

1
0

• 数组的元素是通过索引访问的，数组的索引从0开始。
• 获取数组长度：arrays.length

• 初始化：

public class Demo02 {
    public static void main(String[] args) {
        // 静态初始化：创建+赋值
        int[] a = {1, 2, 3, 4, 5, 6};
        // 动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;

    }
}

• 数组的默认初始化

  • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

• 数组的四个基本特点：

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

数组的使用

• for-each循环

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

结果：

1
2
3
4
5

• 作方法入参

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        printArray(arrays);
    }

    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

结果：

1 2 3 4 5 

• 数组作返回值

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    // 打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

    // 翻转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

结果：

5 4 3 2 1 

多维数组

• 多维数组可以看成是数组的数组，如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

public class Demo05 {
    public static void main(String[] args) {
        // 二维数组
        // [4][2] 4行2列
        int[][] array = {{1, 2}, {2, 3}, {3, 4}};

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

结果：

1
2
2
3
3
4

• 以上array可以看成是一个4行2列的数组。

冒泡排序

import java.util.Arrays;
public class Demo07 {
    public static void main(String[] args) {
        int[] a = {13, 5, 6, 3, 25, 7};
        System.out.println(Arrays.toString(sort(a)));
    }

    // 冒泡排序
    // 比较相邻两个元素，如果第一个比第二个大，就交换位置
    // 每一次比较，都会产生出一个最大或最小的数字
    // 下一轮则可以少一次排序
    // 依次循环，直到结束

    public static int[] sort(int[] array) {
        // 临时变量
        int temp = 0;
        // 外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            // 内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置

            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
}

结果：

[3, 5, 6, 7, 13, 25]