KuangStudy 狂神说 JavaSE 学习笔记

firemarks

于 2022-11-04 13:15:30 发布

阅读量245

点赞数

文章标签：学习 java 开发语言

本文链接：https://blog.csdn.net/firemarks/article/details/127686889

版权

JavaSE

基础

基础 01 注释

单行注释
- ```
// 单行注释
```
多行注释
- ```
/*
	多行注释
*/
```

文档注释

/**
*@Description Hello World
*@Author 
*/

基础 02 标识符、关键字

关键字

abstract; boolean; break; byte; case; catch; char; class; continue; default; do; double; else; extends; false; final; finally; float; for; if; implements; import; instanceof; int; interface; long; native; new; null; package; private; protected; public; return; short; static; super; switch; synchronized; this; throw; throws; transient; true; try; void; volatile; while

标识符
- 规则见[Java开发手册（黄山版）.pdf]

基础 03 数据类型

基本数据类型
- 数值类型
  - 整数类型
    - byte占 1 个字节，min：-128（-2^{7）max：127（2}7-1）
    - short占 2 个字节，min：-32768（-2^{15）max：32767（2}15-1）
    - int占 4 个字节，默认值 0，min：-2,147,483,648（-2^{31）max：2,147,483,647（2}31-1）
    - long占 8 个字节，min：-9,233,372,036,854,775,808（-2^{63）max：9,223,372,036,854,775,807（2}63-1）
  - 浮点类型
    - float占 4 个字节
    - double占 8 个字节
  - 字符类型
    - char占 2 个字节，默认值null
- boollean类型：占 1 位，其值只有true和false两个，默认值false
引用数据类型
- 类
- 接口
- 数组

基础 04 数据类型拓展

整数
- 二进制 0b
- 十进制
- 八进制 0
- 十六进制 0x
浮点数
- 最好完全避免使用浮点数进行比较
- 银行业务怎么表示？ ==> BigDecimal 数学工具类
字符
- 所有字符的本质还是数字
- 编码 Unicode 表：（97 = a 65 = A）
- 2 字节 65536
- U0000 UFFFF
转义字符
- \t 制表符
- \n 换行符
- \a 响铃
- \b 退格
- \f 换页
- \r 回车
- \v 垂直制表
- \\ 反斜线字符
- \’ 单引号(撇号)字符
- \" 双引号字符
- \0 空字符

基础 05 类型转换

低 -----------------------------------------------------------------------> 高
byte -> short, char -> int -> long -> float -> double

强制类型转换
- （类型）变量名高 --> 低
自动类型转换
- 低 --> 高

注意点

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或者精度问题

//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years; // -1474836480，计算的时候溢出了
long total2 = money*years; // 还是-1474836480，因为右边还是int类型，转换之前已经存在问题了
long total3 = money*((long)years); // 2000000000，先把一个数转换为long，则全部转换为long

基础 06 变量、常量、作用域

变量

类变量
实例变量（从属于对象）
局部变量（从属于方法，必须声明和初始化值）

public class Variable {
       
    static int allClick = 0;	//类变量
    String str = "Hello world";	//实例变量
    public void method() {
       
        int i = 0;	//局部变量
    }
}

常量（Constant）
- 初始化（initialize）后不能再改变值
- 常量名一般使用大写字符
- ```
final double PI = 3.14;
```
命名规范
- 所有变量、方法、类名：见名知意
- **类成员变量：**首字母小写和驼峰原则：monthSalary
- **局部变量：**首字母小写和驼峰原则
- **常量：**大写字母和下划线：MAX_VALUE
- **类名：**首字母大写和驼峰原则：Man，GoodMan
- **方法名：**首字母小写和驼峰原则：run()，runRun()

基础 07 运算符

算术运算符 +, -, *, /, %, ++, –
- int以下精度运算（short，byte），结果自动转化为int
- 幂运算 2^3
- ```
double pow = Math.pow(2,3);
```
赋值运算符 =
关系运算符 >, <, >=, <=, ==, !=, instanceof

逻辑运算符 &&, ||, !

注意短路运算

boollean a = true;
boollean b = false;
System.out.println(a && b);	//false，先执行判断a，后执行判断b
System.out.println(b && a);	//false，先执行判断b，直接短路，不执行判断a

位运算符 &, |, ^, ~, >>, <<, >>>

&, |, ~, ^：位运算的与，或，非，异或

A = 0011 1100
B = 0000 1101
A & B	//与，0000 1100
A | B	//或，0011 1101
A ^ B	//异或，0011 0001
~ B    //非，1111 0010

2 × 8 最快运算方法？
- <<左移，相当于 × 2
- >>右移，相当于 ÷ 2
- ```
System.out.println(2 << 3);
```

条件运算符 ? :
扩展赋值运算符 +=, -=, *=, /=

基础 08 包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
- ```
package pkg1[. pkg2[. pkg3...]];
```
一般利用公司域名倒置作为包名；
为了能够使用某一个包的成员，需要在Java程序中明确导入该包，使用import语句可完成此功能：
- ```
import package1[. package2...].(classname|*);
```

基础 09 `javadoc`生成文档

javadoc命令是用来生成自己 API 文档的
参数信息
- @author作者名
- @version版本号
- @since指明需要最早使用的jdk版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况

流程控制

流程控制 01 用户交互`Scanner`

基本语法

Scanner scanner = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

import java.util.Scanner;
public class Hello {
       
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        if(scanner.hasNext()){
       
            String str = scanner.next();
            System.out.println("输入的内容为："+str);
        }
        // 凡是属于IO流的类如果不关闭会一直占用资源，应该使用完就关掉。
        scanner.close();
    }
}

next()：
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
nextLine()：
- 以 Enter 为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
- 可以获得空格

流程控制 02 `Scanner`进阶使用

输入整数

import java.util.Scanner;
public class Hello {
       
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);
        int i;
        if (scanner.hasNextInt()) {
       
            i = scanner.nextInt();
            System.out.println(i);
        } else {
       
            System.out.println("输入的不是整数。");
        }
        scanner.close();
    }
}

输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

import java.util.Scanner;
public class Hello {
       
    public static void main(String[] args) {
       
        double sum = 0.0D;
        int m = 0;
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextDouble()) {
       
            sum += scanner.nextDouble();
            m++;
        }
        System.out.println("总和为：" + sum + "\n平均数为：" + sum / m);
        scanner.close();
    }
}

流程控制 03 顺序结构

Java 的基本结构就是顺序结构，除非特别指明，否则就按顺序逐句执行

流程控制 04 `if`选择结构

if单选择结构

if (布尔表达式) {
       
    // 如果布尔表达式的值为 true 执行代码
}

if双选择结构

if (布尔表达式) {
       
    // 如果布尔表达式的值为 true 执行代码
} esle {
       
    // 如果布尔表达式的值为 false 执行代码
}

if多选择结构

// 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行
if (布尔表达式 1) {
       
    // 如果布尔表达式 1 的值为 true 执行代码
} esle if (布尔表达式 2) {
       
    // 如果布尔表达式 2 的值为 true 执行代码
} esle if (布尔表达式 3) {
       
    // 如果布尔表达式 3 的值为 true 执行代码
} esle {
       
    // 如果以上布尔表达式的值均为 false 执行代码
}

嵌套的if结构

if (布尔表达式 1) {
       
    // 如果布尔表达式 1 的值为 true 执行代码
    if(布尔表达式 2) {
       
        // 如果布尔表达式 2 的值为 true 执行代码
    }
}

流程控制 05 `switch`多选择结构

switch语句中的变量类型可以是byte、short、int或者char

从 Java SE 7 开始，switch支持字符串String类型了，同时case标签必须为字符串常量或字面量

switch (expression) {
       
	case value:
	// 语句
	break; // 可选
	case value:
	// 语句
	break; // 可选
	default: // 可选
	// 语句
}

case穿透现象：从满足条件的case value开始，执行后面所有的case，直到遇到 break停止

流程控制 06 `while`循环

while是最基本的循环，其结构为：

while (布尔表达式) {
       
	// 循环内容
}

只要布尔表达式为true循环就会一直执行下去
大多数情况会让循环停止下来，需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等

流程控制 07 `do`…`while` 循环

对于while语句而言，如果不满足条件，则不能进入循环
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次
- ```
do {
       
	// 代码语句
} while (布尔表达式);
```

流程控制 08 `for`循环

for循环执行的次数在执行前就确定，语法格式如下：

for (初始化;布尔表达式;更新) {
       
    // 代码语句
}

IDEA 快捷键：100.for后回车，自动生成：

for (int i = 0; i < 100; i++) {
       

}

练习1：计算0到100之间的奇数和偶数的和

public static void main(String[] args) {
       
    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);
}

练习2：用while或for循环输出 1-1000 之间能被 5 整除的数，每行输出 3 个

public static void main(String[] args) {
       
    for (int i = 1; i < 1000; i++) {
       
        if (i % 5 == 0) {
       
            System.out.print(i + "\t");
        }
        if (i % 15 == 0) {
       
            System.out.println();
        }
    }
}

练习3：打印九九乘法表

public static void main(String[] args) {
       
    for (int i = 1; i <= 9; i++) {
       
        for (int j = 1; j <= i; j++) {
       
            System.out.print(j+"×"+i+"="+j*i+"\t");
        }
        System.out.println();
    }
}

流程控制 09 增强`for`循环

Java 5 引入了一种主要用于数组或集合的增强型for循环

Java 增强for循环语法格式如下：

for (声明语句 : 表达式)
{
       
    // 代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public static void main(String[] args) {
       
    int[] numbers = {
       10, 20, 30, 40, 50};
    for (int x : numbers) {
       
        System.out.println(x);
    }
}

流程控制 10`break`、`continue`、`goto`

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

public static void main(String[] args) {
       
    int i = 0;
    while (i < 100) {
       
        i++;
        System.out.println(i);
        if (i == 30) {
       
            break; // 打破 while 循环，至此只输出到 30
        }
    }
    System.out.println("123"); // 证明只是打破 while 循环，函数仍在执行。
}

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

public static void main(String[] args) {
       
    int i = 0;
    while (i < 100) {
       
        i++;
        if (i % 10 == 0) {
       
            System.out.println();
            continue; // 后面输出 i 不执行，直接进入下一次 while 循环
        }
        System.out.print(i);
    }
}

关于goto关键字

goto关键字很早就在程序设计语言中出现。尽管goto仍是 Java 的一个保留字，但并未在语言中得到正式使用 —— Java 没有goto。然而，在break和continue这两个关键字的身上，我们仍能看出一些goto的影子 —— 带标签的break和continue。例如label:

// 输出 101 到 150 之间的质数
public static void main(String[] args) {
       
    outer: for (int i = 101; i < 150; i++) {
       
        for (int j = 2; j < i/2; j++) {
       
            if (i % j == 0) {
       
                continue outer; // 直接跳转到 outer:
            }
        }
        System.out.print(i + " ");
    }
}

对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会终端到存在标签的地方。

流程控制 12 打印三角形及菱形

打印三角形

import java.util.Scanner;
public class Hello {
       
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
       
            for (int j = 0; j < n-i-1; j++) {
       
                System.out.print(" ");
            }
            for (int j = 0; j < 2*i+1; j++) {
       
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印菱形

import java.util.Scanner;
public class Hello {
       
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < 2*n-1; i++) {
       
            if (i < n) {
       
                for (int j = 0; j < n-i-1; j++) {
       
                    System.out.print(" ");