Java 是一种广泛使用的编程语言，具有跨平台性（通过 Java 虚拟机 JVM 实现），并且支持面向对象编程。它被广泛应用于企业级开发、Web 开发、Android 开发等领域。下面是 Java 基础教程，涵盖了从入门到进阶的常见概念和语法。

1. Java 基础语法

1.1 Java 程序结构

Java 程序通常包括类和方法。每个 Java 程序必须至少包含一个类，并且有一个 main() 方法作为程序入口。

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

1.2 数据类型

Java 支持多种数据类型，分为基本数据类型和引用数据类型。

  • 基本数据类型：
    • 整数类型：byte (1字节), short (2字节), int (4字节), long (8字节)
    • 浮点类型：float (4字节), double (8字节)
    • 字符类型：char (2字节，用于表示单个字符)
    • 布尔类型：boolean (1字节，true 或 false)
  • 引用数据类型：
    • 对象（类实例）
    • 数组

1.3 变量声明与常量

// 变量声明
int num = 10;  // 整型变量
float pi = 3.14f;  // 浮点型变量
boolean isActive = true;  // 布尔变量
char letter = 'A';  // 字符变量

// 常量声明（常量名通常使用大写字母）
final double GRAVITY = 9.8;  // 常量

1.4 控制结构

Java 提供了多种控制结构，包括条件语句和循环语句。

  • 条件语句：int age = 20; if (age >= 18) { System.out.println("Adult"); } else { System.out.println("Minor"); }
  • 循环语句：// for 循环 for (int i = 0; i < 5; i++) { System.out.println(i); } // while 循环 int j = 0; while (j < 5) { System.out.println(j); j++; } // do-while 循环 int k = 0; do { System.out.println(k); k++; } while (k < 5);

2. 面向对象编程（OOP）

2.1 类与对象

Java 是一种面向对象的语言，类是创建对象的模板。

public class Car {
    // 属性（成员变量）
    String color;
    String model;
    
    // 构造方法
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    // 方法
    public void start() {
        System.out.println(model + " is starting.");
    }
    
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car("Red", "Tesla");
        myCar.start();  // 调用方法
    }
}

2.2 继承

Java 支持类的继承，允许你创建一个新类来继承现有类的特性。

class Animal {
    public void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();  // 输出: Bark
    }
}

2.3 多态

多态是指同一个方法调用，产生不同的行为，具体表现为方法的重载和重写。

  • 方法重载：同一类中方法名称相同，但参数不同。
  • 方法重写：子类重写父类的方法。
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

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

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));  // 输出: 8
        System.out.println(calc.add(5.5, 3.3));  // 输出: 8.8
    }
}

2.4 接口与抽象类

  • 接口：接口定义了方法的规范，但没有实现。类可以实现接口，并提供方法的具体实现。
  • 抽象类：抽象类可以包含抽象方法和具体方法，不能直接实例化。
// 接口
interface Shape {
    void draw();
}

// 抽象类
abstract class Shape2 {
    abstract void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Square extends Shape2 {
    @Override
    void draw() {
        System.out.println("Drawing a square.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();  // 输出: Drawing a circle.

        Shape2 square = new Square();
        square.draw();  // 输出: Drawing a square.
    }
}

3. 异常处理

Java 提供了 try-catch 块来处理运行时异常，以避免程序崩溃。

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;  // 会抛出 ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("This block always executes.");
        }
    }
}

4. 常用 Java 库

  • 字符串处理：String str = "Hello, Java!"; System.out.println(str.length()); // 输出: 13 System.out.println(str.substring(7)); // 输出: Java!
  • 集合类：import java.util.*; List<String> list = new ArrayList<>(); list.add("Apple"); list.add("Banana"); list.add("Cherry"); for (String item : list) { System.out.println(item); }
  • 文件操作：import java.io.*; public class FileExample { public static void main(String[] args) throws IOException { FileWriter writer = new FileWriter("example.txt"); writer.write("Hello, World!"); writer.close(); } }

5. Java 高级特性

5.1 Lambda 表达式

Java 8 引入了 Lambda 表达式，使得函数式编程风格可以更方便地在 Java 中使用。

import java.util.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
        
        // 使用 Lambda 表达式
        list.forEach(item -> System.out.println(item));
    }
}

5.2 Stream API

Stream API 允许你通过声明式的方式处理集合，提供了函数式的风格。

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry", "Orange");
        
        // 使用 Stream 进行筛选和排序
        list.stream()
            .filter(s -> s.startsWith("B"))
            .sorted()
            .forEach(System.out::println);  // 输出: Banana
    }
}

6. Java 常见问题

  1. 如何解决 NullPointerException：始终确保在使用对象前进行 null 检查。
  2. 如何提高性能：使用合适的数据结构，如 HashMap 代替 ArrayList 进行查找。
  3. 如何调试 Java 程序：使用 System.out.println() 或者 IDE 内置的调试工具，设置断点和查看变量状态。

以上就是 Java 基础教程的一个概述。Java 语言非常丰富，涵盖的内容也非常多。如果你有任何具体问题或更深入的学习需求，随时告诉我！