Java基础知识总结（超详细整理）

以下是Java基础知识的详细总结，包含核心概念和代码示例，涵盖语法、面向对象、常用类等关键内容：

一、Java基础语法

1. 基本数据类型

Java有8种基本数据类型，分为数值型、字符型、布尔型：

public class BasicTypes {
   
    public static void main(String[] args) {
   
        // 整数型
        byte b = 127;         // 1字节，范围：-128~127
        short s = 32767;      // 2字节
        int i = 2147483647;   // 4字节（默认整数类型）
        long l = 9223372036854775807L; // 8字节，需加L后缀

        // 浮点型
        float f = 3.14F;      // 4字节，需加F后缀
        double d = 3.1415926; // 8字节（默认浮点类型）

        // 字符型
        char c = 'A';         // 2字节，Unicode字符
        char chinese = '中';  // 支持中文

        // 布尔型
        boolean flag = true;  // 1位，仅true/false
    }
}

2. 运算符

包括算术、赋值、比较、逻辑、位运算等：

public class Operators {
   
    public static void main(String[] args) {
   
        // 算术运算符
        int a = 10, b = 3;
        System.out.println(a + b);   // 13
        System.out.println(a / b);   // 3（整数除法）
        System.out.println(a % b);   // 1（取余）
        System.out.println(++a);     // 11（先自增后使用）

        // 逻辑运算符
        boolean x = true, y = false;
        System.out.println(x && y);  // false（短路与）
        System.out.println(x || y);  // true（短路或）

        // 位运算符（操作二进制位）
        int c = 6; // 二进制：110
        int d = 3; // 二进制：011
        System.out.println(c & d);   // 2（010，按位与）
        System.out.println(c | d);   // 7（111，按位或）
        System.out.println(c ^ d);   // 5（101，按位异或）
    }
}

3. 流程控制

• 条件语句：if-else、switch

  public class Condition {
       
    public static void main(String[] args) {
       
        int score = 85;
        // if-else
        if (score >= 90) {
       
            System.out.println("优秀");
        } else if (score >= 60) {
       
            System.out.println("及格");
        } else {
       
            System.out.println("不及格");
        }
  
        // switch（JDK12+支持表达式）
        String day = "MON";
        switch (day) {
       
            case "MON", "TUE", "WED", "THU", "FRI" -> System.out.println("工作日");
            case "SAT", "SUN" -> System.out.println("周末");
            default -> System.out.println("无效日期");
        }
    }
  }
  

• 循环语句：for、while、do-while

  public class Loops {
       
    public static void main(String[] args) {
       
        // for循环
        for (int i = 0; i < 5; i++) {
       
            System.out.print(i + " "); // 0 1 2 3 4
        }
  
        // 增强for循环（遍历数组/集合）
        int[] arr = {
       1, 2, 3};
        for (int num : arr) {
       
            System.out.print(num + " "); // 1 2 3
        }
  
        // while循环
        int count = 0;
        while (count < 3) {
       
            System.out.println("count: " + count);
            count++;
        }
    }
  }
  

二、面向对象编程（OOP）

1. 类与对象

类是模板，对象是类的实例：

// 定义类
class Person {
   
    // 属性（成员变量）
    String name;
    int age;

    // 方法（行为）
    void sayHello() {
   
        System.out.println("Hello, 我叫" + name + ", 今年" + age + "岁");
    }
}

// 使用类创建对象
public class ClassObject {
   
    public static void main(String[] args) {
   
        Person p = new Person(); // 创建对象
        p.name = "张三";         // 赋值属性
        p.age = 20;
        p.sayHello();           // 调用方法：Hello, 我叫张三, 今年20岁
    }
}

2. 构造方法

用于初始化对象，与类名相同且无返回值：

class Student {
   
    String name;
    int id;

    // 无参构造
    Student() {
   }

    // 有参构造
    Student(String n, int i) {
   
        name = n;
        id = i;
    }

    void show() {
   
        System.out.println("姓名：" + name + "，学号：" + id);
    }
}

public class Constructor {
   
    public static void main(String[] args) {
   
        Student s1 = new Student(); // 调用无参构造
        s1.name = "李四";
        s1.id = 1001;

        Student s2 = new Student("王五", 1002); // 调用有参构造
        s2.show(); // 姓名：王五，学号：1002
    }
}

3. 封装

通过private修饰属性，提供get/set方法访问：

class Car {
   
    private String brand; // 私有属性，外部无法直接访问
    private int price;

    // get方法：获取属性值
    public String getBrand() {
   
        return brand;
    }

    // set方法：设置属性值（可加验证）
    public void setBrand(String b) {
   
        if (b != null) {
   
            brand = b;
        }
    }

    public int getPrice() {
   
        return price;
    }

    public void setPrice(int p) {
   
        if (p > 0) {
    // 价格必须为正数
            price = p;
        }
    }
}

public class Encapsulation {
   
    public static void main(String[] args) {
   
        Car car = new Car();
        car.setBrand("特斯拉");
        car.setPrice(-100000); // 无效值，不生效
        System.out.println(car.getBrand() + "价格：" + car.getPrice()); // 特斯拉价格：0
    }
}

4. 继承

使用extends关键字，子类继承父类的属性和方法：

// 父类
class Animal {
   
    String name;

    void eat() {
   
        System.out.println(name + "在吃东西");
    }
}

// 子类继承父类
class Dog extends Animal {
   
    // 重写父类方法
    @Override
    void eat() {
   
        System.out.println(name + "在吃骨头");
    }

    // 子类特有方法
    void bark() {
   
        System.out.println(name + "在汪汪叫");
    }
}

public class Inheritance {
   
    public static void main(String[] args) {
   
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.eat();  // 旺财在吃骨头（调用重写的方法）
        dog.bark(); // 旺财在汪汪叫（子类特有）
    }
}

5. 多态

同一行为的不同表现形式（父类引用指向子类对象）：

class Cat extends Animal {
   
    @Override
    void eat() {
   
        System.out.println(name + "在吃鱼");
    }
}

public class Polymorphism {
   
    public static void main(String[] args) {
   
        Animal animal1 = new Dog(); // 父类引用指向Dog对象
        Animal animal2 = new Cat(); // 父类引用指向Cat对象

        animal1.name = "小白";
        animal2.name = "小花";

        animal1.eat(); // 小白在吃骨头（调用Dog的eat）
        animal2.eat(); // 小花在吃鱼（调用Cat的eat）
    }
}

6. 抽象类与接口

• 抽象类：用abstract修饰，可包含抽象方法（无实现）和普通方法
  ```java
  abstract class Shape {
  abstract double getArea(); // 抽象方法，子类必须实现
  }

class Circle extends Shape {
double radius;

Circle(double r) {
    radius = r;
}

@Override
double getArea() {
    return Math.PI * radius * radius; // 圆面积公式
}

}

- **接口**：用`interface`修饰，全是抽象方法（JDK8+可有默认方法）
```java
interface Flyable {
    void fly(); // 抽象方法

    default void land() { // 默认方法
        System.out.println("降落");
    }
}

class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟在飞");
    }
}

三、常用类

1. String类

不可变字符串，常用方法：

public class StringDemo {
   
    public static void main(String[] args) {
   
        String s = "Hello Java";
        System.out.println(s.length()); // 长度：9
        System.out.println(s.charAt(1)); // 索引1的字符：e
        System.out.println(s.substring(6)); // 从索引6截取：Java
        System.out.println(s.contains("Java")); // 是否包含：true
        System.out.println(s.toUpperCase()); // 转大写：HELLO JAVA
    }
}

2. 包装类

基本类型的包装对象，提供类型转换等方法：

public class WrapperClass {
   
    public static void main(String[] args) {
   
        // 装箱：基本类型→包装类
        Integer i1 = Integer.valueOf(100);
        Integer i2 = 200; // 自动装箱

        // 拆箱：包装类→基本类型
        int num = i1.intValue();
        int sum = i1 + i2; // 自动拆箱

        // 字符串转基本类型
        int a = Integer.parseInt("123");
        double b = Double.parseDouble("3.14");
    }
}

3. 集合框架

常用集合：ArrayList（动态数组）、HashMap（键值对）

import java.util.ArrayList;
import java.util.HashMap;

public class Collections {
   
    public static void main(String[] args) {
   
        // ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("苹果");
        list.add("香蕉");
        System.out.println(list.get(0)); // 获取第一个元素：苹果
        for (String fruit : list) {
   
            System.out.println(fruit);
        }

        // HashMap
        HashMap<String, Integer> map = new HashMap<>();
        map.put("语文", 90);
        map.put("数学", 85);
        System.out.println(map.get("语文")); // 获取值：90
        for (String key : map.keySet()) {
   
            System.out.println(key + "：" + map.get(key));
        }
    }
}

4. 异常处理

使用try-catch-finally捕获异常：

public class ExceptionHandling {
   
    public static void main(String[] args) {
   
        int[] arr = {
   1, 2, 3};
        try {
   
            System.out.println(arr[3]); // 数组越界，抛出异常
        } catch (ArrayIndexOutOfBoundsException e) {
   
            System.out.println("异常：" + e.getMessage()); // 捕获异常
        } finally {
   
            System.out.println("无论是否异常，都会执行"); // 释放资源
        }
    }
}

四、其他重要知识点

• static关键字：修饰静态成员（属于类，而非对象）
  ```java
  class Tool {
  static String version = "1.0"; // 静态变量

  static void printVersion() { // 静态方法

    System.out.println("版本：" + version);
  

  }
  }

public class StaticDemo {
public static void main(String[] args) {
// 直接通过类名访问，无需创建对象
Tool.printVersion(); // 版本：1.0
System.out.println(Tool.version);
}
}

- **this与super**：`this`指代当前对象，`super`指代父类对象
```java
class Parent {
    String name = "父类";
}

class Child extends Parent {
    String name = "子类";

    void show() {
        System.out.println(this.name); // 子类
        System.out.println(super.name); // 父类
    }
}

以上内容涵盖了Java基础的核心知识点，通过代码示例可直观理解语法规则和面向对象特性。实际开发中需结合具体场景灵活运用，进一步学习集合、IO、多线程等进阶内容。