java从0到1的学习

基础知识

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

• Java语言是面向对象的语言(oop)
• Java语言是健壮的，Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。
• Java语言是跨平台型的语言
• Java语言是强类型的语言
• Java语言是解释型语言
• 解释型语言:javascript,PHP,java 编译性语言:C/C++

什么是解释性语言？就是编译后的代码不能直接被机器执行的，需要解释器去执行

一个 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窗口进行操作

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

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

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

常量是特殊的变量！

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

java标识符命名规则

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

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

Java修饰符

和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;

java的注释

单行注释:以//开始

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

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

关于文档注释的DOS命令

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

java的转义字符

常用的转义字符

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

java的继承

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

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

java的数据类型

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

基本数据类型:

1. 整数类型：
   • byte：1 字节，范围从 -128 到 127。
   • short：2 字节，范围从 -32,768 到 32,767。
   • int：4 字节，范围从 -2,147,483,648 到 2,147,483,647。
   • long：8 字节，范围为 -2^63 到 2^63-1。定义变量的时候需要在初始值后加上一个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，通常用于条件判断。

引用数据类型:

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

1. 类（Class）：
   • Java 中的类可以定义用户自定义数据类型。通过类的实例化可以创建对象。
2. 接口（Interface）：
   • 接口是抽象的一种类型，可以定义方法的签名，通常用于实现多态。
3. 数组（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运算符

• 算术运算符

操作符	描述	例子
+	相加	A + B 等于 30
-	相减	A – B 等于 -10
*	相乘	A * B等于200
/	相除	B / A等于2
％	相除后取模	B%A等于0
++	自增	B++ 或 ++B 等于 21
–	自减	B– 或 –B 等于 19
+	字符串拼接	“He”+”llo”=”Hello”

• 关系运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（1 == 0）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(1 != 0) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（0> 1）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（0 < 1）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（1> = 0）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（0 <= 1）为真。

• 位运算符

＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

• 逻辑运算符

操作符	描述	例子
&	称为逻辑与运算符。无论真假都会执行右边运算	0<1&x=6结果是x=6
|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（1 | 0）为真。
!	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	!0为真。
&&	AND(短路)当且仅当两个操作数都为真，条件才为真。	一真为假
||	OR(短路)	一真为真
^	异或	(1^1)为假

&和&&的区别:

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

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

• 赋值运算符

=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

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

其他运算符:三目运算符

格式

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

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

java键盘输入语句

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

1.导入该类所在的包 java.util.*或java.util.Scanner
2.创建该类对象
3.调用里面的功能

使用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接口

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

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

接口的几个特点

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

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

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

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

• 定义接口

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

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岁，毛色为花色，我们如何获得这个猫的实例呢？

访问实例变量和方法

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

/* 实例化对象 */
类名 对象名 = 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
• 简单来说类就是对象的模板，而对象则是类的一个实际个体

内存中对象存在的形式

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

SpringBoot开发

SpringBoot 是基于 Spring Framework 的一个快速开发框架，旨在简化 Java Web 应用程序 的初始搭建和开发过程。