java快速学习速查（1）

在经历了艰苦卓绝的思想斗争之后，我决定走Java的全栈开发，这是个很难走的路线，但是这是最合适现在的环境的（自认为）

我将会在一周内快速解决Java的本体基础学习，会在乐扣上用题目辅助

注意：这是全栈学习的开端，而且必须要快！！
我将以更系统化和结构化的方式为你整理Java基础语法内容，并补充更多实用细节和示例。

这篇文章涉及Java基础语法，注释，对象和类，基本数据类型

Java基础语法全面解析

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

  • 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
  • 类：类是一个模板，它描述一类对象的行为和状态。
  • 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
  • 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

一、程序结构核心概念

这是构成Java语法结构的最基本框架

  1. 类与对象

    • 类：对象的蓝图/模板
      1
      2
      3
      public class Dog {  // 类名首字母大写
          // 类内容
      }
    • 对象：类的具体实例
      1
      Dog myDog = new Dog();  // 创建Dog类的对象

  2. main方法详解

    1
    2
    3
    4
    5
    6
    7
    public static void main(String[] args) {
        // 程序入口必须严格按此格式
        // public: 访问修饰符
        // static: 静态方法
        // void: 无返回值
        // String[] args: 命令行参数
    }

二、命名规范与语法规则

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

  • 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
    -** 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
    -     方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
    -     源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
    -     主方法入口：**所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
    元素类型 规范示例 错误示例
    类名 MyFirstClass myFirstClass
    方法名 calculateTotal() CalculateTotal()
    变量名 studentCount StudentCount
    常量名 MAX_VALUE max_value

重要规则：

  • 源文件名必须与public类名完全匹配（包括大小写）
  • 一个.java文件只能有一个public类

三、数据类型深度解析

  1. 基本数据类型（8种）

    类型 大小 范围/示例
    byte 8位 -128 ~ 127
    short 16位 -32768 ~ 32767
    int 32位 -2^31 ~ 2^31-1
    long 64位 需加L后缀：100L
    float 32位 需加f后缀：3.14f
    double 64位 默认小数类型
    char 16位 'A' 或 Unicode
    boolean - true/false

  2. 引用数据类型

    • 类对象：String str = "Hello"
    • 数组：int[] arr = new int[5]
    • 接口：List<String> list

四、变量类型对比

变量类型 声明位置 生命周期 初始化要求
局部变量 方法/块内 方法/块执行期间 必须显式初始化
实例变量 类内方法外 对象存在期间 自动初始化(0/false/null)
类变量 类内+static 程序运行期间 自动初始化 
1
2
3
4
5
6
7
8
9
public class VariableDemo {
    static int classVar;  // 类变量
    
    String instanceVar;   // 实例变量
    
    void method() {
        int localVar = 10; // 局部变量必须初始化
    }
}

五、数组使用详解

  1. 声明与初始化

    1
    2
    3
    4
    5
    6
    // 方式1
    int[] arr1 = new int[3];  // [0,0,0]
    // 方式2
    int[] arr2 = {1, 2, 3};
    // 方式3
    int[] arr3 = new int[]{1, 2, 3};

  2. 多维数组

    1
    2
    int[][] matrix = new int[3][3];
    matrix[0][0] = 1;

六、枚举(Enum)高级用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Pizza {
    enum Size {
        SMALL("S"), MEDIUM("M"), LARGE("L");
        
        private String abbreviation;
        
        Size(String abbreviation) {
            this.abbreviation = abbreviation;
        }
        
        public String getAbbreviation() {
            return abbreviation;
        }
    }
    
    public static void main(String[] args) {
        Size size = Size.MEDIUM;
        System.out.println(size.getAbbreviation()); // 输出 M
    }
}

七、核心关键字分类说明

如果你要关键字全集点这里

  1. 访问控制

    • private：仅本类可见
    • protected：本包+子类可见
    • public：所有类可见
    • 默认(不写)：本包可见

  2. 类与对象

    • new：创建对象 Dog d = new Dog()
    • this：指代当前对象
    • super：指代父类对象

  3. 流程控制

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    // if-else
    if(condition) {
        // ...
    } else if(condition2) {
        // ...
    } else {
        // ...
    }

    // switch (Java 12+支持表达式形式)
    int day = 3;
    String dayType = switch(day) {
        case 1, 2, 3, 4, 5 -> "Weekday";
        case 6, 7 -> "Weekend";
        default -> "Invalid";
    };

八、注释规范

  1. 单行注释

    1
    // 这是单行注释

  2. 多行注释

    1
    2
    3
    4
    /*
     * 这是多行注释
     * 可以跨越多行
     */

  3. 文档注释（生成API文档）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * 计算两个数的和
     * @param a 第一个加数
     * @param b 第二个加数
     * @return 两数之和
     */
    public int add(int a, int b) {
        return a + b;
    }

九、编译与执行流程

  1. 完整步骤

    1
    2
    3
    1. 编写HelloWorld.java
    2. 编译: javac HelloWorld.java → 生成HelloWorld.class
    3. 运行: java HelloWorld

  2. 常见问题解决

    • 编码问题：javac -encoding UTF-8 HelloWorld.java
    • 类路径问题：java -cp . HelloWorld

  3. JVM执行过程

    1
    源代码(.java) → 编译器 → 字节码(.class) → JVM → 机器码

十、面向对象核心概念

  1. 继承示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Animal {
        void eat() {
            System.out.println("Eating...");
        }
    }

    class Dog extends Animal {
        void bark() {
            System.out.println("Barking...");
        }
    }

  2. 接口示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    interface Drawable {
        void draw();  // 默认public abstract
    }

    class Circle implements Drawable {
        public void draw() {
            System.out.println("Drawing circle");
        }
    }

最佳实践建议

  1. 代码风格

    • 类名使用大驼峰：MyClass
    • 方法名使用小驼峰：myMethod()
    • 常量全大写：MAX_COUNT

  2. 调试技巧

    • 使用System.out.println()进行简单调试
    • 学会阅读编译错误信息
    • 使用IDE的调试功能（如IntelliJ IDEA）

Java注释全面指南

注释是编程中不可或缺的部分，好的注释能极大提升代码可读性和可维护性。下面我将详细讲解Java中的三种注释类型及其最佳实践。

你自己读得懂代码才行啊。

一、注释类型详解

1. 单行注释（Single-line）

语法：// 注释内容

特点：

  • 从//开始到行尾
  • 适用于简短解释或行尾说明
1
2
3
4
5
// 计算订单总金额
double total = price * quantity;  // price是单价，quantity是数量

// 下面这行代码被暂时禁用
// System.out.println("调试信息");

2. 多行注释（Multi-line）

语法：

1
2
3
4
/* 
 * 注释内容
 * 可以跨越多行
 */

特点：

  • 以/*开始，*/结束
  • 适合较长的解释说明或临时屏蔽代码块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
 * 这段代码实现了用户登录验证功能
 * 包含以下步骤：
 * 1. 检查用户名格式
 * 2. 验证密码强度
 * 3. 查询数据库匹配
 */
boolean loginSuccess = validateLogin(username, password);

/* 临时注释掉的代码块
if(debugMode) {
    logger.log("进入支付流程");
    processPayment();
}
*/

3. 文档注释（Javadoc）

这玩意在大型工程基本上才用得到，一般情况用不到
语法：

1
2
3
4
/**
 * 描述信息
 * @tag 标签内容
 */

特点：

  • 以/**开始，*/结束
  • 用于生成正式的API文档
  • 支持HTML标签和特殊标记
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 计算两个数的和
 * <p>该方法接受两个整数参数，返回它们的算术和</p>
 * 
 * @param a 第一个加数
 * @param b 第二个加数
 * @return 两个参数的和
 * @throws IllegalArgumentException 如果参数为负数
 */
public int add(int a, int b) {
    if(a < 0 || b < 0) {
        throw new IllegalArgumentException("参数不能为负数");
    }
    return a + b;
}

二、Javadoc常用标签

标签很重要，但不是现在说的

标签 用途 适用对象
@param 方法参数说明 方法
@return 返回值说明 方法
@throws/@exception 抛出异常说明 方法
@see 参考链接 类/方法/字段
@deprecated 标记已过时 类/方法/字段
@since 引入版本 类/方法/字段
@version 版本信息 类
@author 作者信息 类

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 表示二维点的类
 * @author John Doe
 * @version 1.2
 * @since 2020-03-15
 */
public class Point {
    /**
     * 计算到另一点的距离
     * @param other 另一个点对象
     * @return 两点间的距离
     * @see Math#sqrt(double)
     */
    public double distanceTo(Point other) {
        // 实现代码...
    }
}

三、注释最佳实践

  1. 该注释什么：

    • 复杂算法逻辑
    • 不直观的设计决策
    • 公共API的用法
    • 已知问题的临时解决方案
    • 特殊业务规则

  2. 不该注释什么：

    • 自我解释的简单代码
    • 重复方法名的信息
    • 过时的实现细节

  3. 良好注释示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    // 使用快速排序因为：
    // 1. 数据集通常部分有序
    // 2. 空间复杂度要求O(log n)
    // 3. 基准测试显示比其他算法快15%
    sortAlgorithm = new QuickSort();

    /**
     * 转换日期格式（线程安全版本）
     * @deprecated 请使用{@link DateFormatter#formatSafe(Date)}
     *             因为发现时区处理问题
     */
    @Deprecated
    public String formatDate(Date date) {
        // ...
    }

  4. 注释风格建议：

    • 保持注释与代码同步更新
    • 使用完整的句子和正确的语法
    • 避免幽默或不专业的语言
    • 重点说明”为什么”而不是”做什么”

四、生成API文档

使用JDK自带的javadoc工具：

1
javadoc -d docs -encoding UTF-8 -sourcepath src com.example.package

常用参数：

  • -d：输出目录
  • -encoding：指定源文件编码
  • -sourcepath：源代码路径
  • -author/-version：包含作者/版本信息

五、特殊注释技巧

  1. 调试标记：

    1
    2
    // TODO: 需要优化数据库查询
    // FIXME: 时区处理有问题

  2. 条件编译（通过final变量实现）：

    1
    2
    3
    4
    5
    final boolean DEBUG = false;

    if(DEBUG) {
        System.out.println("调试信息");
    }

  3. 注释中的代码示例：

    1
    2
    3
    4
    5
    6
    7
    /**
     * 使用示例：
     * <pre>{@code
     * List<String> list = new ArrayList<>();
     * list.add("item");
     * }</pre>
     */

    接下来是很重要的一个部分

Java对象和类深度解析

面向对象编程(OOP)是Java的核心思想，下面我将从实际开发角度，通过丰富的示例详细讲解Java中类和对象的各个方面。

一、类与对象全面解析

Java 作为一种面向对象的编程语言，支持以下基本概念：

1、类（Class）：

定义对象的蓝图，包括属性和方法。

示例：public class Car { … }

2、对象（Object）：

类的实例，具有状态和行为。

示例：Car myCar = new Car();

3、继承（Inheritance）：

一个类可以继承另一个类的属性和方法。

示例：public class Dog extends Animal { … }

4、封装（Encapsulation）：

将对象的状态（字段）私有化，通过公共方法访问。

示例：
private String name;
public String getName() { return name; }

5、多态（Polymorphism）：

对象可以表现为多种形态，主要通过方法重载和方法重写实现。

示例：
方法重载：public int add(int a, int b) { … } 和 public double add(double a, double b) { … }
方法重写：@Override public void makeSound() { System.out.println(“Meow”); }

6、抽象（Abstraction）：

使用抽象类和接口来定义必须实现的方法，不提供具体实现。
示例：

抽象类：public abstract class Shape { abstract void draw(); }
接口：public interface Animal { void eat(); }

7、接口（Interface）：

定义类必须实现的方法，支持多重继承。

示例：public interface Drivable { void drive(); }

8、方法（Method）：

定义类的行为，包含在类中的函数。

示例：public void displayInfo() { System.out.println(“Info”); }

9、方法重载（Method Overloading）：

同一个类中可以有多个同名的方法，但参数不同。

1
2
3
4
5
6
7
8
9
public class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

1. 类(Class)的本质

类是创建对象的模板，它定义了：

  • 属性（字段/成员变量）：描述对象的状态
  • 方法：定义对象的行为
  • 构造器：用于初始化对象

定义对象的蓝图，包括属性和方法。
示例：public class Car { … }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
 * 汽车类 - 演示类的基本结构
 * 包含字段、方法和构造器
 */
public class Car {
    // 字段/属性
    private String brand;  // 品牌
    private String color;  // 颜色
    private double price;  // 价格
    
    // 构造器
    public Car(String brand, String color, double price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }
    
    // 方法
    public void startEngine() {
        System.out.println(brand + "汽车引擎启动");
    }
    
    public void displayInfo() {
        System.out.printf("品牌：%s，颜色：%s，价格：%.2f万\n", 
                         brand, color, price);
    }
    
    // Getter和Setter方法
    public String getBrand() { return brand; }
    public void setColor(String color) { this.color = color; }
    // 其他getter/setter...
}

2. 对象(Object)的创建与使用

对象是类的具体实例，创建和使用过程：
**
类的实例，具有状态和行为。
示例：Car myCar = new Car();**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class CarTest {
    public static void main(String[] args) {
        // 创建Car类的实例（对象）
        Car myCar = new Car("比亚迪", "红色", 15.99);
        Car yourCar = new Car("特斯拉", "白色", 29.99);
        
        // 调用对象方法
        myCar.startEngine();  // 输出：比亚迪汽车引擎启动
        yourCar.displayInfo(); // 输出：品牌：特斯拉，颜色：白色，价格：29.99万
        
        // 修改对象状态
        myCar.setColor("蓝色");
        System.out.println("修改后颜色：" + myCar.getColor());
    }
}

###访问实例变量和方法
通过已创建的对象来访问成员变量和成员方法，如下所示：

1
2
3
4
5
6
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

使用 Object 类型声明变量只能在编译时访问 Object 类中的方法和属性，但在运行时，你可以通过强制类型转换将其转换为特定类型，以便访问特定类型的方法和属性。

3. 内存模型解析

这是类和对象的内存中的状态解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
栈内存(Stack)：
- 存储基本类型变量和对象引用
- myCar (引用地址0x100)
- yourCar (引用地址0x200)

堆内存(Heap)：
0x100: Car对象 {
    brand = "比亚迪"
    color = "红色" → 修改为"蓝色"
    price = 15.99
}
0x200: Car对象 {
    brand = "特斯拉"
    color = "白色"
    price = 29.99
}

二、构造方法深度探讨

1. 构造方法特点

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法

  • 与类同名
  • 无返回类型（连void都没有）
  • 可以重载（多个构造方法）
  • 默认提供无参构造（除非显式定义其他构造方法）

2. 构造方法示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Student {
    private String name;
    private int age;
    private String major;
    
    // 默认构造器
    public Student() {
        this("未知", 18, "未定"); // 调用其他构造器
    }
    
    // 带部分参数的构造器
    public Student(String name, int age) {
        this(name, age, "计算机科学"); // 默认专业
    }
    
    // 全参数构造器
    public Student(String name, int age, String major) {
        if(age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
        this.name = name;
        this.age = age;
        this.major = major;
    }
    
    // 拷贝构造器
    public Student(Student other) {
        this(other.name, other.age, other.major);
    }
}

3. 构造方法使用场景

1
2
3
4
Student s1 = new Student();  // 使用默认构造器
Student s2 = new Student("张三", 20);
Student s3 = new Student("李四", 22, "人工智能");
Student s4 = new Student(s3);  // 拷贝创建

三、封装与访问控制实践

1. 封装原则

  • 将字段设为private
  • 通过public方法访问
  • 在方法中添加业务逻辑

2. 完整封装示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class BankAccount {
    private String accountNumber;
    private String accountHolder;
    private double balance;
    private static final double MAX_DEPOSIT = 100000;
    
    public BankAccount(String accountNumber, String accountHolder) {
        this.accountNumber = accountNumber;
        this.accountHolder = accountHolder;
        this.balance = 0.0;
    }
    
    public void deposit(double amount) {
        if(amount <= 0) {
            throw new IllegalArgumentException("存款金额必须为正数");
        }
        if(amount > MAX_DEPOSIT) {
            throw new IllegalArgumentException("单笔存款不能超过" + MAX_DEPOSIT);
        }
        balance += amount;
        System.out.printf("成功存款%.2f，当前余额：%.2f\n", amount, balance);
    }
    
    public void withdraw(double amount) {
        if(amount <= 0) {
            throw new IllegalArgumentException("取款金额必须为正数");
        }
        if(amount > balance) {
            throw new IllegalArgumentException("余额不足");
        }
        balance -= amount;
        System.out.printf("成功取款%.2f，当前余额：%.2f\n", amount, balance);
    }
    
    // 只提供getter方法，不提供setter，防止随意修改
    public double getBalance() {
        return balance;
    }
    
    public String getAccountInfo() {
        return String.format("账号：%s，户主：%s", accountNumber, accountHolder);
    }
}

四、变量类型全解析

1. 三种变量对比

变量类型 声明位置 生命周期 初始化要求 访问方式
局部变量 方法/块内 方法/块执行期间 必须显式初始化 直接访问
实例变量 类内方法外 对象存在期间 自动初始化 通过对象访问
类变量 类内+static 程序运行期间 自动初始化 类名或对象访问

2. 变量使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class VariableDemo {
    // 实例变量
    private int instanceVar;
    
    // 类变量（静态变量）
    private static int classVar;
    
    public void method() {
        // 局部变量
        int localVar = 10;
        
        System.out.println("局部变量：" + localVar);
        System.out.println("实例变量：" + this.instanceVar);
        System.out.println("类变量：" + VariableDemo.classVar);
    }
    
    public static void main(String[] args) {
        VariableDemo demo = new VariableDemo();
        demo.method();
        
        // 不同对象共享类变量
        VariableDemo.classVar = 100;
        new VariableDemo().method();
    }
}

五、方法设计与重载

1. 方法组成要素

1
2
3
4
[访问修饰符] [static/final/abstract] 返回类型 方法名(参数列表) [throws 异常列表] {
    // 方法体
    [return 返回值;]
}

2. 方法重载最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Calculator {
    // 整数加法
    public int add(int a, int b) {
        System.out.println("调用int版本");
        return a + b;
    }
    
    // 小数加法
    public double add(double a, double b) {
        System.out.println("调用double版本");
        return a + b;
    }
    
    // 可变参数加法
    public int add(int... numbers) {
        System.out.println("调用可变参数版本");
        int sum = 0;
        for(int num : numbers) {
            sum += num;
        }
        return sum;
    }
    
    // 方法重载的调用
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1, 2));       // 调用int版本
        System.out.println(calc.add(1.5, 2.5));   // 调用double版本
        System.out.println(calc.add(1, 2, 3));    // 调用可变参数版本
    }
}

六、综合案例：员工管理系统

Employee.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import java.time.LocalDate;
import java.util.Objects;

/**
 * 员工类
 * 演示完整的类设计：封装、构造器、方法、重写等
 */
public class Employee {
    private final String id;          // 员工ID（不可变）
    private String name;              // 姓名
    private Department department;    // 部门（枚举）
    private double salary;            // 薪资
    private LocalDate hireDate;       // 入职日期
    
    // 构造器
    public Employee(String id, String name, Department department, 
                   double salary, LocalDate hireDate) {
        this.id = Objects.requireNonNull(id, "ID不能为空");
        this.name = Objects.requireNonNull(name, "姓名不能为空");
        this.department = Objects.requireNonNull(department);
        setSalary(salary);  // 通过方法设置以便验证
        this.hireDate = Objects.requireNonNull(hireDate);
    }
    
    // 业务方法
    public void raiseSalary(double percent) {
        if(percent <= 0) {
            throw new IllegalArgumentException("加薪比例必须为正数");
        }
        this.salary *= (1 + percent / 100);
    }
    
    public int yearsOfService() {
        return LocalDate.now().getYear() - hireDate.getYear();
    }
    
    // 访问器方法
    public String getId() { return id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    // 其他getter/setter...
    
    // 重写Object方法
    @Override
    public String toString() {
        return String.format("Employee[id=%s, name=%s, dept=%s, salary=%.2f, hireDate=%s]", 
               id, name, department, salary, hireDate);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id.equals(employee.id);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
    
    // 部门枚举
    public enum Department {
        HR, FINANCE, ENGINEERING, MARKETING, SALES
    }
}

EmployeeManagement.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

/**
 * 员工管理系统
 * 演示对象集合操作
 */
public class EmployeeManagement {
    private final List<Employee> employees = new ArrayList<>();
    
    // 添加员工
    public void addEmployee(Employee employee) {
        employees.add(Objects.requireNonNull(employee));
    }
    
    // 根据ID查找员工
    public Employee findEmployeeById(String id) {
        return employees.stream()
                .filter(e -> e.getId().equals(id))
                .findFirst()
                .orElse(null);
    }
    
    // 给部门员工加薪
    public void raiseSalaryForDepartment(Employee.Department dept, double percent) {
        employees.stream()
                .filter(e -> e.getDepartment() == dept)
                .forEach(e -> e.raiseSalary(percent));
    }
    
    // 显示所有员工
    public void displayAllEmployees() {
        System.out.println("\n===== 员工列表 =====");
        employees.forEach(System.out::println);
    }
    
    public static void main(String[] args) {
        EmployeeManagement system = new EmployeeManagement();
        
        // 添加员工
        system.addEmployee(new Employee("001", "张三", Employee.Department.ENGINEERING, 
                15000, LocalDate.of(2020, 5, 10)));
        system.addEmployee(new Employee("002", "李四", Employee.Department.HR, 
                12000, LocalDate.of(2019, 3, 15)));
        
        // 操作员工数据
        system.raiseSalaryForDepartment(Employee.Department.ENGINEERING, 10);
        
        // 查找并修改员工
        Employee emp = system.findEmployeeById("002");
        if(emp != null) {
            emp.setName("李四（已更名）");
        }
        
        // 显示结果
        system.displayAllEmployees();
    }
}

七、Java文件组织规范

1. 源文件规则

  1. 一个.java文件只能有一个public类
  2. 文件名必须与public类名完全一致（包括大小写）
  3. 包声明(package)必须位于文件首行
  4. 导入语句(import)位于包声明之后，类定义之前

2. 典型文件结构

1
2
3
4
5
6
7
8
9
10
11
12
13
// Employee.java
package com.company.model;

import java.time.LocalDate;
import java.util.Objects;

public class Employee {
    // 类实现...
}

class EmployeeHelper {  // 非public辅助类
    // 实现...
}

八、包(package)与导入(import)机制

1. 包的作用

  • 避免命名冲突
  • 实现访问控制
  • 组织代码结构

2. 包命名规范

  • 公司域名倒写：com.company.project
  • 全部小写
  • 不使用Java保留字

3. 导入使用技巧

1
2
3
4
import java.util.List;       // 导入单个类
import java.util.*;          // 导入整个包（不推荐）
import static java.lang.Math.PI;  // 静态导入
import com.company.model.Employee; // 导入自定义类

九、开发建议与常见问题

1. 类设计原则

  1. 单一职责原则：一个类只做一件事
  2. 高内聚低耦合：内部紧密相关，外部依赖最少
  3. 优先使用组合而非继承
  4. 为所有公开API添加文档注释

2. 常见错误

  1. 忘记实例化对象：MyClass obj; obj.method(); → NullPointerException
  2. 混淆实例变量和局部变量：使用this明确指代
  3. 过度使用静态成员：破坏面向对象特性
  4. 忽视封装：直接暴露字段

Java基本数据类型全面解析

Java作为一门强类型语言，其数据类型系统是编程基础中的核心。下面我将从实际应用角度，深入讲解Java的基本数据类型。

一、Java数据类型体系

1
2
3
4
5
6
7
8
9
10
11
Java数据类型
├── 基本数据类型（8种）
│   ├── 数值型
│   │   ├── 整数类型（byte, short, int, long）
│   │   └── 浮点类型（float, double）
│   ├── 字符型（char）
│   └── 布尔型（boolean）
└── 引用数据类型
    ├── 类（Class）
    ├── 接口（Interface）
    └── 数组

二、八大基本数据类型详解

1. 整数类型

类型 位数 取值范围 默认值 包装类 应用场景
byte 8 -128 ~ 127 0 Byte 二进制数据、节省空间
short 16 -32,768 ~ 32,767 0 Short 较少使用，兼容性考虑
int 32 -2^31 ~ 2^31-1 (约±21亿) 0 Integer 最常用的整数类型
long 64 -2^63 ~ 2^63-1 0L Long 大整数、时间戳

代码示例：

1
2
3
4
byte fileData = -128;          // 最小byte值
short pixelValue = 32767;      // 最大short值
int population = 2_147_483_647; // 使用下划线增强可读性
long globalPopulation = 7_900_000_000L; // 注意L后缀

2. 浮点类型

类型 位数 取值范围 默认值 包装类 精度
float 32 ±1.4E-45 ~ 3.4028235E38 0.0f Float 6-7位有效数字
double 64 ±4.9E-324 ~ 1.7976931348623157E308 0.0d Double 15位有效数字

重要特性：

  • 浮点数遵循IEEE 754标准
  • 存在舍入误差，不适合精确计算（如金融）
  • 默认字面量是double类型

代码示例：

1
2
3
4
5
6
float piApprox = 3.14159f;    // 必须加f后缀
double precisePi = 3.141592653589793;
double scientific = 1.23e10;  // 科学计数法

// 浮点精度问题演示
System.out.println(0.1 + 0.2); // 输出0.30000000000000004

3. 字符类型（char）

  • 16位Unicode字符
  • 范围：\u0000 ~ \uffff（0~65535）
  • 默认值：’\u0000’
  • 包装类：Character

特殊表示方式：

1
2
3
char letterA = 'A';          // 直接字符
char unicodeChar = '\u0041'; // Unicode表示（也是'A'）
char tab = '\t';             // 转义字符

4. 布尔类型（boolean）

  • 只有true和false两个值
  • 默认值：false
  • 包装类：Boolean
  • 大小：JVM规范未明确定义（通常按int处理）

注意事项：

1
2
3
boolean isJavaFun = true;
// if(isJavaFun == true)  // 不推荐写法
if(isJavaFun)            // 推荐写法

三、类型转换机制

1. 自动类型转换（隐式转换）

转换方向：低精度 → 高精度

1
2
3
byte → short → int → long → float → double
          ↑
         char

转换规则：

  • 两种类型兼容
  • 目标类型范围大于源类型

示例：

1
2
3
int i = 100;
long l = i;      // 自动转换
float f = l;     // 可能丢失精度（但自动转换）

2. 强制类型转换（显式转换）

语法：(目标类型)值

风险点：

  • 数据溢出
  • 精度丢失
  • 非兼容类型转换

示例：

1
2
3
4
5
double d = 100.04;
long l = (long)d;  // 截断小数部分，l=100
int i = (int)l;    // 安全转换

byte b = (byte)128; // 溢出！b=-128

3. 特殊转换场景

char与整型的转换：

1
2
3
char c = 'A';
int i = c;        // 自动转换，i=65
char c2 = (char)(i + 1); // c2='B'

布尔类型限制：

1
2
// boolean cannot = 1;       // 错误！
// int number = true;        // 错误！

四、类型默认值与内存分配

1. 默认值规则

数据类型 默认值
byte/short/int/long 0
float/double 0.0
char ‘\u0000’
boolean false
引用类型 null

示例验证：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class DefaultValues {
    static int intValue;
    static boolean boolValue;
    
    public static void main(String[] args) {
        System.out.println(intValue);  // 输出0
        System.out.println(boolValue); // 输出false
        
        // 局部变量必须初始化
        // int localInt;  // 编译错误
        // System.out.println(localInt);
    }
}

2. 内存占用分析

类型 大小 备注
boolean ~1字节 JVM依赖，通常按int处理
byte 1字节
short 2字节
char 2字节 UTF-16编码
int 4字节
float 4字节
long 8字节
double 8字节

数组内存计算示例：

1
int[] arr = new int[100];  // 占用约100*4=400字节

五、包装类与自动装箱拆箱

1. 基本类型与包装类对应

基本类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

2. 自动装箱/拆箱机制

1
2
3
4
5
6
7
8
9
10
// 自动装箱
Integer objInt = 100;  // 编译器转换为 Integer.valueOf(100)

// 自动拆箱
int primInt = objInt;  // 编译器转换为 objInt.intValue()

// 集合中的使用
List<Integer> numbers = new ArrayList<>();
numbers.add(1);        // 自动装箱
int num = numbers.get(0); // 自动拆箱

注意事项：

  • 包装类对象可能为null，拆箱时可能引发NullPointerException
  • 整数缓存：-128~127的Integer对象会被缓存
1
2
3
4
5
6
7
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true（缓存对象）

Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false（新建对象）

六、类型相关工具方法

1. 类型大小与极值

1
2
System.out.println("int范围：" + Integer.MIN_VALUE + "~" + Integer.MAX_VALUE);
System.out.println("float精度位数：" + Float.SIZE);

2. 类型转换工具

1
2
3
4
5
6
7
8
9
10
11
// 字符串转数字
int num = Integer.parseInt("123");
double d = Double.parseDouble("3.14");

// 数字转字符串
String s1 = Integer.toString(123);
String s2 = Double.toString(3.14);

// 进制转换
String binary = Integer.toBinaryString(10); // "1010"
String hex = Integer.toHexString(255);     // "ff"

3. 数学运算工具

1
2
3
4
5
6
// 安全运算
Math.addExact(a, b);  // 溢出时抛出ArithmeticException

// 比较
int max = Integer.max(a, b);
float min = Float.min(x, y);

七、最佳实践与常见问题

1. 类型选择建议

  • 整数：优先使用int，大数用long
  • 小数：优先使用double，除非内存敏感
  • 布尔：避免用其他类型模拟boolean
  • 字符：明确需要单个字符时才使用char

2. 常见陷阱

浮点数比较：

1
2
3
4
5
// 错误方式
if (d1 == d2) {...}

// 正确方式
if (Math.abs(d1 - d2) < 1e-6) {...}

大数溢出：

1
2
3
4
5
6
// 错误：发生溢出
int million = 1000000;
int result = million * million;  // -727379968

// 正确：使用long
long result = (long)million * million;

自动装箱性能：

1
2
3
4
5
6
7
8
// 低效（创建多余对象）
Integer sum = 0;
for (int i=0; i<10000; i++) {
    sum += i;  // 反复装箱拆箱
}

// 高效
int sum = 0;

3. 特殊值处理

1
2
3
4
5
6
7
8
9
10
// 浮点特殊值
double inf = Double.POSITIVE_INFINITY;
double nan = Double.NaN;

// 判断NaN
if (Double.isNaN(nan)) {...}

// 最大值处理
long max = Long.MAX_VALUE;
// max + 1 会变成 Long.MIN_VALUE