Java基础语法与面向对象编程核心要点解析

1. Java学习笔记1.14：从基础语法到面向对象编程

今天整理的是Java学习过程中最关键的语法基础和面向对象编程要点。这些内容看似基础，但实际开发中90%的bug都源于对这些核心概念的掌握不扎实。我会结合自己踩过的坑，分享真正实用的学习方法和注意事项。

2. Java基础语法精要

2.1 变量与数据类型

Java是强类型语言，所有变量必须先声明后使用。基本数据类型包括：

• 整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)
• 浮点型：float(4字节)、double(8字节)
• 字符型：char(2字节)
• 布尔型：boolean(1位)

特别注意：float类型赋值时必须在数字后加f，如float f = 3.14f，否则会被默认为double类型导致编译错误

类型转换有两种方式：

1. 自动类型转换（小范围→大范围）
2. 强制类型转换（大范围→小范围，可能丢失精度）

java复制int i = 100;
long l = i;  // 自动转换
double d = 3.14;
int i2 = (int)d;  // 强制转换，i2=3

2.2 运算符与表达式

Java运算符优先级从高到低：

1. 括号()
2. 单目运算符++ -- ! ~
3. 算术运算符* / % + -
4. 移位运算符<< >> >>>
5. 关系运算符< <= > >= instanceof
6. 相等运算符== !=
7. 逻辑运算符& ^ | && ||
8. 三目运算符?:
9. 赋值运算符= += -= *= /= %=

实际开发中建议多用括号明确优先级，而不是依赖记忆

3. 流程控制结构

3.1 分支结构

if-else的三种形式：

java复制// 形式1
if(condition) {
    // code
}

// 形式2
if(condition) {
    // code1
} else {
    // code2
}

// 形式3
if(condition1) {
    // code1
} else if(condition2) {
    // code2
} else {
    // code3
}

switch-case结构：

java复制switch(expression) {
    case value1:
        // code1
        break;
    case value2:
        // code2
        break;
    default:
        // default code
}

switch的expression可以是byte/short/int/char/String/enum，从Java 14开始支持switch表达式

3.2 循环结构

三种循环方式：

1. while循环

java复制while(condition) {
    // code
}

2. do-while循环

java复制do {
    // code
} while(condition);

3. for循环

java复制for(初始化; 条件; 迭代) {
    // code
}

循环控制语句：

• break：跳出当前循环
• continue：跳过本次循环
• 带标签的break/continue：可以跳出指定循环

4. 面向对象编程核心

4.1 类与对象

类是对象的模板，对象是类的实例。定义类的语法：

java复制[修饰符] class 类名 {
    // 成员变量
    // 构造方法
    // 成员方法
}

创建对象：

java复制类名 对象名 = new 类名();

4.2 构造方法

特点：

• 方法名与类名相同
• 没有返回值类型
• 主要完成对象初始化

如果没显式定义构造方法，编译器会自动提供无参构造方法；如果定义了有参构造方法，建议同时显式定义无参构造方法。

4.3 this关键字

this的三种用法：

1. 访问当前对象的成员变量

java复制public void setName(String name) {
    this.name = name;
}

2. 调用当前对象的成员方法

java复制this.method();

3. 调用当前类的构造方法

java复制this();  // 调用无参构造
this(参数);  // 调用有参构造

4.4 封装性

实现封装的步骤：

1. 将成员变量私有化(private)
2. 提供公共的(public)getter/setter方法
3. 在setter方法中加入合理性验证

java复制public class Person {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        if(name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("姓名不能为空");
        }
        this.name = name;
    }
}

5. 继承与多态

5.1 继承的实现

语法：

java复制class 子类 extends 父类 {
    // code
}

继承的特点：

• Java只支持单继承
• 子类继承父类非private的成员变量和方法
• 子类可以重写(override)父类方法

5.2 方法重写规则

1. 方法名相同
2. 参数列表相同
3. 返回值类型相同或是其子类
4. 访问权限不能比父类更严格
5. 不能抛出比父类更多的异常

5.3 super关键字

super的三种用法：

1. 访问父类的成员变量

java复制super.变量名;

2. 调用父类的成员方法

java复制super.方法名();

3. 调用父类的构造方法

java复制super();  // 调用无参构造
super(参数);  // 调用有参构造

5.4 多态的实现

多态的三个必要条件：

1. 继承关系
2. 方法重写
3. 父类引用指向子类对象

java复制class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

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

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();  // 多态
        a.eat();  // 输出"猫吃鱼"
    }
}

6. 数组与常用类

6.1 数组的定义与使用

三种初始化方式：

java复制// 方式1
int[] arr1 = new int[3];
arr1[0] = 1;

// 方式2
int[] arr2 = new int[]{1,2,3};

// 方式3
int[] arr3 = {1,2,3};

数组的遍历：

java复制// for循环
for(int i=0; i<arr.length; i++) {
    System.out.println(arr[i]);
}

// foreach
for(int num : arr) {
    System.out.println(num);
}

6.2 String类常用方法

String是不可变对象，常用方法：

• length()：获取长度
• charAt(int index)：获取指定位置字符
• substring(int begin, int end)：截取子串
• indexOf(String str)：查找子串位置
• split(String regex)：分割字符串
• trim()：去除首尾空格

字符串拼接建议使用StringBuilder提高性能

6.3 日期时间处理

Java 8之前的Date和Calendar类使用复杂且线程不安全，建议使用Java 8新增的日期时间API：

java复制LocalDate date = LocalDate.now();  // 当前日期
LocalTime time = LocalTime.now();  // 当前时间
LocalDateTime dateTime = LocalDateTime.now();  // 当前日期时间

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = dateTime.format(formatter);

7. 异常处理机制

7.1 异常分类

Java异常体系：

code复制Throwable
    ├── Error（系统错误，不应捕获）
    └── Exception（可处理异常）
        ├── RuntimeException（运行时异常）
        └── 非RuntimeException（检查异常）

常见运行时异常：

• NullPointerException
• ArrayIndexOutOfBoundsException
• ClassCastException
• ArithmeticException

7.2 try-catch-finally

基本语法：

java复制try {
    // 可能抛出异常的代码
} catch(异常类型1 e) {
    // 处理异常1
} catch(异常类型2 e) {
    // 处理异常2
} finally {
    // 无论是否发生异常都会执行的代码
}

finally块通常用于释放资源，如关闭文件、数据库连接等

7.3 自定义异常

创建自定义异常：

java复制class MyException extends Exception {
    public MyException() {
        super();
    }
    
    public MyException(String message) {
        super(message);
    }
}

抛出异常：

java复制throw new MyException("自定义异常信息");

8. 集合框架基础

8.1 Collection接口

主要子接口：

• List：有序可重复
• Set：无序不可重复
• Queue：队列

常用实现类：

• ArrayList：基于数组，查询快增删慢
• LinkedList：基于链表，增删快查询慢
• HashSet：基于哈希表，无序
• LinkedHashSet：保持插入顺序
• TreeSet：基于红黑树，自然排序

8.2 Map接口

常用实现类：

• HashMap：基于哈希表，无序
• LinkedHashMap：保持插入顺序
• TreeMap：基于红黑树，按键排序
• Hashtable：线程安全但性能差

Map的基本操作：

java复制Map<String, Integer> map = new HashMap<>();
map.put("a", 1);  // 添加
int value = map.get("a");  // 获取
map.remove("a");  // 删除

8.3 集合遍历方式

List遍历：

java复制// for循环
for(int i=0; i<list.size(); i++) {
    System.out.println(list.get(i));
}

// foreach
for(String s : list) {
    System.out.println(s);
}

// 迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    System.out.println(it.next());
}

Map遍历：

java复制// 遍历key
for(String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

// 遍历entry
for(Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

9. IO流基础

9.1 流的分类

按流向分：

• 输入流：InputStream/Reader
• 输出流：OutputStream/Writer

按处理单位分：

• 字节流：InputStream/OutputStream
• 字符流：Reader/Writer

9.2 常用流类

字节流：

• FileInputStream/FileOutputStream
• BufferedInputStream/BufferedOutputStream

字符流：

• FileReader/FileWriter
• BufferedReader/BufferedWriter

9.3 文件读写示例

读取文本文件：

java复制try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

写入文本文件：

java复制try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("Hello World");
    bw.newLine();
} catch (IOException e) {
    e.printStackTrace();
}

使用try-with-resources语法可以自动关闭资源，避免忘记调用close()

10. 多线程基础

10.1 线程创建方式

1. 继承Thread类

java复制class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行代码
    }
}

new MyThread().start();

2. 实现Runnable接口

java复制class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行代码
    }
}

new Thread(new MyRunnable()).start();

3. 使用Lambda表达式（Java 8+）

java复制new Thread(() -> {
    // 线程执行代码
}).start();

10.2 线程同步

使用synchronized实现同步：

java复制// 同步方法
public synchronized void method() {
    // code
}

// 同步代码块
synchronized(锁对象) {
    // code
}

同步会降低性能，应尽量减小同步代码块的范围

10.3 线程通信

wait/notify机制：

java复制synchronized(lock) {
    while(条件不满足) {
        lock.wait();
    }
    // 处理业务
    lock.notifyAll();
}

11. 反射机制

11.1 获取Class对象

三种方式：

java复制// 1. 类名.class
Class<?> clazz1 = String.class;

// 2. 对象.getClass()
String s = "hello";
Class<?> clazz2 = s.getClass();

// 3. Class.forName()
Class<?> clazz3 = Class.forName("java.lang.String");

11.2 创建对象

通过反射创建实例：

java复制Class<?> clazz = Class.forName("com.example.Person");
Object obj = clazz.newInstance();  // 调用无参构造

11.3 调用方法

反射调用方法：

java复制Method method = clazz.getMethod("methodName", 参数类型.class);
Object result = method.invoke(obj, 参数值);

12. 泛型基础

12.1 泛型类

定义泛型类：

java复制class Box<T> {
    private T data;
    
    public void setData(T data) {
        this.data = data;
    }
    
    public T getData() {
        return data;
    }
}

使用：

java复制Box<String> box = new Box<>();
box.setData("hello");
String s = box.getData();

12.2 泛型方法

定义泛型方法：

java复制public <T> void printArray(T[] array) {
    for(T element : array) {
        System.out.println(element);
    }
}

12.3 类型通配符

• 无界通配符：<?>
• 上界通配符：<? extends Number>
• 下界通配符：<? super Integer>

13. 注解基础

13.1 内置注解

常用内置注解：

• @Override：标记方法重写
• @Deprecated：标记过时
• @SuppressWarnings：抑制警告

13.2 自定义注解

定义注解：

java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
    int count() default 0;
}

使用注解：

java复制@MyAnnotation(value = "test", count = 3)
public void myMethod() {
    // code
}

14. Lambda表达式

14.1 基本语法

Lambda表达式组成：

• 参数列表
• 箭头符号->
• 方法体

示例：

java复制// 无参
() -> System.out.println("Hello")

// 单参
s -> System.out.println(s)

// 多参
(a, b) -> a + b

// 代码块
(a, b) -> {
    int sum = a + b;
    return sum;
}

14.2 函数式接口

只有一个抽象方法的接口称为函数式接口，可以用Lambda表达式实现。Java内置的常用函数式接口：

• Consumer：消费型，接受一个参数无返回值
• Supplier：供给型，无参数有返回值
• Function<T,R>：函数型，接受T返回R
• Predicate：断言型，接受T返回boolean

15. Stream API

15.1 创建Stream

几种创建方式：

java复制// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();

// 从数组创建
String[] array = {"a", "b", "c"};
Stream<String> stream2 = Arrays.stream(array);

// 直接创建
Stream<String> stream3 = Stream.of("a", "b", "c");

15.2 常用操作

中间操作：

• filter(Predicate)：过滤
• map(Function)：映射
• sorted()：排序
• distinct()：去重

终止操作：

• forEach(Consumer)：遍历
• collect(Collector)：收集
• reduce()：归约
• count()：计数

示例：

java复制List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());