Java基础入门：从零开始掌握核心概念

大家好！Java是一种强大的面向对象编程语言，广泛应用于Web开发、移动应用（如Android）和企业级系统。无论你是编程小白还是初学者，这篇博客将带你一步步学习Java的核心知识。我会用简单易懂的语言和详细代码示例来解释每个概念，帮助你快速上手。让我们开始吧！

1. Java基础知识入门

Java程序基于“类”（class）结构，每个程序至少有一个类和一个main方法作为入口点。Java代码需要编译成字节码（.class文件），然后在Java虚拟机（JVM）上运行。下面是一个最简单的Java程序示例：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); // 输出到控制台
    }
}
  • 解释：public class HelloWorld定义了一个公共类，类名必须与文件名一致（这里是HelloWorld.java）。main方法是程序起点，System.out.println用于打印文本。
  • 运行步骤：
    1. 保存为HelloWorld.java。
    2. 编译：在命令行输入javac HelloWorld.java（生成HelloWorld.class）。
    3. 运行：输入java HelloWorld，输出"Hello, World!"。
2. 数据类型：基础与引用

Java数据类型分为基本类型和引用类型。基本类型直接存储值，引用类型存储对象的引用（地址）。下面是详细分类：

  • 基本数据类型：

    • 整型：int（整数，如42）、long（大整数）、byte（小整数）、short（短整数）。
    • 浮点型：float（单精度浮点数）、double（双精度浮点数，如3.14）。
    • 字符型：char（单个字符，如’A’）。
    • 布尔型：boolean（真或假，如true）。

    示例：

    int age = 25; // 声明并初始化int变量
double price = 99.99; // 双精度浮点数
char grade = 'A'; // 字符
boolean isStudent = true; // 布尔值
System.out.println("Age: " + age + ", Price: " + price); // 输出：Age: 25, Price: 99.99

  • 引用数据类型：包括类、数组、接口等。它们指向对象在内存中的位置。

    String name = "Alice"; // String是引用类型
int[] numbers = {1, 2, 3}; // 数组也是引用类型
System.out.println("Name: " + name + ", First number: " + numbers[0]); // 输出：Name: Alice, First number: 1
3. 流程控制语句：决策与循环

流程控制用于根据条件执行代码或重复操作。Java提供了多种语句：

  • 条件语句：if, else if, else。

    int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}
// 输出：及格

  • switch语句：用于多分支选择。

    char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好");
        break;
    default:
        System.out.println("未知等级");
}
// 输出：良好

  • 循环语句：for, while, do-while。

    // for循环：打印1到5
for (int i = 1; i <= 5; i++) {
    System.out.print(i + " ");
}
// 输出：1 2 3 4 5

// while循环：计算1到10的和
int sum = 0;
int j = 1;
while (j <= 10) {
    sum += j;
    j++;
}
System.out.println("Sum: " + sum); // 输出：Sum: 55
4. 构造方法：初始化对象

构造方法（constructor）是类的一种特殊方法，用于初始化新对象。它与类同名，没有返回类型。如果没有定义，Java提供默认构造方法。

  • 示例：
    public class Car {
    String brand; // 属性
    int year;
    
    // 构造方法：初始化brand和year
    public Car(String b, int y) {
        brand = b;
        year = y;
    }
    
    public void display() {
        System.out.println("Brand: " + brand + ", Year: " + year);
    }
    
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", 2020); // 使用构造方法创建对象
        myCar.display(); // 输出：Brand: Toyota, Year: 2020
    }
}
  • 解释：Car类有一个构造方法Car(String b, int y)，它在创建对象时设置属性值。new Car("Toyota", 2020)调用构造方法。
5. 面向对象编程：封装、继承、多态

面向对象（OOP）是Java的核心，包括三大特性：封装、继承、多态。

  • 封装：隐藏内部细节，通过公共方法访问私有属性。使用private关键字。

    public class Student {
    private String name; // 私有属性
    private int age;
    
    // 公共方法（getter和setter）提供访问
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name; // this指当前对象
    }
    
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("Bob");
        System.out.println("Name: " + stu.getName()); // 输出：Name: Bob
    }
}

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

    // 父类
public class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

// 子类
public class Dog extends Animal {
    @Override // 重写父类方法
    public void sound() {
        System.out.println("狗叫：汪汪");
    }
    
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.sound(); // 输出：狗叫：汪汪
    }
}

  • 多态：同一方法在不同对象中有不同实现，通常通过继承和接口实现。

    public interface Shape {
    void draw(); // 接口方法
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制正方形");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();
        shape1.draw(); // 输出：绘制圆形
        shape2.draw(); // 输出：绘制正方形
    }
}
6. 数组操作：存储与遍历

数组是固定大小的集合，用于存储相同类型的数据。Java支持一维和多维数组。

  • 声明与初始化：

    int[] numbers = new int[3]; // 声明大小为3的数组
numbers[0] = 10; // 设置元素
numbers[1] = 20;
numbers[2] = 30;

// 简化初始化
int[] arr = {1, 2, 3, 4, 5};

  • 遍历数组：使用for循环或增强for循环。

    // 普通for循环
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}
// 输出：1 2 3 4 5

// 增强for循环（for-each）
for (int num : arr) {
    System.out.print(num + " ");
}
// 输出：1 2 3 4 5

  • 多维数组：如二维数组。

    int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(matrix[0][1]); // 输出：2
7. 常用类使用：字符串与工具类

Java提供了丰富的类库，简化常见操作。

  • String类：用于字符串操作。

    String str = "Java";
System.out.println(str.length()); // 输出：4（长度）
System.out.println(str.substring(1, 3)); // 输出：av（子字符串）
System.out.println(str.toUpperCase()); // 输出：JAVA（大写）

  • Math类：数学计算。

    double result = Math.sqrt(16); // 平方根
System.out.println(result); // 输出：4.0
int max = Math.max(10, 20); // 最大值
System.out.println(max); // 输出：20

  • Scanner类：读取用户输入。

    import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入姓名：");
        String name = scanner.nextLine(); // 读取一行输入
        System.out.println("你好，" + name);
        scanner.close(); // 关闭扫描器
    }
}
8. 异常处理：捕获与处理错误

异常是程序运行时发生的错误，Java使用try-catch-finally机制处理。

  • 示例：
    public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); // 尝试访问不存在的索引
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界异常：" + e.getMessage()); // 捕获异常
        } finally {
            System.out.println("无论是否异常，都会执行finally块");
        }
    }
}
// 输出：数组越界异常：Index 3 out of bounds for length 3
//       无论是否异常，都会执行finally块
  • 自定义异常：可以创建自己的异常类。
    public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

public class Test {
    public static void checkAge(int age) throws MyException {
        if (age < 18) {
            throw new MyException("年龄太小");
        }
    }
    
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (MyException e) {
            System.out.println(e.getMessage()); // 输出：年龄太小
        }
    }
}
9. 集合框架：存储与操作数据

集合用于存储一组对象，Java提供了List, Set, Map等接口和实现类。

  • List：有序集合，可重复元素。

    import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Apple"); // 允许重复
        System.out.println(fruits); // 输出：[Apple, Banana, Apple]
        System.out.println(fruits.get(1)); // 输出：Banana
    }
}

  • Set：无序集合，无重复元素。

    import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("A");
        set.add("B");
        set.add("A"); // 重复，不会被添加
        System.out.println(set); // 输出：[A, B]
    }
}

  • Map：键值对集合。

    import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 90);
        scores.put("Bob", 85);
        System.out.println(scores.get("Alice")); // 输出：90
    }
}
10. IO流：文件读写操作

IO（输入输出）流用于处理数据流，如读写文件。

  • 文件读取：使用FileReader和BufferedReader。

    import java.io.BufferedReader;
import java.io.FileReader;

public class ReadFile {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  • 文件写入：使用FileWriter。

    import java.io.FileWriter;

public class WriteFile {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("output.txt")) {
            writer.write("Hello, Java IO!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
11. 多线程：并发执行

多线程允许程序同时执行多个任务，提高效率。Java通过Thread类或Runnable接口实现。

  • 继承Thread类：

    public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程运行: " + i);
        }
    }
    
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}
// 输出：线程运行: 0 到 4

  • 实现Runnable接口：更灵活。

    public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable线程运行");
    }
    
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableDemo());
        thread.start();
    }
}

  • 线程同步：避免冲突，使用synchronized。

    public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

public class TestSync {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Count: " + counter.getCount()); // 输出：2000（无冲突）
    }
}
12. 反射机制：动态操作类

反射允许在运行时获取类信息、调用方法或修改属性，用于框架开发。

  • 示例：
    import java.lang.reflect.Method;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 获取Class对象
        Class<?> clazz = Class.forName("java.lang.String");
        
        // 获取方法
        Method method = clazz.getMethod("length");
        
        // 创建对象并调用方法
        String str = "Reflection";
        int length = (int) method.invoke(str);
        System.out.println("字符串长度: " + length); // 输出：10
    }
}
13. 注解：元数据标记

注解（Annotation）用于提供元数据，如标记方法或类。Java内置了@Override、@Deprecated等，也可以自定义。

  • 内置注解：

    public class AnnotationExample {
    @Override // 标记重写方法
    public String toString() {
        return "注解示例";
    }
    
    @Deprecated // 标记过时方法
    public void oldMethod() {
        System.out.println("过时方法");
    }
    
    public static void main(String[] args) {
        new AnnotationExample().oldMethod(); // 编译警告：方法已过时
    }
}

  • 自定义注解：

    import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME) // 注解保留到运行时
@Target(ElementType.METHOD) // 用于方法
public @interface MyAnnotation {
    String value() default "默认值";
}

public class UseAnnotation {
    @MyAnnotation(value = "自定义注解")
    public void myMethod() {
        System.out.println("方法执行");
    }
    
    public static void main(String[] args) throws Exception {
        UseAnnotation obj = new UseAnnotation();
        Method method = obj.getClass().getMethod("myMethod");
        MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
        System.out.println("注解值: " + annotation.value()); // 输出：自定义注解
        obj.myMethod(); // 输出：方法执行
    }
}
总结

恭喜你完成了Java基础的学习之旅！我们从基础知识、数据类型、流程控制到面向对象、异常处理、多线程等核心概念，一步步用代码示例讲解。记住，编程需要实践，多写代码、多调试是关键。Java的世界广阔，后续可以深入学习框架如Spring、数据库操作等。如果你有任何问题，欢迎留言讨论！加油，未来的Java开发者！

# java # 开发语言
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

深度 | Claude 11 天「验完」费马大定理：AI 没证明新数学，但把验算工业化了一脚

avatar AI编程社区
cover

状态丢失排障：Claude 持久记忆的跨会话局限与知芽 Notebook Skill 单元记忆如何沉淀可复用知识资产

avatar AI编程社区
cover

vs code 下载安装 以及 如何配置 claude code 和codex

avatar AI编程社区