java基础知识总结

原创于 2025-08-19 18:46:01 发布 · 744 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #开发语言

Java基础知识

一、基本语法
二、面向对象(oop)
三、异常处理
四、字符串
五泛型
六、IO流
七、多线程
其他重要知识

java 基础包含语法、面向对象，异常处理、文件操作等方面。

一、基本语法

1、数据类型

基本数据类型(8种，值传递)
- 整数型：(bety(1字节)、short(2)、int(4)、long(8，需要加L后缀))
- 浮点：float(4,需要F后缀)，Double(8,默认)
- 字符：char(2字节，单引号使用）
- 布尔：Boolean(1位，true/false)
引用数据类型(引用传递)：
- 类(class)、接口(interface)、数组、枚举(enum)等
- 默认值为null.

2、变量与常量

变量：数据类型变量名 = 初始值；(如int age = 20);
- 作用域：局部变量(方法内，需要显示初始化)，成员变量(类内方法外，有默认值)、静态变量(static修饰，属于类)。
- 常量：final 数据类型常量名 = 值；(一旦赋值不可修改，命名全大写)

3、运算符

算术运算符：+、-、*、/整除、%、++、–
关系运算符：==(值相等)，!=、>、<、>=、<=。
逻辑运算符：&&(短路与)、||(短路或)、!(非)。
- 短路性质：
位运算：&、|、!、^、<<(左移)、>>右移(保留符号)、>>>右移(无符号)
赋值运算：=；+=；-=等。
三目运算符：条件？表达式1 ：表达式2

4、控制流程

条件语句：

// if-else
if (条件1) { ... } 
else if (条件2) { ... } 
else { ... }

// switch（Java 7+支持String，Java 12+支持表达式）
switch (变量) {
    case 值1: ...; break;
    case 值2: ...; break;
    default: ...; // 默认分支
}

循环语句

// for循环
for (初始化; 条件; 迭代) { ... }

// 增强for循环（遍历集合/数组）
for (元素类型 变量 : 集合/数组) { ... }

// while/do-while
while (条件) { ... }
do { ... } while (条件); // 至少执行一次

跳转语句
- break：跳出循环。
- contuine：跳出本次循环。
- return：结束方法，

二、面向对象(oop)

1、三大特性

封装：隐藏内部实现，通过访问修饰符控制访问权限。
- private ：进本类可访问。
- default（默认）：本包可见。
- protected：本包+子类可见
- public：公开
多态：同一行为的不同实现(编译时多态：重载，运行时多态：重写)
- 重写(@Override)：子类重写父类方法(方法名、参数、返回值相同、访问权限不低于父类)
- 向上转型：父类变量 = new 子类()；(自动转换，只能调用父类声明的方法)
- 向下转型：子类变量 = (子类)父类对象；(需强制转换，需先判断instanceof)
继承： class子类 extends 父类(属性和方法)
- 子类继承父类非private成员(属性和方法)
- super关键字；调用父类构造器(super(…))，必须在子类第一行，

2、类和对象
- 类：抽象模板，定义属性和方法；对象：类的实例(new 类名()创建)
- 构造器：与类名同名，无返回值，用于初始化对象(提供无参构造函数，若定义有参函数会覆盖无参构造，需要显式声明无参构造)

class Person {
    String name;
    // 构造器
    public Person(String name) {
        this.name = name; // this指代当前对象
    }
}
// 创建对象
Person p = new Person("Alice");

3、抽象类和接口

抽象类(abstract class)
- 含抽象方法(abstract修饰，无实现)和具体方法。
  - 含抽象方法(abstract修饰，无实现)和具体方法。
  - 不能实例化，需要子类继承并实现方法
  - 可包含构造函数，成员变量。
- 接口(interface)：
  - JDK8前：只包含抽象方法和常量(默认public static final)
  - JDK8+：可含默认方法(default)和静态方法(static)。
  - 类通过implements实现接口，可多实现
  - 接口可继承接口(多继承)。
- 区别：抽象类是is-a关系，接口是 has-a能力，抽象类单继承，接口多实现。

4、关键字

static：修饰变量(类变量，共享)、方法(类方法，可直接通过类名调用，无this)、代码块(类加载器执行，用于初始化)
final：修饰类(不可继承)、方法(不可重写)、变量(不可修改)
this：当前对象，用于访问当前对象的成员变量、构造器/方法。
super：指代父类，用于访问父类成员

三、异常处理

1、异常体系

顶层类：ThroWable
- Error：严重错误(如OutOfMemoryError)，程序无法处理
- Exception：可处理的异常
  - 受检异常(checked Exception)：编译时检查(如IoException必须处理)
  - 非受检异常(unChecked Exception)：运行时异常(如NullPointException、IndexOutOfBoundsException,可不用显示处理)

2、异常处理机制

捕获异常：try-catch-finally
抛出异常：throw、throws。
throw new 异常类()，
public void read() throws 异常类 {}
trywhit-resource(JDK7+)：自动关闭实现AutoCloseable的资源(如流、连接)

四、字符串

String：不可变（底层char[]被final修饰），每次修改生成新对象
StringBuffer：可变，线程安全（方法加synchronized），效率低
StringBuilder：可变，非线程安全，效率高（推荐单线程使用）
常用方法：equals()（内容比较）、length()、substring()、indexOf()、trim()、split()等

五泛型

作用：编译时类型检查，避免强制转换，提高代码复用
定义：类（class Box）、接口（interface List）、方法（public T get()）
通配符：
- ? extends T：上限，只能读取（如? extends Number表示 Number 及其子类）
- ? super T：下限，只能写入（如? super Integer表示 Integer 及其父类）

六、IO流

1、分类

分类：
- 按数据单位：字节流(InPutStream/OutPutStream)、字符流(Reader/Writer)
- 按照流向：输入流/输出流
- 按角色：节点流(直接操作文件，如FileInPutStream)、处理流(包装节点流、如BufferedInPutStream)
常用流：
- 缓冲流（BufferedXXX）：提高读写效率
- 转换流（InputStreamReader/OutputStreamWriter）：字节流转字符流
- 对象流（ObjectInputStream/ObjectOutputStream）：序列化（Serializable）与反序列化

2、字节流
字节流是Iowa操作的基础，可处理所有类型的数据。
1）输入字节流InputStream
核心方法：
int read();读取一个字节，返回字节值(0-255)，若到达末尾返回-1.
int read(byte[] b)：读取字节到数组b，返回实际读取到的字节数据，末尾返回-1.
void close()，关闭流，释放资源。
常用实现类：

FileinputStream：从文件读取字节。

// 读取文件示例
try(InputStream fils = new FileInputStream("test.txt)) {
	byte[] buffer = new byte[1024]; // 缓冲区
	int len;
	while(len = fils.read(buffer)!=-1) {
		System.out.printf(new StringBuffer(buffer,0,len))
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		fils.close();
	}	
}

ByteArrayinputStrea ：从内存字节数组中读取数据。
FilterInputStream：处理流的父类(如BufferedInputStream）

2）输出字节流（OutPutStream）
核心方法：
void write(int[] b):写入一个字节(仅低8位有效)
void write(byte[] b)；写入一个字节数组b
void write(byte[] b,int off, int len)；写入数组b中从从off开始，len个字节。
void flush()：刷新缓冲区，将数据立刻写入。
void close()；关闭流(关闭前自动刷新)。

常见实现
- fileOutPutStream：像文件写入字节。

// 写入文件示例（覆盖模式）
try (OutputStream fos = new FileOutputStream("output.txt")) {
    String content = "Hello, IO!";
    fos.write(content.getBytes()); // 字符串转字节数组
    fos.flush(); // 强制刷新
} catch (IOException e) {
    e.printStackTrace();
}finally {
 fos.close();
}

// 追加模式（第二个参数为true）
try (OutputStream fos = new FileOutputStream("output.txt", true)) {
    fos.write("\nAppend content".getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

- ByteArrayoutPutStream：将数据写入内存数组中。
- FileterOutPutStream：处理流的父类(如BufferedOutPutStream)

3、字符流(Reader/Writer)
字符流专为文本设计，自动处理编码。

输入字符流Reader

常用方法：
int read()：读取一个字符，返回字符值(0-65535)，末尾返回-1.
int read(char[] cbuf)：读取字符到数组cbuf，返回实际读取到的字符数。
void close()：关闭流。
常见实现类：
FileReader：从文件中读取字符(使用系统默认编码集，不推荐)
InputStreanReader：字节流转字符流的转换流(可指定编码集，推荐)
BufferedReader：带缓冲的字符输入流，提供ReadLine方法读取一行文本。
输出字符流Writer
核心方法：
void write(int c)：写入一个字符（仅低 16 位有效）。
void write(char[] cbuf)：写入字符数组。
void write(String str)：写入字符串（便捷方法）。
void flush()：刷新缓冲区。
void close()：关闭流。
常用实现类：
FileWriter：向文件写入字符（默认系统编码，不推荐）。
OutputStreamWriter：字符流→字节流的转换流（可指定编码，推荐）。
BufferedWriter：带缓冲的字符输出流，提供newLine()方法

七、多线程

创建方式：
- 继承Thread类，重写run()
- 实现Runnable接口，实现run()方法
- 实现Callable接口，重写call()(可返回结果，抛异常)

线程状态：新建（New）→ 就绪（Runnable）→ 运行（Running）→ 阻塞（Blocked）/ 等待（Waiting）→ 终止（Terminated）
同步机制：

Synchronized：修饰方法，代码块。(锁对象：方法锁this对象，代码块锁指定对象)
volatile：保证变量可见，禁止代码重排序。(不能保证原子性)
Lock接口：ReentrantLock(可中断，超时获取锁，更灵活)

线程通讯
wait/notify/notifyAll(需要在Synchronized中)

其他重要知识

内部类：
- 成员内部类：类内部方法外，可访问外部类成员、
- 局部内部类：方法内，仅方法内可见
- 匿名内部类：方法内，直接实例化接口/抽象类(如new Runnable(){…})
- 静态内部类：static修饰，不依赖外部类实例，不能访问外部类非静态成员。
反射：通过Class类动态加载获取类信息（属性、方法、构造器）并操作，常用框架（如Spring）

Class<?> cls = Class.forName("com.example.Person"); // 获取Class对象
Object obj = cls.newInstance(); // 创建实例

注解（Annotation）：提供元数据（如@Override、@Deprecated），可自定义注解（需配合元注解@Target、@Retention等）