Java笔记

酷༒猫

已于 2025-05-14 20:31:31 修改

阅读量650

点赞数 18

分类专栏： Java学习文章标签： java 开发语言

于 2025-03-29 21:09:56 首次发布

本文链接：https://blog.csdn.net/qq_66759927/article/details/146707975

版权

Java学习专栏收录该内容

1 篇文章

订阅专栏

一、数据类型

（一）、基本数据类型

1.整型（4种）

（1）byte

大小：1字节（8位）

范围：-128到127

默认值：0

示例：

byte a = 100;

（2）short

大小：2字节（16位）

范围：-32,768到32,767

默认值：0

示例：

short b = 20000;

（3）int

大小：4字节（32位）

范围：-2³¹ 到 2³¹-1（-2147283648到2147283647）

默认值：0

示例：

int c = 1000000;

（4）long

大小：8字节（64位）

范围：-2⁶³ 到 2⁶³-1

默认值：0L

注意：字面量需加L后缀，如：

long d = 10000000000L;

2、浮点型（2种）

（1）float

大小：4字节（32位）

精度：约6-7位有效数字

默认值：0.0f

注意：字面量需加F后缀，如：

float e = 3.14F;

（2）double

大小：8字节（64位）

精度：约15位有效数字

默认值：0.0d（可省略后缀）

示例：

double f = 3.1415926535;

3、字符型（1种）

char

大小：2字节（16位，Unicode编码）

范围：\u0000（0）到\uffff（65,535）

默认值：\u0000

示例：

char g = 'A';

或

char h = '\u0041';

4、布尔型（1种）

boolean

大小：无明确规范（JVM实现相关）

取值：true或false

默认值：false

示例：

boolean flag = true;

（二）、引用数据类型

Java中所有非基本类型的类型均为引用类型，主要分为以下类别：

1、类（Class）

自定义类：用户定义的类，如Person、Car。

Person p = new Person();

包装类：基本类型的对象形式，如Integer、Double。支持自动装箱（Autoboxing）和拆箱（Unboxing）。

Integer num = 10;  // 自动装箱：int → Integer
int n = num;       // 自动拆箱：Integer → int

2、接口类（Interface）

接口类型的引用可以指向其他实现类的对象。

List<String> list = new ArrayList<>();  // 接口引用指向实现类对象

3、数组（Array）

数组是对象，即使元素是基本类型，数组本身也是引用类型。

int[] arr = new int[5];  // 数组是引用类型

4、字符串（String）

String是Java预定义不可变类，属于引用类型。

String s1 = "abc";            // 字面量存储在字符串常量池
String s2 = new String("abc"); // 显式创建新对象

5、枚举（Enum）

枚举类型本质是类，每个枚举常量是枚举类的实例。

enum Color { RED, GREEN, BLUE }
Color color = Color.RED;

6、注解（Annotation）

注解本质是接口，由JVM动态生成代理类。

@Override  // 注解属于引用类型
public void method() {}

二、运算符

在Java中，运算符用于对变量或值进行各种操作。以下是常见的运算符分类及其详细说明：

（一）、算术运算符

用于数学计算，操作数为数值类型（基本数据类型）。

运算符	描述	示例	注意事项
+	加法	int a = 5 + 3;	也可用于字符串连接（见下文）
-	减法	double b = 10.5 - 2;
*	乘法	float c = 3.14f * 2;
/	除法	int d = 10 / 3;	整数除法结果为整数（如3）
%	取模	int e = 10 % 3;	结果的符号与被除数一致
++	自增	a++或++a	前缀先增后用，后缀先用后增
--	自减	b--或--b	同上

示例：

int x = 5;
int y = x++; // y=5, x=6
int z = ++x; // x=7, z=7

（二）、关系运算符

比较两个值的大小或相等性，返回 boolean 值（true/false）。

运算符	描述	示例
==	等于	5 == 3 → false
!=	不等于	5 != 3 → true
>	大于	10 > 5 → true
<	小于	10 < 5 → false
>=	大于等于	10 >= 10 → true
<=	小于等于	10 <= 5 → false

注意：比较引用类型时，== 比较的是内存地址，非内容（需用 equals() 方法）。

（三）、逻辑运算符

操作数为布尔值（boolean），用于组合条件。

运算符	描述	示例	特性
&&	逻辑与	(a > 5) && (b < 10)	短路运算（当两边都为true时，才返回true）
\|\|	逻辑或	(a < 0) && (b > 20)	短路运算（当一边为true时，就返回true）
!=	逻辑非	!(a == b)	取反

示例：

if(a > 10 && a < 20){
}

（四）、位运算符

直接操作二进制位（仅用于整数类型：byte、short、int、long、char）。

运算符	描述	示例	说明
&	按位与	0b1010 & 0b1100 = 0b1000	两位均为1时结果为1
\|	按位或	0b1010 \| 0b1100 = 0b1110	任意一位为1时结果为1
^	按位异或	0b1010 ^ 0b1100 = 0b0110	两位不同时结果为1
~	按位取反	~ 0b1010 = ob0101	单目运算符，取反所有位
<<	左移	5 << 2 → 20	低位补0，等价于乘2的n次方
>>	右移	-10 >> 2 → -3	高位补符号位

（五）、条件运算符（三元运算符）

根据条件选择两个值之一，语法：条件？值1 ：值2。

示例：

int max = (a > b) ? a : b;  //返回a和b中较大的值

（六）运算符优先级

优先级从高到低（部分常见）：

优先级	运算符
最高	()、[]、.（方法调用或属性访问）
	++、--（后缀/前缀）、!、~
	*、/、%
	+、-
	<<、>>
	>、<、>=、<=
	==、!=
	&、^、\|
	&&、\|\|
	? :（三元运算符）
最低	=、复合赋值运算符（如+=）
建议：在复杂表达式中使用()明确优先级，增强可读性。

三、常用输出

（一）、print()

直接输出，不换行，示例：

public class Example{
    public static void main(String[] args){
        int a = 5 + 2;
        String b = "Hello World!";
        System.out.print(a);
        System.out.print(b);
    }
}

7Hello World!

（二）、println()

每次输出后自动换行，示例：

public class Example{
    public static void main(String[] args){
        int a = 5 + 2;
        String b = "Hello World!";
        System.out.println(a);
        System.out.println(b);
    }
}

7
Hello World!

（三）、printf()

C风格的输出，实现格式化输出功能，示例：

public class Example{
    public static void main(String[] args){
        int a = 5 + 2;
        char b = 'A';
        System.out.printf("%d\n%c",a,b);
        
    }
}

7
A

四、分支结构

（一）、if结构

1、基本语法

if(表达式){
   语句块
}

2、示例

public class Example{
    public static void main(String[] args){
        int a = 5；
        int b = 6;
        if(a < b){
            System.out.println("Hello World!");
        }
    }
}

Hello World!

语法上，语句块仅有一句代码时，可以省略{}，但是一般不建议这么做。

（二）、if-else结构

1、基本语法

if(表达式){
    语句块A
} else{
    语句块B
}

描述：表达式为true时，执行语句块A；表达式为false时，执行语句块B。

2、示例

public class Example{
    public static void main(String[] args){
        int a = 5；
        int b = 6;
        if(a > b){
            System.out.println("Hello World!");
        } else{
            System.out.println("Java No.1!");
        }
    }
}

Java No.1!

（三）、if-else if-else结构

1、基本语法

if(表达式){
    语句块1
} else if(表达式){
    语句块2
} else if(表达式){
    语句块3
} 
……
else if(表达式){
    语句块n
} else{
    语句块n+1
}

注意：else if可以有多个，也可以没有；else可以有（只能有一个），可以没有。

2、示例

public class Example{
    public static void main(String[] args){
        int a = 5；
        int b = 6;
        int c = 7;
        if(a > b){
            System.out.println("Hello World!");
        } else if(a < c){
            System.out.println("Java No.1!");
        } else{
            System.out.println("Love Java!");
        }
    }
}

Java No.1!

（四）、switch结构

1、基本语法

switch(表达式){
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    ……
    case 值N:
        语句块N;
        break;
    default:
        语句块;
        break;
}

注意：

表达式的值必须是以下几种类型之一：char，byte，short，int，enum，String（Jdk7之后）。
case子句中的值必须是常量值，不能是一个范围。
所有case子句中的值不能重复，否则编译出错。
default子句是可选的，如果没有default，程序依旧可以运行。
break语句用于执行完一个case分支后跳出swicth语句块；如果没有，引起case贯穿，使程序接着执行下一个case语句，直至遇到break或者语句结束。

五、循环结构

（一）、认识循环

1、循环是什么

循环是指同样的事情反复做多次，在程序编写中，就是一种命令要反复使用，学会运用循环结构可节省大量内存空间，且能减少不必要的代码重复量。

2、循环三要素

定义循环变量并赋初值
循环条件
循环变量的更新

（二）、while循环

1、基本语法

while(条件){//当满足条件时，执行大括号里的代码块
    代码块
}

2、示例

public class Example {
    public static void main(String[] args){
        int a = 0;
        while(a < 9){
            System.out.print(a+" ");
            a++;
        }
    }
}

0 1 2 3 4 5 6 7 8

3、总结

while循环的特征就是先判断，后执行，如果在一开始条件就不满足，那么可能while循环一次也不执行。

（三）、do-while循环

1、基本语法

do{
    代码块
}while(循环条件);

2、示例

public class Example {
    public static void main(String[] args){
        int a = 0;
        do{
            System.out.print(a+" ");
            a++;
        }while(a < 9);
    }
}

0 1 2 3 4 5 6 7 8

3、总结

do-while循环的特征是先执行，后判断，do-while循环至少会执行一次。

（四）、for循环

1、基本语法

for(定义循环变量;循环条件;循环变量的更新){
   代码块
}
//for循环结构里的定义循环变量、循环条件、循环变量的更新都可以不填
//但;不可省略
//不填入任何表达式时，默认为true

2、示例

public class Example {
    public static void main(String[] args){
        for(int a = 0;a < 9;a++){
            System.out.println(a);
        }
    }
}

3、总结

for循环的特征是先判断，后执行；如果一开始条件就不满足，那么for循环可能一次也不执行。循环次数稳定的情况下，通常使用for循环；循环次数不稳定的情况下通常使用while循环和do-while循环。

（五）、循环嵌套

在循环的使用中，可以内套循环结构，实现多重循环。

示例

public class Example {
    public static void main(String[] args){
        for (int i = 0; i < 9; i++) {//外层循环
            for(int j = 1;j <= i;j++){//内层循环
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();//每行末尾换行
        }
    }
}

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

六、数组

在Java中，数组（Array）是一种用于存储同类型数据的引用数据类型，所有元素在内存中连续存储。

（一）、数组的特点

1、固定长度

数组一旦创建，长度不可变。

2、类型一致

所有元素必须是同一数据类型（基本类型或引用类型）。

3、索引访问

通过下标（从0开始）访问元素。

4、内存分配

数组变量是引用类型，存储在栈内存中，指向堆内存中的数组对象。
数组对象存储在堆内存中，元素按顺序存储。

（二）、数组的声明与初始化

1、声明数组

//第一种方式
数据类型[] 数组名;  //推荐写法（更清晰）
int[] arr1;
//第二种方式
数据类型 数组名[];  //合法但不推荐
String arr2[];

2、初始化

动态初始化：指定长度，元素赋默认值。

int[] arr = new int[5];  //默认值为0
arr[0] = 90; //赋值
String[] names = new String[3] //默认值为null

静态初始化：直接指定元素值。

int[] arr = {1,2,3}; //简写形式
int[] arr = new int[] {1,2,3}; //完整形式

（三）、数组的访问与遍历

1、访问元素

通过索引访问，索引范围：0到数组长度-1。

int[] arr = {10,20,30};
System.out.println(arr[1]); //输出20

2、遍历数组

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

3、越界问题

访问超出索引会抛出

ArrayIndexOutOfBundsException:

int[] arr = new int[3];
System.out.println(arr[3]); //报错，所以最大为2

（四）、多维数组

Java支持多维数组（如二维数组），本质是“数组的数组”。

1、二维数组声明与初始化

动态初始化：

int[][] matrix = new int[3][4]; //3行4列的规则二维数组

静态初始化：

int[][] matrix = {
     {1,2,3},
     {4,5},
     {6}         //不规则二维数组（每行长度不同）
};

2、访问多维数组

System.out.println(matrix[0][1]);  //输出2
System.out.println(matrix[1][1]);  //输出5

3、遍历多维数组

嵌套循环：

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

（五）、数组的常见操作

1、数组的复制

System.arraycopy():

int[] src = {1,2,3};
jint[] dest = new int[3];
System.arraycopy(src,0,src.length); //复制整个数组

Array.copyOf():

int[] newArr = Arrays.copyOf(src,src.length);  //返回新数组

2、数组排序

使用Arrays.sort():

int[] arr = {5,3,9,1};
Arrays.sort(arr);  //排序后arr变为[1,3,5,9]

3、数组查找

线性查找：数个遍历。
二分查找（需先排序）Arrays.binarySearch(数组,要查找的值)：

int index = Array.binarySearch(arr,5);  //返回元素索引

（六）、注意事项

1、默认值规则

基本类型数组：数值类型为0，boolean为false。
引用类数组：默认值为null（如String[] 默认元素为null）。

2、数组长度

通过数组名。length获取长度（不是方法，是属性）。
无法直接修改数组长度，需创建新数组并复制数据。

七、方法

在Java中，方法类似于C语言中的函数，用于执行特定任务。通过方法可以实现代码的模块化和复用。

（一）、基本语法

[访问修饰符] [static] 返回类型 方法名(参数列表){
    //方法体（代码逻辑）
    [return 返回值;]  //若返回类型为void则无需写return
}

示例1（无返回类型，无参数列表）：

public static void example_1(){
    int a = 3;
    int b = 2;
    Sysstem.out.println(a+b);
}

示例2（无返回类型，有参数列表）：

public static void example_2(int a,int b){
    System.out.println(a+b);
}

示例3（有返回类型，有参数列表）：

public static int example_3(int a,int b){
    return a + b;
}

（二）、方法的调用

在Java中，同一类中的方法可直接通过方法名调用。

示例：

public class Test{
    public static void main(String[] args){
       int a = 3;
       int b = 2;
       int c = method_1(a,b);
       System.out.println(c);
    }
    public static int method_1(int a,int b){
       return a + b;
    }
}

运行结果：

（三）、方法的重载(Overloading)与重构(Refactoring)

1、重载(Overloading)

定义：

在同一个类中，允许多个同名方法，但这些方法的参数列表必须不同（参数类型、参数数量或参数顺序不同）。重载是编译时多态性的体现。

规则：

方法名必须相同。
参数列表必须不同（类、数量、顺序）。
返回类型可以不同，但仅返回类型不同不足以构成重载。
访问修饰符可以不同（如public和private）。

作用：

提高代码复用性，统一功能相似的方法命名。
支持不同类型或数量的参数输入。

示例：

public class Calculator {
    
    // 两个int参数
    public int add(int a,int b){
        return a + b;
    }
    
    // 三个int参数
    public int add(int a,int b,int c){
        return a + b + c;
    }
    
    // 两个double参数
    public double add(double a,double b){
        return a +b;
    }
}

2、方法重构（Refactoring）

定义：

重构是指在不改变代码外部功能的前提下，优化代码结构，使其更清晰、可维护性更高。重构不是Java语法特性，而是一种编程实践。

常用场景：

拆分冗长方法为多个小方法。
重命名方法或变量一提高可读性。
消除重复代码（如提取公共逻辑）。
简化复杂条件判断或循环。

作用：

提高代码可读性和可维护性。
减少代码冗余，降低复杂度。
便于团队协作和后续扩展。

示例：

// 重构前
public void processData(String input) {
    // 冗长复杂的逻辑
    String[] parts = input.split(",");
    int sum = 0;
    for (String part : parts) {
        int num = Integer.parseInt(part);
        sum += num;
    }
    System.out.println("总和: " + sum);
}

// 重构后
public void processData(String input) {
    int sum = calculateSum(input);
    printResult(sum);
}

// 拆分出的方法：计算总和
private int calculateSum(String input) {
    String[] parts = input.split(",");
    int sum = 0;
    for (String part : parts) {
        sum += parseNumber(part);
    }
    return sum;
}

// 拆分出的方法：解析数字
private int parseNumber(String str) {
    return Integer.parseInt(str);
}

// 拆分出的方法：打印结果
private void printResult(int sum) {
    System.out.println("总和: " + sum);
}