闲话

先来扯一点java的闲话吧

扯一点历史

Java之父是一定要记住的，那就是詹姆斯·高斯林！Java最早是由Sun公司(已被Oracle收购)的高斯林在上个世纪90年代初开发的一种编程语言，一开始是被命名为Oak，后面由于该商标已经被人注册了，因此SUN公司就注册了Java这个商标。之后，我们伟大的Java语言就诞生成最重要的编程语言了。

编译型语言和解释型语言

• 编译型语言例如C、C++，他们的代码在运行前被预先编译成机器码然后才被执行，具有高效便捷的特点，但是基于不同的平台的CPU指令集的不同，因此编译型语言需要根据不同平台编译出不同的机器码

• 解释型语言例如Python、Ruby，他们是由解释器直接加载源码并逐行执行的，具有灵活、能跨平台运行的特点，不依赖于平台，但是这样的话运行效率就会很低。

Java是介于解释型语言和编译型语言之间的一种语言（Maybe更偏向于编译型语言的解释），Java会将代码编译成一种字节码，就是一种抽象的CPU指令和语法树，之后被JVM虚拟机根据不同的平台将字节码解释执行或编译成机器码

Java的版本一共有三种：

• Java SE：Standard Edition
• Java EE：Enterprise Edition
• Java ME：Micro Edition（无特殊需求不建议学）

最重要的其实就是前面的JavaSE和JavaEE

简单来说，Java SE就是标准版，包含标准的JVM和标准库，而Java EE是企业版，它只是在Java SE的基础上加上了大量的API和库，以便方便开发Web应用、数据库、消息服务等，Java EE的应用使用的虚拟机和Java SE完全相同。

总而言之，Java SE是一整个Java体系学习的基础和核心，而Java EE是为了进一步学习Web应用开发所需要的，所以我们从Java SE开始入手去学习

JavaSE基础知识

参考文章：https://liaoxuefeng.com/books/java/quick-start/history/index.html、菜鸟教程

先讲讲Java语言的几个重要特性

• Java语言是面向对象的语言(oop)
• Java语言是健壮的，Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。
• Java语言是跨平台型的语言
• Java语言是强类型的语言

然后还有两个特别的名词，JDK和JRE，他们分别是什么呢？

JRE就是运行java字节码的一种虚拟机运行环境，包含 JVM + Java 核心类库；而JDK是java的开发工具包，包含了java的开发，编译的工具

和环境，可以将java代码编译成字节码。

这里放一个师傅的图片

关于JDK

安装教程的话这里就不说了，还是很简单的，然后我们关注一个点

在JAVA_HOME的bin目录下找到很多可执行文件：

• java.exe：这个可执行程序其实就是JVM，运行Java程序，就是启动JVM，然后让JVM执行指定的编译后的代码；
• javac.exe：这是Java的编译器，它用于把Java源码文件（以.java后缀结尾）编译为Java字节码文件（以.class后缀结尾）；
• jar.exe：用于把一组.class文件打包成一个.jar文件，便于发布；
• javadoc.exe：用于从Java源码中自动提取注释并生成文档；
• jdb.exe：Java调试器，用于开发阶段的运行调试。

javac 是 Java 编译器，它的作用是读取 .java 文件并将其编译成 .class 文件，一旦生成了 .class 文件，就可以使用 java 命令来运行程序

HelloWorld的开始

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。

程序员的第一个程序必然就是hello world了，那我们先拿这个代码来分析一下

public class HelloWorld {
    /* 我的第一个Java程序
     * 它将输出字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 输出 Hello World
    }
}

类声明

• public：这是一个访问修饰符，表示该类可以被其他类访问。
• class：关键字，用于声明一个类。
• HelloWorld：这是类的名称，必须与文件名相同（HelloWorld.java）。

main主方法：

• public：修饰符，表示该方法可以被任何其他类调用。
• static：关键字，表示该方法属于类，而不是类的实例。程序运行时不需要先创建类的对象。
• void：表示该方法没有返回值。
• main：方法名称，Java 程序的入口点。JVM（Java Virtual Machine）会从这里开始执行程序。
• String[] args：这是一个参数，表示可以接收命令行输入的字符串数组。

输出语句

• System.out：这是 Java 中的一个输出流对象，用于向控制台打印信息。
• println：这是一个方法，用于打印括号内的内容，并在打印后换行。
• “Hello World”：这是要输出的字符串。

代码编辑好后运行的话就是在cmd窗口进行操作

如何运行java程序

java源码本质上是一个java类型的文本文件，我们需要先用javac把.java文件编译成字节码文件.class文件，然后，用java命令执行这个字节码文件

从图中可以看到一个命令

java HelloWorld

为什么这里是HelloWorld呢？其实是因为JVM虚拟机会根据我们传入的类名去查找对应的class文件，这也就涉及到一个类加载机制的问题了，后面再细说。

Java程序的基本结构

从上面的HelloWorld来分析

public class HelloWorld {
    /* 我的第一个Java程序
     * 它将输出字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 输出 Hello World
    }
}

因为java是面向对象的编程语言，所以一个java程序的基本单位就是class

编写 Java 程序时，应注意以下几点：

• 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
• 类名和接口名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 变量名和方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 常量名：所有字母都大写。多单词时每个单词用下划线隔开

常量是特殊的变量！

• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

标识符命名规则

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

• 开头不能是数字
• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary

修饰符

和php一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符

• 一种是可访问修饰符:public(公共),protected(受保护),private(私有),default(默认)

1. public（公共）
   • 任何其他类都可以访问。没有访问限制。
   • 示例：public class MyClass {}
2. protected（受保护）
   • 仅限于同一个包中的类以及子类（无论是否在同一个包中）访问。
   • 示例：protected int myVariable;
3. default（默认）
   • 如果没有指定任何访问修饰符，则为默认访问权限（包私有）。仅限于同一个包中的类访问。
   • 示例：class MyClass {}
4. private（私有）
   • 仅限于该类内部访问，其他类无法访问。
   • 示例：private int myVariable;

• 一种是非访问修饰符:

1. static（静态）
   • 表示该成员属于类而不是类的实例，可以通过类名直接访问。
   • 示例：static int myStaticVariable;
2. final（最终）
   • 用于声明类、方法或变量。
   • • 类：表示该类不能被继承。
     • 示例：final class MyFinalClass {}
   • • 方法：表示该方法不能被子类重写。
     • 示例：final void myMethod() {}
   • • 变量：表示该变量的值不能被改变（常量）。
     • 示例：final int MY_CONSTANT = 10;
3. abstract（抽象）
   • 用于类和方法。
   • • 类：表示该类不能被实例化，通常用于为子类提供模板。
     • 示例：abstract class MyAbstractClass {}
   • • 方法：表示该方法没有实现，子类必须实现该方法。
     • 示例：abstract void myAbstractMethod();
4. synchronized（同步）
   • 用于方法或代码块，表示该方法或代码块在同一时间只能被一个线程访问，适用于多线程环境下的同步。
   • 示例：synchronized void myMethod() {}
5. volatile（易失性）
   • 用于变量，表示该变量可能会被多个线程修改，以确保每次读取变量时都从主内存中获取。
   • 示例：volatile int myVariable;
6. transient（瞬态）
   • 用于变量，表示该变量不应被序列化。当对象被序列化时，瞬态变量的值不会被保存。
   • 示例：transient int myTransientVariable;

注释

单行注释:以//开始

多行注释:以/*开始，以*/结束

文档注释:以 /* 开始，每行开头用*号开始以 */ 结束

关于文档注释的DOS命令

javadoc -d 文件夹名 -xx -yy java文件名

转义字符

常用的转义字符

• \t：水平制表符(类似于tab键)
• \n：换行符
• \\：表示常规字符反斜杠
• \"：表示常规字符双引号
• \'：表示常规字符单引号
• \r：回车符，将光标移到该行开头逐个覆盖字符

数据类型

Java 数据类型分为两大类：基本数据类型和引用数据类型。

基本数据类型

1. 整数类型：
   • byte：1 字节，范围从 -2^7到2^7-1（-128 到 127）。
   • short：2 字节，范围从 -2^15到2^15-1（-32,768 到 32,767）。
   • int：4 字节，范围从 -2^31到2^31-1（-2,147,483,648 到 2,147,483,647）。
   • long：8 字节，范围为 -2^63 到 2^63-1（-9223372036854775808 到 9223372036854775807）。定义变量的时候需要在初始值后加上一个L，例如12345678L
2. 浮点类型：
   • float：单精度浮点型，4 字节，适合表示小数，范围约为 ±3.40282347E+38（有效位数约为 7 位）。定义变量的时候需要在结尾加上f，例如0.0f
   • double：双精度浮点型，8 字节，适合表示较大或较小的浮点数，范围约为 ±1.79769313486231570E+308（有效位数约为 15 位）。
3. 字符类型：
   • char：2 字节，表示单个字符，用单引号包裹，支持 Unicode 字符集，范围从 '\u0000' 到 '\uffff'。
4. 布尔类型：
   • boolean：表示两个值之一，true 或 false，通常用于条件判断。

那java定义的这些基本数据类型有什么区别呢？这就得了解一下计算机内存的基本结构了

计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，也就是8个bit。它的二进制表示范围从

0000000011111111，换算成十进制是0255，换算成十六进制是00~ff。

在内存中，内存单元是按内存地址去编号的，每个内存单元就相当于一间房间，而内存地址就是其房间号

  0   1   2   3   4   5   6  ...
┌───┬───┬───┬───┬───┬───┬───┐
│   │   │   │   │   │   │   │...
└───┴───┴───┴───┴───┴───┴───┘

我们理清一下一些内存单位的大小关系

1K = 1024byte
1M = 1024K
1G = 1024M
1T = 1024G

基于上面的定义，我们来看看基本数据类型占用的字节数大小

       ┌───┐
  byte │   │
       └───┘
       ┌───┬───┐
 short │   │   │
       └───┴───┘
       ┌───┬───┬───┬───┐
   int │   │   │   │   │
       └───┴───┴───┴───┘
       ┌───┬───┬───┬───┬───┬───┬───┬───┐
  long │   │   │   │   │   │   │   │   │
       └───┴───┴───┴───┴───┴───┴───┴───┘
       ┌───┬───┬───┬───┐
 float │   │   │   │   │
       └───┴───┴───┴───┘
       ┌───┬───┬───┬───┬───┬───┬───┬───┐
double │   │   │   │   │   │   │   │   │
       └───┴───┴───┴───┴───┴───┴───┴───┘
       ┌───┬───┐
  char │   │   │
       └───┴───┘

再次感谢师傅的图，实在是真的懒得重新画了

引用数据类型

引用数据类型用于存储对象的引用，而不是对象本身。主要包括：

• 类（Class）：
  • Java 中的类可以定义用户自定义数据类型。通过类的实例化可以创建对象。
• 接口（Interface）：
  • 接口是抽象的一种类型，可以定义方法的签名，通常用于实现多态。
• 数组（Array）：
  • 数组是相同类型元素的集合，可以是基本数据类型的数组或引用数据类型的数组。

放个具体的例子来实验一下

public class HelloWorld {
    public static void main(String[] args){
        //byte
        System.out.println("byte的二进制位数:"+Byte.SIZE);
        System.out.println("byte的最小值:"+Byte.MIN_VALUE);
        System.out.println("byte的最大值:"+Byte.MAX_VALUE);
        System.out.println();
        //short
        System.out.println("short的二进制位数:"+Short.SIZE);
        System.out.println("short的最小值:"+Short.MIN_VALUE);
        System.out.println("short的最大值:"+Short.MAX_VALUE);
        System.out.println();
        //int
        System.out.println("int的二进制位数:"+Integer.SIZE);
        System.out.println("int的最小值:" + Integer.MIN_VALUE);  
        System.out.println("int的最大值:" + Integer.MAX_VALUE);  
        System.out.println();  
        // long  
         System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
         System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
         System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
         System.out.println();     
        // float  
         System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
         System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
         System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
         System.out.println();  
        // double  
         System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
         System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
         System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
         System.out.println();     
        // char  
         System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        // 将char的最小值转化成整数型进行输出    
         System.out.println("最小值：Character.MIN_VALUE="  
                 + (int) Character.MIN_VALUE);  
        // 将char的最大值转化成整数型进行输出  
         System.out.println("最大值：Character.MAX_VALUE="  
                 + (int) Character.MAX_VALUE);        
    }
}

输出结果

这个代码纯属是为了练练手才一个个打出来的，学编程还是建议多动手哈

特别说明一下啊关于这些数据类型的默认值(也就是当我们并没有给这些数据类型的变量进行赋值的时候的默认值)

• int, short, long, byte 的默认值是0。
• char 的默认值是 \u0000（空字符）。
• float 的默认值是 0.0f。
• double 的默认值是 0.0d。
• boolean 的默认值是 false。
• 引用类型（类、接口、数组）的默认值是 null。

说起这个数据类型我们不得不聊到存储的地址，基本数据类型的变量都是直接存储在栈中的，而引用数据类型的变量则分为两个区域，引用(指向堆的地址)存储在栈中，通过访问变量名称读取栈中的地址，进而我们去访问存储的数据

数据类型的转化

类型转换主要分为两种：自动类型转换（隐式转换）和强制类型转换（显式转换）。

• 自动类型转换

小转大

当将一种较小范围的基本数据类型赋值给较大范围的基本数据类型时，Java 会自动进行转换

byte->short,char—> int —> long—> float —> double 

说白了就是大的数据类型的范围可以容纳小的数据类型的所有范围

但是这里的话是没有boolean的，boolean是不能进行转换的

那我们怎么从大的数据类型转化成小的数据类型呢?这就是我们的强制类型转换了

• 强制类型转换

格式:

(type)value

type就是需要转换的数据类型了，例如从浮点数强制转化成整数，(int)131.4=131,但是要注意我们的值不能超过小类型的范围

String转化成char

System.out.println(gender.charAt(0));

基本数据类型转化成String

语法：基本类型+ ““即可

int n1 = 1;
String s1 = n1 + "";
System.out.println(s1);
//1

String转化成基本数据类型

语法：

通过基本类型的包装类调用parsexxx方法进行转化，例如Integer.parseInt()

//String转化成基本数据类型的方法
public class StringToBasic {
    public static void main(String[] args) {
        //String -> int
        String s1 = "123";
        int n1 = Integer.parseInt(s1);
        System.out.println(n1);

        //String -> double
        String s2 = "123.456";
        double n2 = Double.parseDouble(s2);
        System.out.println(n2);

        /*
        . 
        . 
        . 
        */
    }
}

java变量

变量的概念：

• 内存中的一个存储区域，该区域有自己的名称(变量名)和类型(数据类型)
• 和其他语言一样，变量需要先声明后使用
• Java是强类型语言，每个变量在声明的时候必须声明数据类型
• 变量只能作用在作用域内(最近的一对花括号中)

声明变量的格式

最好变量名是能清晰体现其用途的，比如我的名字的变量就是myName，用小写字母开头，后面的单词首字母大写

static int a;
修饰符+数据类型+变量名

声明变量后再给变量赋值，但是也是可以直接对变量进行定义初始化的，格式如下：

数据类型 变量名 = 初始值(如果没有的话就是null)

变量的分类(按声明的位置分)

• 局部变量

在方法、构造函数或代码块中声明的变量，只能在该特定方法、构造函数或代码块内访问。(方法中声明的变量)

• 类变量(静态变量)

使用 static 关键字声明的变量，属于类本身，而不是任何特定的实例。所有对象共享同一个类变量(应该就是类似于define常量)

1. 由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量。
2. 常量和静态变量的区别，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。

• 成员变量

在类中声明，但不在方法内的变量，属于类的实例。每个对象都有自己的一份实例变量。(在类中的成员属性)

1. 当一个对象被实例化之后，每个成员变量的值就跟着确定。
2. 成员变量在对象创建的时候创建，在对象被销毁的时候销毁

这个直接理解成php中的对象和类里面的成员变量就可以了

然后我在教程中还发现了一种变量类型

• 参数变量

参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。(说白了就是函数的形参嘛)

前面几个比较好理解，最后一个参数变量我们来稍微讲一下

参数变量的值传递方式有两种：值传递和引用传递。

可以看成是c语言中的函数引用，值传递就是正常的传值，从形参到实参，实参可以是具体的值也可以是一个内存地址，值传递的特点是实参不会变，而引用传递的特点是实参也会改变。下面我会写一个具体的实例去进行讲解

public class HelloWorld{
    public String name="wanth3f1ag";//成员变量
    public static void change(int x ,int y){//参数变量
        int a = x;//局部变量
        int b = y;
        int c = a;
        a = b;
        b = c;
    }
    public static void main(String[] args){
        int a= 20,b=10;
        change(a,b);
        System.out.println("a= " + a + "b= " + b);
    }
}
//a= 20b= 10

java运算符

• 算术运算符

• 关系运算符

• 位运算符

• 逻辑运算符

&和&&的区别:

• 单&时，左边无论真假，右边都会执行
• 双&时，如果左边为真则执行右边运算，如果为假则不执行
• 和”||“的区别同理，双|时左边为真右边则不执行

异或("^”)“和(”|")不同的是,对御^而言，左右结果为true时，结果为false

• 赋值运算符

值得注意的是，在我们的变量为一个对象的时候，关系运算符比较的是两个变量的地址而不是字符串

其他运算符:三目运算符

格式

布尔表达式?执行语句1:执行语句2

若表达式为真则执行语句1，为假则执行语句2

java键盘输出和输入语句

输出语句

在前面的时候就已经介绍过了，我们通常会用System.out.println()来向屏幕输出一些内容，但是println是print line的缩写，表示输出并换行，如果不需要换行的话可以用System.out.print()

• 格式化输出

C语言里面介绍过，这里就不必多说

输入语句

我们可以通过 Scanner 类来获取用户的输入，具体步骤如下

1.导入该类所在的包 java.util.*或java.util.Scanner
2.创建该类对象Scanner scanner = new Scanner(System.in)
3.调用里面的功能scanner.next()

创建Scanner对象并传入System.in。System.out代表标准输出流，而System.in代表标准输入流。

使用next()方法

在处理输入的时候我们需要使用Scanner中的方法，例如next

这里的完整令牌就是字符串，这意味着他只会读取一个字符串，我们先正常演示一下

//如何进行键盘输入
//1.导入Scanner所在的包
import java.util.Scanner;

public class Input {
    public static void main(String[] args) {
        //2.new创建一个实例化对象
        Scanner input = new Scanner(System.in);
        //3.接收用户的输入 需要使用相关的方法
        System.out.println("请输入你的名字");
        String name = input.next();
        System.out.println("你的名字是: " + name);
    }
}
/*
请输入你的名字
wanth3f1ag
你的名字是: wanth3f1ag
*/

另外还能根据需要赋值的变量的类型去决定输入的内容被标记为什么类型

实例操作一下

//如何进行键盘输入
//1.导入Scanner所在的包
import java.util.Scanner;

public class Input {
    public static void main(String[] args) {
        //2.创建一个实例化对象
        Scanner input = new Scanner(System.in);
        
        //3.接收用户的输入 需要使用相关的方法
        //使用next方法标记输入的类型为字符串
        System.out.println("请输入你的名字");
        String name = input.next();
        
        //使用nextint方法标记输入的类型为整型
        System.out.println("请输入你的年龄");
        int age = input.nextInt();
        
        //使用nextdouble方法标记输入的类型为双精度浮点型
        System.out.println("请输入你的身高");
        double heigh = input.nextDouble();
        
        System.out.println("你的身高是: " + heigh);
        System.out.println("你的年龄是: " + age);
        System.out.println("你的名字是: " + name);
    }
}

使用nextline()方法

//如何进行键盘输入
//1.导入Scanner所在的包
import java.util.Scanner;

public class Input {
    public static void main(String[] args) {
        //2.创建一个实例化对象
        Scanner input = new Scanner(System.in);
        //3.接收用户的输入 需要使用相关的方法
        //使用next方法标记输入的类型为字符串
        System.out.println("请输入你的名字");
        String name = input.nextLine();
        //使用nextint方法标记输入的类型为整型
//        System.out.println("请输入你的年龄");
//        int age = input.nextInt();
//        //使用nextdouble方法标记输入的类型为双精度浮点型
//        System.out.println("请输入你的身高");
//        double heigh = input.nextDouble();
//        System.out.println("你的身高是: " + heigh);
//        System.out.println("你的年龄是: " + age);
        System.out.println("你的名字是: " + name);

    }
}
/*
请输入你的名字
asdhiawda jdsdjsd
你的名字是: asdhiawda jdsdjsd
*/

在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据，当然这个判断输入数据的也是有不同类型的

next() 与 nextLine() 区别

next():

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

nextLine()：

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

java循环控制

分为三种：for循环，while循环，do…while循环

for循环

for(变量初始化; 循环条件; 循环变量迭代) {
    //代码语句
}

开始循环前有初始化值，每次循环开始前都会进行循环条件的判断，true则进入循环，false则结束循环，每次循环结束都会执行更新语句

需要注意的是

1. 循环条件是可以返回布尔值的表达式
2. 变量初始化可以是多条初始化语句，但要求类型一致，语句之间逗号隔开
3. 循环变量迭代也是可以有多条语句的，并且迭代语句和初始化语句可以为空，但是分号不能少

while循环

while( 循环条件 ) {
  //循环内容
}

如果循环的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

do…while循环

do {
       //代码语句
}while(布尔表达式);

和while循环语句一样，但是由于布尔表达式在循环体的后面，do…while循环语句在进行进入循环前都会先进行一次代码语句。如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

break关键字

主要在循环语句和控制语句中，可以跳出最里层的循环，并且继续执行该循环下面的语句。

continue关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代

在for语句中continue会直接结束当前循环进入下一循环而不是跳出循环

在 while 或者 do…while 循环中，continue会立即跳转到布尔表达式的判断语句。

java分支控制

if单分支语句

if(布尔表达式){
   //如果布尔表达式为true将执行的语句
}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则不执行

举个例子

//if单分支语句

import java.util.Scanner;

public class IF01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        int age = scanner.nextInt();//获取输入的年龄
        if(age >= 18) {
            System.out.println("你已经满18岁了");
        }
    }
}

if…else双分支语句

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 else 语句块后面的代码。

//if单分支语句

import java.util.Scanner;

public class IF01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        int age = scanner.nextInt();//获取输入的年龄
        if(age >= 18) {
            System.out.println("你已经满18岁了");
        }else System.out.println("你还未满18岁");
    }
}

if…else if…else 多分支语句

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

一个if语句只能有一个else语句，else语句都会在末尾，在所有的 else if 语句之后。一个if语句可以有若干个else if语句。一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

嵌套的 if…else 语句

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

当然也可以向上面一样嵌套if ..else if语句

if(布尔表达式 1){
   ////如果布尔表达式 1的值为true执行代码
   if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
		}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
		}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
		}else {
   //如果以上布尔表达式都不为true执行代码
		}
}

switch case语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(表达式){
    case 常量1 :
       //语句 1
       break; //可选
    case 常量2 :
       //语句2
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

在这个语句中需要注意几个细节

1. 表达式数据类型应该和case后的常量类型一致，或者是可以自动转化为可以相互比较的类型，例如表达式的数据类型是字符，而case后的常量是int
2. switch中的表达式的返回值必须是(byte,short,int,char,enum,String)
3. case子语句中的值必须是常量或常量表达式而不能是变量
4. 变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
5. 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

关于java的那些结构语句的话其实和c语言差不多，我就不赘述了

java数组

数组简单来说就是相同类型的数的一个集合

• 先声明数组变量

dataType[] arrayRefVar;   // 首选的方法
或
dataType arrayRefVar[];  // 效果相同，但不是首选方法

java中声明数组时候不能指定数组长度，例如int class[40]；这样是错误的

数组属于引用类型，数组型数据是对象，数组中每个元素相当于该对象的成员变量，所以数组在使用前需要先创建

• 再创建数组

arrayRefVar = new dataType[arraySize];

注意:数组需要声明长度并且长度不可变

当然，我们声明数组和创建数组可以一起完成

dataType[] arrayRefVar = new dataType[arraySize];
or
dataType[] arrayRefVar = {value0, value1, ..., valuek};

• 数组的引用

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 数组名.length-1。

数组的下标可以是整形常量也可以是表达式，但是切记需要在数组长度的取值范围内去引用，不然会导致出错

可以用length属性去获取数组的长度，例如class.length可以指向class数组的长度

• 数组初始化

和我们基本数据类型的初始值是一样的

• int, short, long, byte 的默认值是0。
• char 的默认值是 \u0000（空字符）。
• float 的默认值是 0.0f。
• double 的默认值是 0.0d。
• boolean 的默认值是 false。
• 引用类型（类、接口、数组）的默认值是 null。

我们定义什么类型的数组，数组的初始化值就是什么样的

接下来我们写个一维数组感受一下

public class HelloWorld{
    public static void main(String[] args) {
        //String[] students;//数组的声明1
        String students[];//数组的声明2
        students = new String[5];//数组的创建方法1
        //String[] students = new String[5]//数组的声明和创建方法1
        //String[] students = {"John","Jane"}//数组的声明和创建方法2
        students[0] = "John";
        students[1] = "Mary";
        students[2] = "Jane";
        students[3] = "Bob";
        students[4] = "Alice";
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
    }
}

打印出的结果就是各个元素的名字

通常我们在处理数组或者引用数组的时候都会搭配循环去进行使用，例如对数组的数据进行赋值，以及操作数组等

import java.util.Scanner;

//输入数组的数据
public class Array01{
    public static void main(String[] args) {
        int[] arr1 = new int[10];
        Scanner scanner = new Scanner(System.in);
        for(int i = 0; i < arr1.length; i++){
            arr1[i] = scanner.nextInt();
            System.out.println(arr1[i]);
        }
    }
}

数组赋值机制

Java 中的参数传递机制是 按值传递（Pass by Value），但对于对象（包括数组）来说，传递的是对象的引用（即内存地址）的副本

值传递和引用传递的区别

基本数据类型的传递方式为值传递，即两个数之间不会互相影响

public class Test01{
    public static void main(String[] args){
    	int n1 = 10;
    	int n2 = n1;
    
    	n2 = 80;
    	System.out.println("n1 = " + n1);
    	System.out.println("n2 = " + n2);
    }
}
//n1 = 10
//n2 = 80

数组在默认情况下是引用传递

public class Array01 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int[] arr2 = arr1;//arr2指向arr1的地址
        arr2[0] = 10;

        System.out.println(arr1[0]);
    }
}
//10

在 Java 中，数组是一个对象。即使数组存储的是基本数据类型（如 int[]），数组本身也是一个对象。因此，数组的传递遵循对象的传递规则。

面向对象OOP

对象和类的基础知识

• 对象：对象是类的一个实例，有状态和行为。
• 类：类是一种数据类型，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 变量：变量就是状态，一个类可以有很多变量。类的状态都是由变量去决定的
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

比如，我们类可以看成是一类动物，行为和状态就指的是动物的一些特点，而对象就可以具体到哪些动物，拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑。这些行为和状态就是可以看成是一个个实例变量和方法，而具体的名字等等就是变量的值，具体的行为就是方法了。在java中状态可以看成是成员属性(变量)，而行为就是方法

因为之前学过php，所以对这些的理解的话其实大致上是一样的。

那我们如何定义一个类并且获得一个实例呢？

举个例子

//定义一个猫类Cat
class Cat{
    //定义猫的名字，年龄，毛色
    String name;
    int age;
    String color;
}

在这里我们定义了一个Cat猫的类，其中有猫的名字，年龄，毛色等属性变量（因为是在Object01.java类中另外定义的猫类，所以这里不需要加上修饰符），然后假如我们这里有一只小花猫叫小花，年龄是3岁，毛色为花色，我们如何获得这个猫的实例呢？

[!IMPORTANT]

一个Java源文件可以包含多个类的定义，但只能定义一个public类，且public类名必须与文件名一致。如果要定义多个public类，必须拆到多个Java源文件中。

访问实例变量和方法

我们需要记得的是，类是一种引用数据类型，跟基本数据类型的使用是一样的

/* 实例化对象 */
类名 对象名 = new 类名();
/* 访问类中的变量 */
对象名.实例属性;
/* 访问类中的方法 */
对象名.类方法();

完整的代码

//类和对象学习01

//利用OOP思想定义猫类和实例对象
public class Object01 {

    public static void main(String[] args) {
        //实例化一只猫并赋值给cat1

        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "花色";

        //输出猫的信息
        System.out.println("小猫的名字是: " + cat1.name + "\n"
                + "小猫的年龄是: " + cat1.age + "\n"
                + "小猫的毛色是: " + cat1.color);
    }
}

//定义一个猫类Cat
class Cat{
    //定义猫的名字，年龄，毛色
    String name;
    int age;
    String color;
}

所以我们可以看出：

• 类是抽象的，概念的，代表的是一类事物，也就是说类跟int，double一样，是自定义的引用数据类型
• 而对象是具体的，实际的，例如int a = 200这个变量a是具体的，他有具体的数据类型和值：整型200
• 简单来说类就是对象的模板，而对象则是类的一个实际个体

定义方法

定义方法的语法是

修饰符 方法返回类型 方法名(参数列表){
    方法执行语句;
    return方法返回值;(可选)
}

方法返回值通过return语句实现，如果没有返回值，返回类型设置为void，可以省略return。

this变量

在方法内部可以用一个隐含的变量this，它指向的是当前的实例，例如this.field表示访问当前实例的字段

但是如果没有变量命名的冲突的话就没必要使用this

class Person{
    private String name;
    public void setName(String name){
        this.name = name;//因为这里有一个同名变量name，所以需要用this.name表示当前实例的name字段
    }
}

构造方法

在创建类的实例化对象的时候我们通常需要初始化该对象的字段，这时候就需要用到构造方法了

关于构造方法的特点，构造方法名就是类名，并且构造方法的参数是无限制的，但是构造方法是没有返回值的

• 默认构造方法

其实任意一个类都是有构造方法的，如果我们自身在构造类的时候没有给他编写一个构造方法的话，java编译器会自动为我们生成一个默认的空构造方法，大致是这样的

class Person{
    public Person(){
        
    }
}

但是需要主意的是，如果我们自身编写了一个构造方法的话，编译器就不会自动创建一个默认的构造方法了

例如以下情况就是报错的

// 构造方法
public class Main {
    public static void main(String[] args) {
        Person p = new Person(); // 编译错误:找不到这个构造方法
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
}

这里的话因为我们本身定义了一个构造方法，该构造方法是需要传入参数的，而我们的new Person是无参构造函数，所以这里会报错

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来

// 构造方法
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
        Person p2 = new Person(); // 也可以调用无参数构造方法
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

• 多个构造方法

当一个类有多个构造方法，我们尝试用new去调用的时候，编译器会通过构造方法的参数数量、未知和类型去进行自动的一个区分和选择

举个例子

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
        this.age = 20;
    }

    public Person() {
    }
}

如果调用new Person("Xiao Ming", 20);，会自动匹配到构造方法public Person(String, int)。

如果调用new Person("Xiao Ming");，会自动匹配到构造方法public Person(String)。

如果调用new Person();，会自动匹配到构造方法public Person()。

当然一个构造方法中可以调用其他的构造方法

具体语法就是this(参数列表)

public Person(String name){
    this(name,18)
}
public Person(String name,int age){
    this.name = name;
    this.age = age;
}

方法重载

一个类中可以有多个同名方法，这种方法名相同但是参数不同的就叫做方法重载（Overload），而重载方法返回值类型应该相同。

extends继承

这个可以类似于寄生的过程，在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class）或者父类、基类，派生类称为子类（sub class）。

子类自动获得了父类的所有字段，并且严禁定义与父类重名的字段

[!IMPORTANT]

需要主意的是，Java只允许一个class继承自一个类并且一个类有且仅有一个类，如果一个类没有明确写明继承什么类的话，他都是继承于object，object是一个特殊的类，他没有继承任何的父类

继承有个特点，就是子类无法访问父类的private字段或者private方法。但是protected修饰的字段和方法可以被子类所访问。因此，protected关键字可以把字段和方法的访问权限控制在继承树内部

举个例子

class Person{
    protected String name;
    protected int age;
}
class Son extends Person{
    public String getName(){
        return "Hello, " + name;
    }
}

super关键字

super关键字通常用于表示当前子类继承的父类（超类），例如用super.field可以访问父类的字段

其实通常情况下使用super.name，或者this.name，或者name，效果都是一样的。编译器会自动定位到父类的name字段。

但是在某些情况下就必须用到super了

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(); // 自动调用父类的构造方法
        this.score = score;
    }
}

在任何class的构造方法中，第一行语句必须是调用父类的构造方法，所以我们需要加上super()去调用父类的构造方法

多态

Override覆写

在继承关系中如果子类定义了一个跟父类方法签名完全一样的方法，就需要用到Override覆写

Override和Overload不同的是，如果方法签名不同，就是Overload，Overload方法是一个新方法；如果方法签名相同，并且返回值也相同，就是Override。

但是需要注意的是，方法名相同，方法参数相同，但方法返回值不同，也是不同的方法。

例如我们举个例子

class Person{
    public void run(){...}
}
class Son extends Person{
    public void run(String s){...}
    public int run(){...}
}

在son中的这两种方法都不是Override，第一个run的方法参数和父类的不相同，第二个run的方法返回值类型和父类的不同。

另外可以直接加上@Override去检查是否是覆写，不是的话编译器会报错

那什么是多态呢？

多态就是同一个对象的行为（方法调用）在不同的运行时类型下表现出不同的形式。

举个例子就能明白了

public class Main{
    public static void main(String[] args){
        Person p = new Son();	//关注点1
        p.run();//关注点2
    }
}
class Person{
    public void run() {
        System.out.println("Person.run");
    }
}
class Son extends Person{
    @Override
    public void run(){
        System.out.println("Son run");
    }
}

在关注点1中可以看到，此时我们实例化了一个p对象，该对象是一个实际类型为Son，但引用类型为Person的对象，那么实际上这里调用的run方法是Son的run方法

由此我们可以得出：

**父类引用指向子类对象，调用方法时会执行子类的实现。**Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。

但是实现多态的话需要满足下面三个点：

• 继承（类与类之间有继承关系 / 接口实现）
• 方法重写（Override）（子类重新实现父类的方法）
• 父类引用指向子类对象

父类类型 变量名 = new 子类类型();

覆写Object

在Object中有几个重要的方法：

• toString()：把instance输出为String；
• equals()：判断两个instance是否逻辑相等；
• hashCode()：计算一个instance的哈希值。

因此当我们需要重新定义这几个方法的时候需要用到Override

final关键字

如果一个父类不允许子类对他的某个方法进行覆写的话，可以用final关键字标记该方法，用final标记的方法不能被Override

class Person {
    protected String name;
    public final String hello() {
        return "Hello, " + name;
    }
}

class Student extends Person {
    @Override
    public String hello() {
    }
}

这里的话会报错

如果一个类不希望其他类继承他的话，也可以用final去标记这个类，用final修饰的类不能被继承

final class Person{
}
class Son extends Person{}

这里是报错的

如果一个类的字段不希望在初始化后被修改的话，可以用final去标记这个字段，用final修饰的字段不能被修改

class Person{
    public final String name = "wanth3f1ag";
}
Person p = new Person();
p.name = "bao";

最后的赋值操作会报错

但是在构造方法中可以初始化final修饰的字段

publc class Person{
    public final String name;
    public Person(String name){
        this.name = name;
    }
}

但是一样的，在实例化对象之后final修饰的字段就没法被修改了

总结一下

final修饰符有多种作用：

• final修饰的方法可以阻止被覆写；
• final修饰的class可以阻止被继承；
• final修饰的field必须在创建对象时初始化，随后不可修改。

abstract抽象

在Java中，abstract是一个关键字，用来定义抽象类和抽象方法，作用是让类和方法只定义其规范而不提供完整实现，必须由子类去实现

对于抽象类

• 用abstract修饰的抽象类不能通过new去实例化
• 因为抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。

对于抽象方法：

• 一个类中存在抽象方法的话，这个类也必须用abstract去修饰

接口与接入接口

如果一个抽象类中的方法都是抽象方法的话，就可以用inferface去修饰他，也就是声明为一个接口。

接口简单来说就是一个抽象类型，是抽象方法的集合，通常以interface来声明。一个类通过实现继承接口的方式去继承接口的抽象方法。

但是接口和类不同的是，类是用于描述对象的属性和方法，而接口则是包含类要实现的方法，但是接口不提供这些方法的具体实现，无法被实例化。

接口的几个特点

• 接口不能被实例化成对象

• 接口的方法都是抽象方法

• 接口中每个方法都是隐式抽象的，会被隐式的指定为public abstract，非抽象方法可以定义default方法

• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

• 定义接口

[修饰符] interface [接口名称] {
	//声明变量
	//抽象方法
}

当一个具体的class去实现一个interface时，需要使用implements关键字。

class Son implements Person

一个类只能继承于另一个类，但是一个类可以实现多个interface

一个interface继承自另一个interface，需要用extends去修饰

interface Hello{}
interface Person extends Hello{}

static静态字段和静态方法

静态字段

静态字段和实例字段不同的地方在于，实例字段仅属于该实例，而静态字段是所有实例共享的，

举个简单的例子

class Person{
    public String name;
    public int age;
    public static int number;
    
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}
public class Main{
    public static void main(String[] args){
        Person bao = new Person("bao",20);
        Person meng = new Person("meng",21);
        bao.number = 111;
        System.out.println(bao.number + "和" + meng.number);
        meng.number = 222;
        System.out.println(bao.number + "和" + meng.number);
    }
}
//111和111
//222和222

由上面可以看出，对于静态字段，他并不属于某个特定的实例，当我们修改某个实例的静态字段时，其他实例的该静态字段都将被修改

因此，不推荐用实例变量.静态字段去访问静态字段，因为在Java程序中，实例对象并没有静态字段。在代码中，实例对象能访问静态字段只是因为编译器可以根据实例类型自动转换为类名.静态字段来访问静态对象。

静态方法

静态方法和实例方法不同的是，调用实例方法必须要有一个实例对象，而调用静态方法则不需要实例对象，通过类名.静态方法()就可以调用

package包

在java中往往会有很多同名类，这时候就需要用package去解决同名类的名字冲突

搬运师傅的解释：

小明的Person类存放在包ming下面，因此，完整类名是ming.Person；

小红的Person类存放在包hong下面，因此，完整类名是hong.Person；

小军的Arrays类存放在包mr.jun下面，因此，完整类名是mr.jun.Arrays；

JDK的Arrays类存放在包java.util下面，因此，完整类名是java.util.Arrays。

因此在定义class的时候，我们需要在第一行声明这个class属于哪个包。

包作用域

位于一个包的不同类之间是可以相互访问包作用域的字段和方法的，不用public、protected、private修饰的字段和方法就是包作用域。

import 导入包

如果在一个class中我们需要用到别的包的class的话，可以有以下几种方法

• 完整类名调用，假设有一个Name类位于org.example中

package test;

public class Person{
    public void run(){
        org.example.Name name = new org.example.Name();
    }
}

• import导入类所属包

package test;
import org.example.Name;

public class Person{
    public void run(){
        Name name = new Name();
    }
}

• 直接导入包中所有类

package test;
import org.example.*;

public class Person{
    public void run(){
        Name name = new Name();
    }
}

• import static导入类的静态字段和静态方法

package test;
import static java.lang.System.*;

public class Person{
    public void run(){
        out.println("Hello world!");
    }
}

内部类

Java的内部类可分为Inner Class、Anonymous Class和Static Nested Class三种

inner内部类

一个类定义在另一个类的内部，这种类就是inner内部类

inner内部类和普通类最大的区别在于，内部类的实例必须依附于外层类的实例

例如

public class Main{
    public static void main(String[] args){
        Outer outer = new Outer();//实例化外层类
        Outer.Inner inner = outer.new Inner()//实例化内部类
    }
}

Anonymous 匿名类

匿名类 是 Java 中的一种 没有名字的内部类。

具体语法

new 父类/接口(参数...) {
    // 方法重写 / 新的实现
};

static静态内部类

最后一种和Inner Class类似，但是使用static修饰，称为静态内部类

内存中对象存在的形式

因为类和数组一样都是引用类型，所以他们都是指向栈中的一个地址，而当我们实例化一个对象的上会，JVM会在堆中为对象分配一块连续的内存空间。但是需要注意的是，如果实例属性是基本数据类型，则会直接存放在堆中，如果不是基本数据类型，则会在堆中存放常量池中对应的地址，在常量池中存放数据，例如字符串

Java核心类和方法

String操作字符串

equals()方法

用于比较两个字符串的内容是否相同

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

返回值是布尔类型

String s1 = "hello";
String s2 = "hello";
System.out.println(s1.equals(s2));
//true

要忽略大小写比较，使用equalsIgnoreCase()方法。

contains()方法

用于搜索某字符串中是否包含子串

    public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }

返回值是布尔类型

System.out.println("Hello".contains("H"));
//true

需要注意该方法的参数是CharSequence而不是String

其他搜索子串的函数

• indexOf()——检查某个字串在字符串中首次出现的位置
• lastIndexOf()——检查某个字串在字符串中最后出现的位置
• startsWith()——检查字符串是否是以某个字串开始的
• endsWith()——检查字符串是否是以某个字串结尾的

substring()方法

用于从字符串中提取需要的字符串

    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

第一个参数是开始的字符索引号，第二个参数是结尾的字符索引号

"Hello".substring(2); // "llo"
"Hello".substring(2, 4); //"ll"

trim()方法

用于移除字符串结尾的空白字符，空白字符包括空格，\t，\r，\n等

    public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value;    /* avoid getfield opcode */

        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

需要注意的是，这里的话会返回一个新的字符串，而不是改变原来的字符串，所以我们需要将这个函数的返回值赋值给一个新的String

另一个strip()方法也可以移除字符串首尾空白字符。它和trim()不同的是，类似中文的空格字符\u3000也会被移除

replace()方法

用于在字符串中替换特定的字串

    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

第一个参数是需要替换的字符或字符串，第二个是替换后的字符或字符串

split()方法

用于根据某个字符去分割选定的字符串

    public String[] split(String regex, int limit) {
        /* fastpath if the regex is a
         (1)one-char String and this character is not one of the
            RegEx's meta characters ".$|()[{^?*+\\", or
         (2)two-char String and the first char is the backslash and
            the second is not the ascii digit or ascii letter.
         */
        char ch = 0;
        if (((regex.value.length == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
             (regex.length() == 2 &&
              regex.charAt(0) == '\\' &&
              (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
              ((ch-'a')|('z'-ch)) < 0 &&
              ((ch-'A')|('Z'-ch)) < 0)) &&
            (ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE))
        {
            int off = 0;
            int next = 0;
            boolean limited = limit > 0;
            ArrayList<String> list = new ArrayList<>();
            while ((next = indexOf(ch, off)) != -1) {
                if (!limited || list.size() < limit - 1) {
                    list.add(substring(off, next));
                    off = next + 1;
                } else {    // last one
                    //assert (list.size() == limit - 1);
                    list.add(substring(off, value.length));
                    off = value.length;
                    break;
                }
            }
            // If no match was found, return this
            if (off == 0)
                return new String[]{this};

            // Add remaining segment
            if (!limited || list.size() < limit)
                list.add(substring(off, value.length));

            // Construct result
            int resultSize = list.size();
            if (limit == 0) {
                while (resultSize > 0 && list.get(resultSize - 1).isEmpty()) {
                    resultSize--;
                }
            }
            String[] result = new String[resultSize];
            return list.subList(0, resultSize).toArray(result);
        }
        return Pattern.compile(regex).split(this, limit);
    }

第一个参数可以是一个正则表达式也可以是一个字符，第二个参数是切割结果的个数限制，返回值是一个String字符串数组

"a,b,c".split(",")   // 按逗号切分 → ["a", "b", "c"]
"a.b.c".split(".")   // ❌ 错误，因为 "." 在正则里表示“任意字符”
"a.b.c".split("\\.") // ✅ 正确，要转义，表示字面上的点 → ["a", "b", "c"]
    
"a,b,c,d".split(",", 2) 
// 结果: ["a", "b,c,d"]

join()方法

用于用指定的字符去拼接字符串数组

    public static String join(CharSequence delimiter, CharSequence... elements) {
        Objects.requireNonNull(delimiter);
        Objects.requireNonNull(elements);
        // Number of elements not likely worth Arrays.stream overhead.
        StringJoiner joiner = new StringJoiner(delimiter);
        for (CharSequence cs: elements) {
            joiner.add(cs);
        }
        return joiner.toString();
    }

第一个参数是用于拼接字符串数组的分隔符，第二个是需要拼接的多个元素

可以看到最后会用toString将数组转化成字符串并返回

方法还有很多，不过可以总结出一个结论就是我们可以根据想要了解的方法的定义去分析这个方法的作用是什么，根据返回值去确定我们需要用什么类型的变量去接收他

异常处理

在我们编写和运行程序的时候往往都有可能会出现各种各样的错误，而一个健壮的java程序需要能处理各种各样的错误，异常处理并不是能让出错消失，而是以一种更合适和方便的方式去处理我们在运行时出现的异常

Java规定：

• 必须捕获的异常，包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
• 不需要捕获的异常，包括Error及其子类，RuntimeException及其子类。

捕获异常

通常使用try...catch语句，把可以产生异常的代码放入try语句中，然后用catch去捕获对应的Exception及其子类：

我们举个例子

package org.example;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        byte[] bs = toGBK("中文");
        System.out.println(Arrays.toString(bs));
    }

    static byte[] toGBK(String s) {
        try {
            // 用指定编码转换String为byte[]:
            return s.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            // 如果系统不支持GBK编码，会捕获到UnsupportedEncodingException:
            System.out.println(e); // 打印异常信息
            return s.getBytes(); // 尝试使用默认编码
        }
    }
}

如果我们不进行异常处理的话

就会出现报错信息导致编译失败

捕获异常的语句可以用多个catch

try{
    a();
    b();
    c();
}catch(IOException e){
    
}catch(NumberFormatException e){
    
}

JavaEE

参考文章：https://liaoxuefeng.com/books/java/web/basic/index.html

Web基础

Web开发通常是指开发服务器端的Web应用程序。

今天我们访问网站，使用App时，都是基于Web这种Browser/Server模式，简称B/S架构，用户只需要一个浏览器（Browser）作为客户端，通过网络访问服务器（Server）上的应用程序。应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web页面，并把Web页面展示给用户即可。

B/S架构的基本原理

1. 用户在浏览器输入网址或点击网站链接跳转
2. 浏览器通过HTTP/HTTPS协议向服务器发送请求
3. 服务器接收请求后处理业务逻辑，生成结果并返回HTML/JSON/文件流等格式的数据给浏览器
4. 浏览器渲染解析后呈现页面给用户

这个的话其实不陌生了，我们尝试用java去实现一个HTTP Server吧，一个HTTP Server本质上是一个TCP服务器

编写HTTP Server

我们先写一个服务器的启动类Server

public class Server {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个 ServerSocket，绑定到 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("----------server is listening on port 8080----------");

        // 2. 循环等待客户端连接
        while (true) {
            // accept() 会阻塞，直到有客户端连接上来
            Socket socket = serverSocket.accept();
            System.out.println("----------client connected----------");

            // 3. 为每个连接创建一个线程来单独处理
            Thread t = new Handler(socket);
            t.start();
        }
    }
}