Java SE 入门到精通—基础语法【Java】

敲重点！本篇讲述了比较重要的基础，是必须要掌握的

1.程序入口

在Java中，main方法是程序的入口点，是JVM（Java虚拟机）执行Java应用程序的起始点。

main方法的方法签名必须遵循下面规范：

public static void main(String[] args){...}

public: main方法必须是public，以便JVM能够调用它。
static: main方法必须是静态的，因为在调用时不会创建类的实例，而是通过类名直接调用。
void: main方法不返回任何值，其返回类型必须是void。
String[] args: main方法的参数是一个字符串数组，用于接收命令行输入的参数。

当Java应用程序运行时，JVM会先加载应用程序的主类（包含main方法的类）再执行main方法。

2.输入输出

3.标识符与变量

标识符

所谓标识符就是变量、方法，类，接口等对象的名字，标识符的命名规则必须以下换线（_），$或者英文字母开头，并且不能使用关键字和保留字。

一般变量命名遵守小驼峰命名法或大驼峰命名法。

小驼峰命名法命名变量和方法名时，例如$userName，age，myFunction()，getResult()，除第一个单词其他单词首字母大写。

大驼峰命名法命名变量和方法名时，例如$UserName，Age，MyFunction()，GetResult()，所有单词首字符大写。

变量与常量

基本概念

变量与常量是指内存中的一个存储区域的引用，变量其值可以改变，而常量不可变。

基本数据类型变量名和值都存储在栈中，引用类型的变量名/对象引用（内存地址）存储在栈中，变量值(实例)存储在堆中

变量

变量初始化(赋值) 有两种方式，分布是静态初始化和动态初始化。

静态初始化

声明并分配内存空间。

int a=1;

动态初始化

先声明变量，后面使用再赋值。

int a;
a=1

常量

常量值一旦赋值不可被修改，已经被确定，变量前加关键字：final 。

final int  a=1;

还有final 方法：最终方法，final 类：最终类,不可被继承

4.关键字与保留字

关键字被Java语言赋予了特殊含义，用做专门用途的字符串，不可被使用，如class ，interface ，enum ，byte ，short，void等等

保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字，如goto 、const等

5.数据类型

数据类型分类

Java中的数据类型分为 基本数据类型 和 引用数据类型

来源于网络

基本数据类型

整型：short、int、long
浮点：float、double
字节：byte
字符：char
布尔：boolean

注意：

float 精度为8位有效数字，超出部分四舍五入，需带 f/F 后缀表示。
double 精度为17位有效数字。

引用数据类型

类
接口
数组
字符串

数组

一维数组

声明格式：数组类型[] 数组名={…} 或者数组类型数组名[]= {…}

数组初始化

动态初始化

通过new关键字分配内存空间，使用时再赋值，若未赋值则默认值为0

int[] list=new int(a) //申请a位空间数（整数）
int[] list=new int(5) //申请了5个元素空间
list[0]=1;
list[1]=8;
system.out.print(list[0],list[1])
>>>1,8

静态初始化

用花括号声明的同时并赋值

int[] list={1,2,3,4,5}
system.out.print(list[0])
>>>1

创建二维数组

声明格式：数组类型[][] 数组名={…} 或者数组类型数组名[][]= {…}

规则二维数组

子数组元素个数相同

静态初始化

int[][] list={{1},{2},{3},{4},{5}}

动态初始化

int[][] list=[5][1]

不规则二维数组

子数组元素个数不相同

静态初始化

int[][] list={{1},{2，3},{4,5，6}}

动态初始化

int[][] list=[3][]
list[0]=new int[1]   为第1个子数组分配1个空间
list[1]=new int[2]   为第2个子数组分配2个空间
list[2]=new int[3]   为第3个子数组分配3个空间

字符串

字符串底层为final修饰私有的字符数组，String类在long包中，无需导入

创建字符串对象

无参构造直接赋值即可,如String str=‘abc’;

带参构造

public String(char[] a/byte[] a)                
//byte  97,98,99---->a,b,c    字节对应相关字符
//char{'a','b','c'}---->abc    将字符输出为字符串（拼接）

字符数组和字节数组作为参数创建字符串对象，可以指定字节字符区间以及字符集，带参构造字符串通常用于io流数据类型转换

字符串相关操作和方法

字符串拼接

通常用StringBuilder，效率更高

str=str1+str2 产生一个新的字符串（和可变字符串相比会产生新对象，耗时，浪费空间）

字符串的比较

使用“==”做比较时

基本类型：比较值是否相等
引用类型：比较引用地址是否相同

构造方法创建的字符串对象不同对象不同地址
直接赋值相同内容的字符串对象共用一个地址（存储在常量池，已存在则直接引用）

        String s1="A";
        String s2="A";
        
        String s3=new String("A");
        String s4=new String("A");
        System.out.println(s1==s2);//true
        System.out.println(s3==s4);//false
        System.out.println(s1==s4);//false

引用类型比较值

引用类型判断值是否相等时，使用equals()方法

//方法1
str1.equals(str2)
//方法2
Objects.equals(str1, str2)

注意：

a.equals(b), 当a是null, 会抛出NullPointException空指针异常，因为null对象无equals方法。
使用Objects.equals(a, b)比较时不会抛出空指针异常

返回字符串元素个数

//xxx.length()
System.out.println("abc".length()); //3

修改字符串值

字符串对象不可变,若修改产生新对象，可以覆盖引用或者申请新地址，调用replace替换，字for循环替换等等

//覆盖原引用地址内容，使常量池中b值的引用指向a
String a="1"
String b="0"
a=b;
//a-->0 , b-->0

提取子串（切片）

//按索引截取指定子串
//若省略endIndex则从起始位置取到最后一个
//若startIndex=endIndex，则返回空串
str.substrng(startIndex[,endIndex]) （不计endIndex,开区间）

遍历字符串

 //取字符串索引i的元素
str="abc"
for (....){
   str.charAt(0)   
}

String a="123456";
for (int i=0;i<a.length();i++){
    System.out.println(a.charAt(i));
}

Stringbuilder

Stringbuilder是可变字符串，其值修改，地址不变（修改后还是原对象，不会在常量池中创建新对象），相同的还有StringBuffered(线程安全类)

创建可变字符串对象

构造方法创建

//无参
Stringbuilder str=new Stringbuilder()

//带参
Stringbuilder str=new Stringbuilder(string)  //String转StringBuilder(还支持其他类型参数)

可变字符串的相关操作和方法

拼接

append方法

//其返回原对象（可使用链式编程）
StringBuilder str=new StringBuilder()
str.append(str1)

逆置（序列反转）

reverse方法

StringBuilder str=new StringBuilder(str1)
str.reverse(str)
//abc-->cba

数据类型转换

自动类型转换

自动类型转换又为隐式转换，Java内部自动完成。

基本类型由低级到高级分别为(byte，short，char)->int->long->float->double

自动类型转换是从低到高的，所以当int+float的结果还是float

        int a=1;
        float b=1.5f;
        float result = a + b;

强制类型转换

强制类型转换是手动进行，将高级类型转换为低级类型，可能丢失精度

double d = 3.14;
int i = (int) d; // 强制转换为整数，丢失小数部分，i的值为3

long l = 1000000000L;
int i = (int) l; // 强制转换为整数，可能会导致数据溢出

char c = 'A';
int i = (int) c; // 强制类型转换为整数，i的值为65，即字符'A'对应的ASCII码值

字符串数组转换整型数组

通过遍历将每个元素转换成int型,long包中的Intege.parseInt(str)方法

字符数组转换整型数组

getNumericValue方法将字符转换为整型

    char[] chars = "abc".toCharArray();
    int[] ints = new int[chars.length];
    for (int i = 0; i < chars.length; i++) {
        int numericValue = Character.getNumericValue(chars[i]);
        ints[i] = numericValue;
    }

    System.out.println(Arrays.toString(ints)); //[10, 11, 12]

string和stringBuilder类型转换

//string->stringBuilder 直接在创建stringBuilder对象时传参
//tringBuilder->string 调用tooString方法
StringBuilder str=new StringBuilder(astr);
String fstr=str.toString(); //此时fstr为string类型

字符串转字符数组

//字符串->字符数组
"abc".toCharArray(); //["a","b","c"]

int转string

//int -> string
Integer.parseInt(str)
//string -> int
string.valueOF(i)

装箱与拆箱

装箱（Boxing）和拆箱（Unboxing）是指基本数据类型和对应的包装类（引用类型）之间的转换。

手动

通过传参进行转换

       int a=10;
//    手动装箱  基本类型---->包装类
    Integer b=new Integer(a);

//    手动拆箱  包装类---->基本数据类型
        int c= b.intValue();

自动

java内部会自动实现拆箱操作，将包装类型转换为基本类型。

//    自动装箱  基本类型---->包装类  直接将值赋给对应的包装/基本类
        int a=10;
        Integer b=a;
//    自动拆箱  包装类---->基本数据类型
        int c= b;

6.运算符

算术运算符

算术运算符用于执行基本的数学运算，包括加法、减法、乘法、除法、取余以及自增自减操作。

加法（+）：将两个数相加。
减法（-）：将右操作数从左操作数中减去。
乘法（*）：将两个数相乘。
除法（/）：将左操作数除以右操作数。
取余（%）：返回左操作数除以右操作数的余数。
自增（++）：将操作数的值增加1。
自减（–）：将操作数的值减少1。

除法运算符在处理不同数据类型时会产生不同的结果：

System.out.println(4 / 3);    // 输出：1
System.out.println(4 / 3.0);  // double 输出：1.3333333333333333
System.out.println(4 / 3f);   // float  输出：1.3333334

根据向上转型返回不同数据类型。

i++和++i

i++：先返回 i 的值，然后将 i 的值加1。
++i：先将 i 的值加1，然后返回 i 的值。

int i = 5;
System.out.println(i++);  // 输出：5，i先返回自增前的值
System.out.println(++i);  // 输出：7，i先自增后返回自增后的值

逻辑运算符

逻辑运算符用于执行逻辑操作，常用的有与、或、非。

与（&&）：当且仅当两个操作数都为true时，结果为true。
或（||）：当两个操作数中至少有一个为true时，结果为true。
非（！）：用于反转操作数的逻辑状态。

逻辑运算符可能会出现短路现象，即在逻辑运算过程中，如果根据左操作数已经可以确定整个表达式的结果，则右操作数将不再计算。例如：

boolean a = false;
boolean b = true;
boolean c = true;

if (a && b || c) {
    // 如果a为false，则不会计算b
}

关系运算符

关系运算符用于比较两个值之间的关系，返回一个布尔值。

小于（<）
大于（>）
小于等于（<=）
大于等于（>=）
等于（==）
不等于（!=）

移位运算符

移位运算符用于对二进制位进行移动操作。

左移（<<）：将操作数的所有位向左移动指定数量的位。
右移（>>）：将操作数的所有位向右移动指定数量的位，右移时，左边用符号位填充。
无符号右移（>>>）：将操作数的所有位向右移动指定数量的位，右移时，左边用0填充。

位运算符

位运算符用于对操作数的位进行操作。

与（&）：对两个操作数的每个位执行逻辑与操作。
或（|）：对两个操作数的每个位执行逻辑或操作。
异或（^）：对两个操作数的每个位执行逻辑异或操作（相同为0，不同为1）。
非（~）：对操作数的每个位执行逻辑非操作（0变为1，1变为0）。

三元运算符

三元运算符也称为条件运算符，用于根据表达式的结果选择执行不同的操作。

语法：表达式1 ? 表达式2 : 表达式3；

int value = (a == 0) ? 1 : (b + c);

如果表达式a等于0，则将1赋值给value，否则将b+c的结果赋值给value。

复合运算符

复合运算符是一种组合了赋值运算符和算术运算符的运算符，用于简化代码。

例如，+=、-=、*=、/=等等。

7.流程控制

分支结构

分支结构用于根据条件选择不同的执行路径。

单分支：if

if (条件) {
    // 如果条件为真，执行这里的代码块
}

双分支：if… else

if (条件) {
    // 如果条件为真，执行这里的代码块
} else {
    // 如果条件为假，执行这里的代码块
}

多分支 if…else if… else

if (条件1) {
    // 如果条件1为真，执行这里的代码块
} else if (条件2) {
    // 如果条件2为真，执行这里的代码块
} else if (条件3) {
    // 如果条件3为真，执行这里的代码块
} else {
    // 如果以上条件都不满足，执行这里的代码块
}

Switch语句

Switch语句用于根据表达式的值选择执行不同的分支。

switch (表达式/值) {
    case 值1/入口1:
        // 执行语句1
        break; // 终止当前分支的执行
    case 值2/入口2:
        // 执行语句2
        break;
    case 值3/入口3:
        // 执行语句3
        break;
    default:
        // 如果以上入口都不匹配，执行这里的语句
        break;
}

如果不使用break关键字，将会继续执行下一个分支。如果没有匹配的分支，将执行default分支（可选）。

循环结构

循环结构用于重复执行一段代码。

for循环

for (初始化表达式; 判断表达式; 增减表达式) {
    // 循环体，当判断表达式为true时执行
}

增强for循环（foreach）

for (循环变量 : 数组/集合) {
    // 对数组/集合中的每个元素执行相同的操作
}

while循环

while (判断表达式) {
    // 循环体，当判断表达式为true时执行
}

do…while循环

do {
    // 循环体，至少会执行一次
} while (判断表达式);

do...while循环先执行一次循环体，然后再判断条件是否满足。

8.代码块的分类

在Java中，代码块可以根据其位置和作用进行分类，包括局部代码块、构造代码块和静态代码块。

位置	作用
局部代码块	在方法当中使用，作用是控制变量的生命周期。局部代码块的变量，只能在代码块内部使用，在执行结束后会被Java回收//相当于Python中函数或类中方法
构造代码块	在类的成员位置使用。在每次执行构造方法前先执行构造代码块, 可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化.//相当于Python类——init——构造函数，初始化对象
静态代码块	在类的成员位置，代码块前添加static修饰符。一般用于给类初始化,被静态修饰的代码块仅执行一次.静态代码块是主动执行的代码块，在JVM加载类时就会执行，且最高优先权限执行 static{…}

局部代码块

局部代码块通常位于方法内部，用于控制变量的生命周期。在局部代码块中定义的变量只能在代码块内部使用，并且在代码块执行结束后会被Java回收。局部代码块的作用类似于Python中函数或类中的方法。

public void exampleMethod() {
    {
        // 这是一个局部代码块
        int x = 10;
        System.out.println("在局部代码块中：" + x);
    }
    // 这里无法访问局部代码块中定义的变量 x
}

构造代码块

构造代码块位于类的成员位置，每次执行构造方法之前都会先执行构造代码块。构造代码块可以将多个构造方法中相同的代码放到一起，对对象进行初始化。构造代码块类似于Python中的类__init__构造函数。

public class Example {
    {
        // 这是一个构造代码块
        System.out.println("执行构造代码块");
    }
    
    public Example() {
        // 构造方法
        System.out.println("执行构造方法");
    }
}

静态代码块

静态代码块也位于类的成员位置，但在代码块前需要添加static修饰符。静态代码块用于给类初始化，它仅在类加载时执行一次。静态代码块是被动执行的，在JVM加载类时就会执行，并且具有最高优先级。

public class Example {
    static {
        // 这是一个静态代码块
        System.out.println("执行静态代码块");
    }
    
    public static void main(String[] args) {
        System.out.println("执行main方法");
    }
}