欢迎来到 www.xservx.com|备案号:蜀ICP备2026035467号-3

java基础知识点总结归纳

一、java基础知识点总结归纳:知识体系全景

Java作为一门跨平台、面向对象、多线程的编程语言,其基础体系涵盖从语法结构到运行机制的完整闭环。本部分系统梳理java基础知识点,构建清晰学习路径图谱,为进阶开发奠定坚实根基。

Java语言核心特征

  • 跨平台性:通过JVM实现“一次编译,到处运行”,底层依赖字节码(.class)而非机器码
  • 面向对象:封装、继承、多态三大特性,支持类与接口机制
  • 自动内存管理:垃圾回收机制(GC)自动释放无引用对象
  • 强类型检查:变量类型在编译期确定,防止类型误用
  • 多线程支持:内置Thread类与synchronized关键字,保障并发安全

Java开发环境配置要点

安装JDK(Java Development Kit)后需配置以下环境变量:

  • JAVA_HOME:JDK安装路径(如 C:\Program Files\Java\jdk-17)
  • PATH:追加 %JAVA_HOME%\bin(Windows)或 $JAVA_HOME/bin(Linux/macOS)
  • CLASSPATH:通常设为 .(当前目录),现代开发中可省略

验证配置:终端执行 java -version 和 javac -version,确保输出版本一致(如17.0.2)。

从HelloWorld看Java程序结构

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

关键要素:

  • 类名与文件名必须完全一致(区分大小写)
  • main方法是程序入口:public static void main(String[] args)
  • 每条语句以分号结尾
  • Java严格区分大小写:System ≠ system

二、java核心语法体系

1. 变量与数据类型

Java数据类型分为基本类型(8种)与引用类型(类、接口、数组)。

类型字节数取值范围默认值
byte1-128 ~ 1270
short2-32768 ~ 327670
int4-2³¹ ~ 2³¹-10
long8-2⁶³ ~ 2⁶³-10L
float4±3.4029E+38F0.0f
double8±1.7977E+3080.0d
char20 ~ 65535\u0000
boolean1位true / falsefalse

注意:整数默认为int,浮点默认为double;字符用单引号,字符串用双引号;long类型值需加L后缀(如123L)。

int a = 10; // int类型字面量
long b = 10000000000L; // long需加L
float c = 3.14f; // float需加f
double d = 3.1415926; // 默认double
char e = 'A'; // 单引号
String f = "Hello"; // 双引号,引用类型

2. 运算符

Java运算符分为算术、关系、逻辑、位、赋值、条件六类,重点注意:

  • 短路逻辑:&&与||遇false/true立即停止计算,提升效率
  • 位运算:左移<< n位相当于乘2ⁿ(如a<<2 = a*4),右移>>保留符号位
  • 字符串拼接:+号遇字符串即转为拼接(如"结果:" + 5 → "结果:5")
  • 自增陷阱:int x=5; int y=x++; → y=5, x=6;int y=++x; → y=6, x=6
int x = 5;
int y = ++x; // 先自增:x=6, y=6
int z = x++; // 后自增:z=6, x=7
boolean flag = (x > 6) && (x++ > 7); // 短路:第二条件不执行,x仍为7

3. 流程控制

分支结构:if-else、switch;循环结构:for、while、do-while;跳转:break、continue、return

switch增强(JDK 14+):

int day = 3;
String result = switch (day) {
    case 1, 2, 3, 4, 5 -> "工作日";
    case 6, 7 -> "周末";
    default -> "无效日期";
};

for-each循环(增强for):

int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
    System.out.println(num);
}

⚠️ 注意:for-each无法获取索引,修改数组元素需用传统for循环。

三、java面向对象编程(OOP)

封装、继承、多态是OOP三大支柱,通过类(class)与对象(object)组织代码。

1. 封装:隐藏实现细节,暴露访问接口

  • 使用private修饰符隐藏属性
  • 提供public的getter/setter方法操作属性
  • 构造器保证对象初始化一致性
public class Person {
    private String name;
    private int age;
    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Getter/Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) {
        if (age >= 0 && age <= 150) this.age = age;
    }
}

2. 继承:extends关键字,单继承+多层继承

  • 子类继承父类非private成员
  • super()调用父类构造器(必须在第一行)
  • 方法重写(override)需满足:方法名、参数列表、返回类型相同
public class Student extends Person {
    private String studentId;
    public Student(String name, int age, String id) {
        super(name, age); // 调用父类构造器
        this.studentId = id;
    }
    // 重写toString方法
    @Override
    public String toString() {
        return "Student{name='" + getName() + "', age=" + getAge() + ", id='" + studentId + "'}";
    }
}

3. 多态:父类引用指向子类对象

核心条件:继承、重写、父类引用指向子类对象

Person p = new Student("张三", 20, "S001");
System.out.println(p.toString()); // 调用子类重写方法
// p.studentId; // 编译错误:父类引用无子类成员

类型转换:

  • 向上转型(自动):子类 → 父类
  • 向下转型(强制):父类 → 子类,需instanceof判断

4. 抽象类与接口

抽象类(abstract class):

  • 可包含抽象方法(无方法体)和具体方法
  • 子类必须实现所有抽象方法,除非子类也是抽象类
  • 不能实例化,但可定义引用变量
public abstract class Animal {
    public abstract void sound(); // 抽象方法
    public void sleep() { System.out.println("动物睡觉"); } // 具体方法
}

接口(interface):

  • JDK 8+:可含默认方法(default)、静态方法
  • JDK 9+:可含私有方法
  • 类实现接口(implements)需重写所有抽象方法
public interface Flyable {
    void fly(); // 默认public abstract
    default void land() { System.out.println("着陆中..."); }
    static void info() { System.out.println("可飞行能力接口"); }
}

四、java数组:连续内存存储结构

1. 数组声明与初始化

静态初始化:指定元素值,长度自动计算

int[] arr1 = {1, 2, 3, 4, 5}; // 简洁写法
int[] arr2 = new int[]{1, 2, 3}; // 标准写法

动态初始化:指定长度,元素默认值初始化

int[] arr = new int[5]; // [0,0,0,0,0]
String[] names = new String[3]; // [null,null,null]

2. 二维数组:数组的数组

规则二维数组:每行长度相同

int[][] matrix = new int[2][3]; // 2行3列
matrix[0][1] = 5;

不规则二维数组:每行长度可不同

int[][] jagged = new int[3][];
jagged[0] = new int[2]; // 第一行2个元素
jagged[1] = new int[4]; // 第二行4个元素
jagged[2] = new int[1]; // 第三行1个元素

3. 常用操作

  • 长度:arr.length(非方法)
  • 复制:System.arraycopy(src, srcPos, dest, destPos, length)
  • 排序:Arrays.sort(arr)(升序)
  • 查找:Arrays.binarySearch(sortedArr, key)
  • 转字符串:Arrays.toString(arr)
int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 1, dest, 2, 3); // 复制src[1..3]到dest[2..4]
System.out.println(Arrays.toString(dest)); // [0,0,2,3,4]

五、java方法:代码复用单元

1. 方法定义格式

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

要素:权限修饰符(public) + 静态标识(static) + 返回类型(int) + 方法名(add) + 参数列表(int a, int b) + 方法体

2. 方法重载(Overload)

同一类中,方法名相同,参数列表不同(类型/个数/顺序),与返回类型无关

int max(int a, int b)
double max(double a, double b)
int max(int a, int b, int c)

调用时根据实参类型自动匹配

3. 可变参数(Varargs)

语法:类型... 参数名(必须位于参数列表末尾)

int sum(int... nums) {
    int total = 0;
    for (int num : nums) total += num;
    return total;
}
sum(1,2,3); // 6
sum(new int[]{1,2,3}); // 6

4. 递归调用

方法直接/间接调用自身,需满足:

  • 有终止条件(否则栈溢出)
  • 每次递归向终止条件逼近
int factorial(int n) {
    if (n == 1) return 1; // 终止条件
    return n * factorial(n - 1);
}

⚠️ 注意:递归效率较低,深度过大可能导致StackOverflowError

六、java异常处理机制

1. 异常体系结构

  • Throwable(根类)
    • Error:严重错误(如OutOfMemoryError),程序无法处理
    • Exception:可处理异常
      • RuntimeException:运行时异常(如NullPointerException),可处理可不处理
      • Checked Exception:受检异常(如IOException),必须处理(try-catch或throws)

2. 异常处理方式

try-catch-finally

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("除零异常:" + e.getMessage());
} finally {
    System.out.println("清理资源(总是执行)");
}

throws声明异常

public static void readFile() throws IOException {
    FileReader fr = new FileReader("test.txt"); // 可能抛出IOException
}

3. 自定义异常

继承Exception(受检)或RuntimeException(非受检)

public class AgeException extends Exception {
    public AgeException(String message) {
        super(message);
    }
}
public void setAge(int age) throws AgeException {
    if (age < 0 || age > 150) {
        throw new AgeException("年龄非法:" + age);
    }
    this.age = age;
}

七、java集合框架体系

1. 集合框架总览

  • Collection(单列集合)
    • List(有序可重复):ArrayList(动态数组)、LinkedList(链表)、Vector(线程安全)
    • Set(无序不重复):HashSet(哈希表)、LinkedHashSet(有序)、TreeSet(排序)
  • Map(双列集合):HashMap(哈希表)、LinkedHashMap(有序)、TreeMap(排序)、Hashtable(线程安全)

2. List核心操作

List list = new ArrayList<>();
list.add("Java");
list.add(1, "Python"); // 在索引1插入
list.set(0, "C++"); // 替换
System.out.println(list.get(1)); // 获取
for (String s : list) { ... } // 增强for

⚠️ 注意:ArrayList随机访问快(O(1)),增删慢(O(n));LinkedList增删快(O(1)),随机访问慢(O(n))

3. Set去重原理

HashSet通过hashCode()和equals()保证元素唯一性:

  • 添加元素时先计算hashCode
  • 若hashCode相同,再调用equals比较
  • 两者均相同则视为重复元素
class Student {
    String name;
    int age;
    // 重写hashCode和equals(基于name和age)
}

TreeSet通过compareTo()或Comparator实现排序

4. Map常用操作

Map map = new HashMap<>();
map.put("张三", 90);
map.put("李四", 85);
System.out.println(map.get("张三")); // 90
map.containsKey("王五"); // false
map.remove("李四");
for (Map.Entry entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

八、java IO流体系

1. IO流分类

  • 按方向:输入流(InputStream/Reader)、输出流(OutputStream/Writer)
  • 按单位:字节流(8位)、字符流(16位,支持中文)
  • 按功能:节点流(直接连接)、处理流(包装节点流)

2. 字节流操作

// 文件复制
FileInputStream fis = new FileInputStream("src.jpg");
FileOutputStream fos = new FileOutputStream("dest.jpg");
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
    fos.write(buffer, 0, len);
}
fis.close();
fos.close();

3. 字符流操作

// 文本文件读取
BufferedReader br = new BufferedReader(new FileReader("test.txt"));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();
// 写入文本
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
bw.write("Hello World");
bw.newLine(); // 换行
bw.close();

4. 对象流与序列化

实现Serializable接口的对象可被序列化(对象→字节流)

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;
}
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
oos.writeObject(new Person("张三", 20));
oos.close();
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"));
Person p = (Person) ois.readObject();
ois.close();

九、java多线程编程

1. 创建线程的两种方式

方式1:继承Thread类

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + i);
        }
    }
}
new MyThread().start();

方式2:实现Runnable接口

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行体
    }
}
new Thread(new MyRunnable()).start();

✅ 推荐Runnable:避免单继承局限,适合多线程共享资源

2. 线程同步机制

synchronized关键字

// 同步代码块
synchronized (lockObject) {
    // 临界区
}
// 同步方法
public synchronized void increment() {
    count++;
}

Lock显式锁(JUC包)

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();
}

3. 线程通信

wait()/notify()必须在synchronized中使用

// 生产者-消费者模式
public synchronized void produce() {
    while (buffer.isFull()) wait();
    buffer.add(item);
    notifyAll();
}
public synchronized void consume() {
    while (buffer.isEmpty()) wait();
    buffer.remove();
    notifyAll();
}

4. 线程池(ExecutorService)

避免频繁创建线程,提高资源利用率

ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    pool.execute(() -> {
        System.out.println(Thread.currentThread().getName() + " 执行任务");
    });
}
pool.shutdown(); // 优雅关闭

十、java虚拟机(JVM)核心原理

1. JVM内存区域划分

  • 程序计数器:线程私有,记录当前指令地址
  • 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等)
  • 本地方法栈:线程私有,服务native方法
  • 堆:线程共享,存放对象实例(GC主要区域)
  • 方法区:线程共享,存储类信息、常量、静态变量

2. 对象创建过程

1. 类加载检查 → 2. 分配内存(指针碰撞/空闲列表) → 3. 初始化零值 → 4. 设置对象头 → 5. 执行init方法

Person p = new Person("张三");
// 对象在堆中创建,引用p在栈中

3. 垃圾回收机制(GC)

判断对象存活:

  • 引用计数法(Java未采用,因循环引用问题)
  • 可达性分析(GC Roots起点)

GC算法:

  • 标记-清除:标记→清除,产生碎片
  • 复制:新生代(Eden:From:To=8:1:1)
  • 标记-整理:老年代,移动对象避免碎片
System.gc(); // 建议GC,不保证立即执行

4. 常见JVM参数

  • -Xms256m:堆初始大小256MB
  • -Xmx1g:堆最大大小1GB
  • -XX:NewRatio=2:新生代/老年代比例1:2
  • -XX:+PrintGCDetails:打印GC日志

十一、网友最关心的10个问题深度解答

1. Java中==和equals()的区别?

==:比较基本类型值是否相等;比较引用类型时比较地址值是否相同

equals():Object类方法,默认行为与==相同;但String、Integer等类重写了equals(),比较内容是否相等

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false(地址不同)
System.out.println(s1.equals(s2)); // true(内容相同)
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true(-128~127缓存)
Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false(超出缓存范围)
2. String、StringBuilder、StringBuffer区别?
  • String:不可变字符序列(底层final char[]),频繁修改效率低
  • StringBuilder:可变字符序列,线程不安全(JDK 5+),单线程推荐
  • StringBuffer:可变字符序列,线程安全(方法同步),多线程使用
String s = "a";
s += "b"; // 创建新对象(效率低)
StringBuilder sb = new StringBuilder();
sb.append("a").append("b"); // 修改原对象(高效)
3. ArrayList和LinkedList区别?
  • ArrayList:基于动态数组,随机访问快O(1),增删慢O(n)(需移动元素)
  • LinkedList:基于双向链表,增删快O(1)(仅修改指针),随机访问慢O(n)
  • 内存占用:LinkedList每节点额外存储前后指针

✅ 选择建议:频繁查询用ArrayList;频繁增删用LinkedList

4. HashMap和Hashtable区别?
  • 线程安全:Hashtable线程安全(方法同步),HashMap线程不安全
  • 空值支持:HashMap允许null键/值(仅1个null键),Hashtable不允许null
  • 性能:HashMap效率更高
  • 初始容量:HashMap默认16,Hashtable默认11

✅ 现代开发推荐:ConcurrentHashMap替代Hashtable

5. 为什么重写equals()必须重写hashCode()?

Java规范要求:相等对象必须有相同hashCode

  • 若a.equals(b)为true → a.hashCode()必须等于b.hashCode()
  • 若hashCode不同 → equals()一定为false

HashMap/HashSet依赖hashCode定位存储位置,若只重写equals()会导致逻辑错误

class Person {
    String name;
    // 重写equals()仅比较name
    @Override
    public boolean equals(Object o) { ... }
    // 未重写hashCode() → 默认地址hashCode
}
Map map = new HashMap<>();
map.put(new Person("张三"), 90);
map.get(new Person("张三")); // 可能返回null(hashCode不同)
6. Java中final、finally、finalize区别?
  • final:修饰类(不可继承)、方法(不可重写)、变量(不可变)
  • finally:try-catch的finally块,无论是否异常都执行(除System.exit())
  • finalize:Object方法,GC调用前执行清理(JDK 9+已弃用)
7. Java中线程有哪几种状态?

Thread.State枚举定义6种状态:

  1. NEW:线程刚创建,未启动
  2. RUNNABLE:运行中(含就绪和运行中)
  3. BLOCKED:等待monitor锁进入同步块
  4. WAITING:无限期等待(Object.wait()、Thread.join())
  5. TIMED_WAITING:限期等待(Thread.sleep()、wait(1000))
  6. TERMINATED:线程执行完毕
8. 深拷贝和浅拷贝区别?

浅拷贝:复制对象本身,引用类型字段仍指向原对象

深拷贝:递归复制所有层级对象,完全独立

// 浅拷贝示例
class Student implements Cloneable {
    String name;
    School school; // 引用类型
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}
Student s1 = new Student();
Student s2 = (Student)s1.clone();
s2.school.name = "北大"; // s1.school.name也被修改
9. Java中异常链是什么?

通过异常的cause属性包装原始异常,保留完整异常链

try {
    // 可能抛出IOException
} catch (IOException e) {
    throw new ServiceLayerException("服务层错误", e); // 包装原始异常
}

调用getCause()可获取原始异常

10. 什么是Java泛型擦除?

Java泛型只存在于编译期,运行时泛型信息被擦除为原始类型(类型擦除)

List list = new ArrayList<>();
list.add("hello");
// 运行时:list.getClass() == List.class(泛型信息丢失)

影响:无法在运行时获取泛型类型(如list.getClass().getGenericSuperclass())