语法

一、声明类

必须先声明类

public class 类名{
	
}

• 结构定义语句：声明类或方法

• 功能执行语句：实现功能，分号结尾

• 严格区分大小写

• 字符串不换行，换行用加号

/**
 *Title:HelloWorld类
 *@athor sex
 */

二、 关键字

1.关键字

2.标识符

3.命名规范

• 包名小写
• 类名和接口首字母大写
• 常量名大写和下划线
• 变量名和方法名驼峰
• 尽量有意义

三、数据类型

1.分类

• 基础数据类型
  • 数值
    • 浮点
    • 整型
  • 字符
  • 布尔
• 引用数据类型
  • 类(class)
  • 接口(interface)
  • 枚举(enum)
  • 数组(arr)
  • 注解(Annotation)

byte num = 100
int  num = 10000
long num = 2000000L;

float num = 123.4f;
double num = 123.4d;

char str = 'a';
char str = 97; //相当于'a'

boolean flag = true;
flag == true; //结果为true

2.整型

名称	空间	取值
byte	8位	-128~127
short	16位	2e15
int	32位	2e31
long	64位	2e63

3.浮点型

名称	空间	取值
float	32位	10e-45~10e38
double	64位	10e-324~10e308

4.默认值

数据类型	默认值
byte、short、int、long	0
float、double	0.0
char	'\u0000'
blooean	false
引用	null

5.类型转换

自动转换

byte -> short/char -> int -> long -> float -> double

byte a = 100;
int b = a;
double c = b;

强制转换

变量名 = (目标类型) 值

//int转byte
int a = 256;
byte b;
b = (byte) a; //结果为0

6.常量

整型常量

• 二进制（0b）
• 八进制（0）
• 十六进制（0x）

浮点常量

字符常量

只能用双引号（“ ”），不能用单引号

布尔常量

只有true和false两个值

null常量

四、运算符

1.算术运算符

2.赋值运算符

3.比较运算符

4.逻辑运算符

5.位运算符

运算符	运算
&	按位与
|	按位或
~	取反
^	按位异或
<<	左移
>>	右移
>>>	无符号右移

6.条件运算符

7.运算优先级

五、循环语句

1.if语句

2.if···else语句

3.switch语句

4.while循环

5.do···while循环

6.for循环

7.循环嵌套

// 九九乘法表
public class Multiplication_table {
    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+"="+(i*j) + "\t" );
            }
            System.out.println("\n");
        }
    }
}

8.break语句

9.continue语句

六、数组

1.定义

数据类型[] 数组名 = new 数据类型[数组长度]
数据类型[] 数组名 new 数据类型[]{数组元素}
数据类型[] 数组名 = {数组元素}

int[] arr = new int[10];
String[] str = new String[]{"张三",18,"男"}
Object obj = {"张三",18,"男"};

2.遍历数组

for循环遍历数组

public class Traverse{
    public static void main(String[] args){
		int[] arr = {1,2,3,4,5};
        for(int i= 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}
// 1 2 3 4 5

3.数组最值

通过中间值保存变量

public class Max{
    public static void main(String[] args){
        int[] arr = {4,1,5,6,2,8};
        int max = arr[0];
        for(int i= 0;i<arr.length;i++){
            if(max<arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为："+max);
    }
}

4.数组排序

冒泡排序

public class Bubble_sort{
    
}

插入排序

快速排序

选择排序

希尔排序

归并排序

堆排序

桶排序

计数排序

5.多维数组

七、面向对象

成员变量初始值

类型	初始值

访问控制符

类的封装

什么是封装

封装是面向对象编程的核心特性之一，它的核心思想是将对象的属性和行为（方法）包装在一个类中，并通过访问控制机制隐藏对象的内部实现细节，仅对外暴露必要的接口。

1. 访问控制
2. 隐藏对象内部细节
3. 暴露接口

为什么要封装

1. 数据保护
   防止外部直接修改对象的敏感数据，避免无效或不安全的操作（例如年龄不能为负数）。

2. 隐藏实现细节
   类的内部逻辑可以自由修改，而不会影响外部调用者（只要接口不变）。

3. 提高代码可维护性
   通过清晰的接口定义，代码更易理解、调试和扩展。

4. 增强安全性
   通过权限控制限制对关键数据的访问。

如何实现封装

1. 使用访问修饰符
   通过 private、protected、public 等关键字控制属性和方法的可见性。

   • private：仅本类可访问（最严格的封装）。

   • public：完全开放。

   • protected：本类、子类和同包可访问。

   • 默认（无修饰符）：同包内可访问。

2. 提供公共方法（Getter/Setter）
   通过公共方法间接访问或修改私有属性，并在方法中添加逻辑控制。

public class Student {  
    private String name;  
    private int age;  
  
    public String getName(){  
        return name;  
    }  
  
    public int getAge(){  
        return age;  
    }  
  
    public void setName(String name){  
        if(name == null || name.isEmpty()){  
            throw new IllegalArgumentException("姓名不能为空");  
        }  
        this.name = name;  
    }  
  
    public void setAge(int age){  
        if(age <0||age >150){  
            throw new IllegalArgumentException("年龄无效");  
        }  
        this.age = age;  
    }  
}

public class Main{  
    public static void main(String[] args){  
        Student student =  new Student();  
        student.setName("张三");  
        student.setAge(20);  
        System.out.println(student.getName() + "的年龄是：" + student.getAge());  
    }  
}

重载和递归

重载

同名方法，参数类型和数量不同

public class Caculate {  
    // 两个整数相加  
    public static int add(int x,int y){  
        return x+y;  
    }  
  
    // 三个整数相加  
    public static int add(int x,int y,int z){  
        return x+y+z;  
    }  
  
    // 两个小数相加  
    public static double add(double x,double y){  
        return x+y;  
    }  
  
    public static void main(String[] args) {  
        int sum1 = add(1,2);  
        int sum2 = add(1,2,3);  
        double sum3 = add(0.2,0.3);  
        System.out.println("sum1 = "+sum1);  
        System.out.println("sum2 = "+sum2);  
        System.out.println("sum3 = "+sum3);  
    }  
}

递归

方法直接/间接调用自己

构造方法