Java教程：从入门到初级实战

本文提供了全面的Java教程，涵盖了从环境搭建到面向对象编程等各个方面的内容。详细讲解了Java的基本语法、流程控制语句、异常处理和多线程等核心概念。通过丰富的示例代码，帮助读者快速掌握Java编程技能。

Java简介与环境搭建

Java语言概述

Java 是一种广泛使用的、面向对象的高级编程语言。它由James Gosling在Sun Microsystems开发，最初是为消费电子产品（如电视机顶盒）设计的，后来因其跨平台特性而迅速成为Web开发、桌面应用程序开发和移动应用开发的重要语言。Java的最大特点是“一次编写，到处运行”（Write Once, Run Anywhere），这主要得益于Java虚拟机（Java Virtual Machine, JVM）的支持。

Java语言具有以下特点：

1. 面向对象：Java是一种完全的面向对象语言，支持封装、继承和多态等特性。
2. 平台无关性：编写的Java程序可以在任何安装了Java虚拟机的设备上运行。
3. 自动内存管理：通过垃圾回收机制自动回收不再使用的内存。
4. 丰富的类库：Java提供了大量的标准库，可以方便地进行文件操作、网络编程等。

Java语言适用于开发各种类型的应用程序，包括桌面应用、Web应用、移动应用（如Android应用）等。

开发工具与环境配置

安装JDK

为了开始编写Java程序，你需要安装Java开发工具包（JDK）。最新版本的JDK可以在Oracle官方网站或OpenJDK社区下载。以下是安装步骤：

1. 访问Oracle官方网站或下载OpenJDK：

   • Oracle JDK：https://www.oracle.com/java/technologies/javase-jdk18-downloads.html
   • OpenJDK：https://openjdk.java.net/install/

2. 下载并安装JDK。根据操作系统选择相应的安装包，按照安装向导完成安装过程。

3. 配置环境变量。安装完成后，需要配置环境变量以确保系统能够找到Java的可执行文件。具体步骤如下：

   • Windows：打开“环境变量”设置窗口，新建或编辑JAVA_HOME变量为JDK安装路径，并将%JAVA_HOME%\bin添加到Path变量中。
   • macOS/Linux：编辑~/.bashrc或~/.zshrc文件，添加以下内容：

     export JAVA_HOME=/path/to/jdk
     export PATH=$JAVA_HOME/bin:$PATH

4. 验证安装。在命令行窗口中输入以下命令检查安装是否成功：

   java -version

   此命令会显示安装的Java版本信息。如果安装成功，将会输出Java版本号等信息。

安装IDE

集成开发环境（IDE）是编写Java程序的常用工具，提供了代码编辑、调试、运行等功能。常用的Java IDE有IntelliJ IDEA、Eclipse和NetBeans。以下是使用IntelliJ IDEA安装和配置的步骤：

1. 访问IntelliJ IDEA官方网站下载安装包：
   • IntelliJ IDEA：https://www.jetbrains.com/idea/download/
2. 安装IntelliJ IDEA，根据提示完成安装过程。
3. 打开IntelliJ IDEA，选择“Import Project”或“New Project”创建新项目。
4. 如果是新项目，选择合适的项目类型，例如Java Application，然后选择项目保存的位置。点击“Next”继续，直到完成配置。
5. 配置项目SDK。在项目创建后，打开“File”菜单 -> “Project Structure”，在“Project”选项卡中指定JDK版本。确保在“Modules”选项卡中也正确配置了JDK。点击“Apply”保存设置。
6. 完成配置后，可以开始编写Java代码。

第一个Java程序

创建并运行一个简单的Java程序是开始学习Java的第一步。以下是如何创建第一个Java程序的步骤：

1. 创建一个新的Java类文件。在IntelliJ IDEA中，可以使用快捷键Ctrl + Shift + T创建一个新的Java类。
2. 在类文件中定义一个公共类（public class），并指定类名。类名应与文件名相同，例如HelloWorld.java：

   public class HelloWorld {
   }

3. 在类中定义一个主方法（main method），这是Java程序的入口点：

   public class HelloWorld {
      public static void main(String[] args) {
          // 在这里编写代码
      }
   }

4. 在主方法中编写输出语句，打印出“Hello, World!”：

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

5. 保存文件，然后在IntelliJ IDEA中运行程序。可以通过点击工具栏上的运行按钮（绿色三角形）或者使用快捷键Ctrl + Shift + F10来运行程序。
6. 查看命令行窗口中的输出结果，应显示“Hello, World!”。

现在，你已经成功创建并运行了一个简单的Java程序。这标志着你正式踏上了Java编程之旅。

Java基础语法

数据类型与变量

数据类型

在Java中，数据类型分为两大类：基本数据类型和引用数据类型。基本数据类型包括byte、short、int、long、float、double、boolean和char。引用数据类型包括类、接口和数组等。

以下是基本数据类型及其描述：

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

下面是一些基本数据类型的示例代码：

// 定义变量
byte num1 = 127;
short num2 = 32767;
int num3 = 2147483647;
long num4 = 9223372036854775807L;
float num5 = 3.14f;
double num6 = 3.14159265359;
boolean flag = true;
char ch = 'A';

// 打印变量
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println(num5);
System.out.println(num6);
System.out.println(flag);
System.out.println(ch);

变量

变量是用于存储数据的容器。在Java中，变量必须先声明类型，然后进行初始化。以下是一些变量声明的示例：

int age = 25;  // 整型变量
float price = 19.99f;  // 浮点型变量
boolean isStudent = true;  // 布尔型变量
char grade = 'A';  // 字符型变量
String name = "Alice";  // 引用类型变量

通过变量，你可以执行各种运算，也可以更改其值。例如：

int x = 10;
int y = 20;
x = x + y;  // x的值现在是30
y = y - x;  // y的值现在是-10

运算符与表达式

在Java中，运算符用于执行数学或逻辑运算，表达式则是包含一个或多个运算符的操作。

常用运算符

• 算术运算符：+、-、*、/、%。
• 赋值运算符：=、+=、-=、*=、/=。
• 关系运算符：==、!=、>、>=、<、<=。
• 逻辑运算符：&&、||、!。
• 位运算符：&、|、^、~、<<、>>。

表达式

表达式由一个或多个操作数和运算符组成。下面是一些表达式的示例：

int a = 10;
int b = 20;
int sum = a + b;  // sum等于30
int difference = a - b;  // difference等于-10
int product = a * b;  // product等于200
int division = a / b;  // division等于0 (整除)
int remainder = a % b;  // remainder等于10
boolean isEqual = a == b;  // isEqual等于false
boolean isNotEqual = a != b;  // isNotEqual等于true
boolean isGreaterThan = a > b;  // isGreaterThan等于false
boolean isLessThan = a < b;  // isLessThan等于true

流程控制语句

流程控制语句用于控制程序的执行流程。Java提供了多种流程控制语句，包括条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue）。

条件语句

if语句用于基于条件判断执行代码块。if-else用于在条件为真时执行一个代码块，在条件为假时执行另一个代码块。

int number = 10;
if (number > 0) {
    System.out.println("Number is positive.");
} else {
    System.out.println("Number is non-positive.");
}

循环语句

for循环用于重复执行一段代码，直到循环条件为假：

for (int i = 0; i < 5; i++) {
    System.out.println("Iteration " + i);
}

while循环在条件为真时重复执行代码块：

int count = 0;
while (count < 5) {
    System.out.println("Count is " + count);
    count++;
}

do-while循环会先执行一次循环体，然后再检查循环条件：

int count = 0;
do {
    System.out.println("Count is " + count);
    count++;
} while (count < 5);

跳转语句

break语句用于终止循环：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

continue语句用于跳过循环体中的某些代码并继续下一次循环：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;
    }
    System.out.println(i);
}

Java面向对象编程

类与对象

面向对象编程的核心概念是“类”和“对象”。类是对象的蓝图，对象是类的实例。类定义了对象的属性和行为，而对象则是具体的操作实例。

定义类

在Java中，定义一个类需要使用class关键字：

public class Person {
    // 成员变量
    String name;
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

创建对象

使用类定义创建对象：

public class Main {
    public static void main(String[] args) {
        // 创建Person对象
        Person person = new Person("Alice", 25);

        // 调用成员方法
        person.displayInfo();
    }
}

访问修饰符

Java提供了四种访问修饰符：public、protected、private和默认访问修饰符（无修饰符，即package-private）：

• public：任何地方都可以访问。
• protected：同包或子类可以访问。
• private：只有在同一类中的方法和构造方法可以访问。
• 默认访问修饰符（package-private）：同包中的类可以访问。

public class TestAccessModifiers {
    public String publicVar = "public";
    protected String protectedVar = "protected";
    String defaultVar = "default";
    private String privateVar = "private";

    public static void main(String[] args) {
        TestAccessModifiers obj = new TestAccessModifiers();

        System.out.println(obj.publicVar);  // 输出"public"
        System.out.println(obj.protectedVar);  // 输出"protected"
        System.out.println(obj.defaultVar);  // 输出"default"
        // System.out.println(obj.privateVar);  // 这将导致编译错误
    }
}

继承与多态

继承

继承允许一个类继承另一个类的属性和方法。通过继承，可以重用代码，减少重复性。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 调用从Animal继承的方法
        dog.bark();  // 调用Dog自己的方法
    }
}

多态

多态是指允许不同类的对象通过父类的引用进行统一样式调用的方法。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }

    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();  // 输出"Animal is eating"

        animal = new Dog();
        animal.eat();  // 输出"Dog is eating"
    }
}

接口与抽象类

接口

接口是一种契约，规定了类必须实现的方法，但不提供具体实现。接口支持多继承。

public interface Movable {
    void move();
}

public class Car implements Movable {
    @Override
    public void move() {
        System.out.println("Car is moving");
    }
}

public class Main {
    public static void main(String[] args) {
        Movable car = new Car();
        car.move();  // 输出"Car is moving"
    }
}

抽象类

抽象类是包含抽象方法的类，这些方法不能被实例化。抽象类可以包含成员变量和方法，也可以包含非抽象方法。

public abstract class Vehicle {
    public void start() {
        System.out.println("Vehicle is starting");
    }

    public abstract void move();
}

public class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Car is moving");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        car.start();  // 输出"Vehicle is starting"
        car.move();  // 输出"Car is moving"
    }
}

Java常用类库

String与StringBuffer

String类

String类用于表示不可变的字符序列。一旦创建，字符串内容就不能更改。

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";

        String concat = str1 + " " + str2;  // "Hello World"
        System.out.println(concat);

        String upperCase = str1.toUpperCase();  // "HELLO"
        System.out.println(upperCase);

        boolean startsWithH = str1.startsWith("H");  // 输出"true"
        System.out.println(startsWithH);
    }
}

StringBuffer类

StringBuffer类用于可变的字符序列。可以修改字符串内容，线程安全。

public class StringBufferExample {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("Hello");
        buffer.append(" World");  // "Hello World"
        System.out.println(buffer.toString());

        buffer.insert(6, "-");  // "Hello- World"
        System.out.println(buffer.toString());

        buffer.setCharAt(0, 'h');  // "hHello- World"
        System.out.println(buffer.toString());

        buffer.reverse();  // "dlroW -olleh"
        System.out.println(buffer.toString());
    }
}

数组与集合框架

数组

数组是一种简单的数据结构，用于存储一组相同类型的数据。

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

集合框架

集合框架提供了一组用于存储和操作对象的接口和实现类。常见的集合接口有List、Set和Map。

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

public class CollectionExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("First");
        list.add("Second");
        list.add("Third");

        for (String item : list) {
            System.out.println(item);
        }

        // 添加新元素
        list.add("Fourth");
        System.out.println(list.size());  // 输出"4"

        // 删除元素
        list.remove("Second");
        System.out.println(list.size());  // 输出"3"

        // 检查是否存在
        boolean contains = list.contains("First");
        System.out.println(contains);  // 输出"true"
    }
}

输入输出流

Java提供了丰富的输入输出流类，用于处理数据的读写操作。

文件读写

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class FileReadWriteExample {
    public static void main(String[] args) {
        String content = "Hello, this is a file content.";
        try {
            // 写入文件
            File file = new File("example.txt");
            FileWriter writer = new FileWriter(file);
            writer.write(content);
            writer.close();

            // 读取文件
            String readContent = new String(Files.readAllBytes(Paths.get("example.txt")));
            System.out.println(readContent);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象序列化

序列化是指将对象的状态写入文件的过程。反序列化则是将写入文件的对象状态恢复为对象。

import java.io.*;

public class SerializationExample {
    public static void main(String[] args) {
        try {
            // 序列化对象
            Student student = new Student("John", 20);
            FileOutputStream fileOut = new FileOutputStream("student.ser");
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            out.writeObject(student);
            out.close();
            fileOut.close();

            // 反序列化对象
            FileInputStream fileIn = new FileInputStream("student.ser");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            Student deserializedStudent = (Student) in.readObject();
            in.close();
            fileIn.close();

            System.out.println(deserializedStudent.name + ", " + deserializedStudent.age);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Java异常处理与多线程

异常处理机制

Java的异常处理机制通过try-catch-finally块来管理异常。try块包含可能抛出异常的代码，catch块捕获并处理异常，finally块在try和catch块执行后执行（无论是否抛出异常）。

基本语法

public class ExceptionExample {
    public static void main(String[] args) {
        // try块
        try {
            int divide = 10 / 0;  // 会抛出ArithmeticException
        } catch (ArithmeticException e) {
            // 捕获并处理异常
            System.out.println("ArithmeticException caught: " + e.getMessage());
        } finally {
            // finally块
            System.out.println("Finally block executed.");
        }
    }
}

异常层次结构

Java异常分为两类：检查异常（编译时异常）和运行时异常（未检查异常）。检查异常需要显式处理，而运行时异常不需要显式处理。

import java.io.IOException;

public class ExceptionHierarchyExample {
    public static void main(String[] args) {
        try {
            throw new IOException();  // IOException是检查异常
        } catch (IOException e) {
            System.out.println("IOException caught: " + e.getMessage());
        }

        try {
            throw new RuntimeException();  // RuntimeException是运行时异常
        } catch (RuntimeException e) {
            System.out.println("RuntimeException caught: " + e.getMessage());
        }
    }
}

多线程基础

Java程序可以通过创建线程来实现并发执行。线程是进程中一个独立的、并发的执行单元。

创建线程

Java提供了两种创建线程的方法：继承Thread类或实现Runnable接口。

public class ThreadExample extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }

    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();
        thread.start();
    }
}

public class RunnableExample implements Runnable {
    public void run() {
        System.out.println("Runnable is running.");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableExample());
        thread.start();
    }
}

线程同步

同步机制用于确保多个线程在访问共享资源时不会产生冲突。Java提供了多种同步机制，包括synchronized关键字和Lock接口。

使用synchronized关键字

synchronized关键字可以用来同步方法或代码块。

public class SynchronizedExample {
    public static void main(String[] args) {
        SharedResource shared = new SharedResource();
        Thread thread1 = new Thread(() -> {
            shared.increment();
        });

        Thread thread2 = new Thread(() -> {
            shared.decrement();
        });

        thread1.start();
        thread2.start();
    }
}

class SharedResource {
    private int count = 0;

    public synchronized void increment() {
        count++;
        System.out.println("Incremented: " + count);
    }

    public synchronized void decrement() {
        count--;
        System.out.println("Decremented: " + count);
    }
}

使用Lock接口

Lock接口提供了比synchronized更灵活的同步机制，例如可以尝试获取锁、设置超时等待等。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    public static void main(String[] args) {
        SharedResource shared = new SharedResource();
        Thread thread1 = new Thread(() -> {
            shared.increment();
        });

        Thread thread2 = new Thread(() -> {
            shared.decrement();
        });

        thread1.start();
        thread2.start();
    }
}

class SharedResource {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println("Incremented: " + count);
        } finally {
            lock.unlock();
        }
    }

    public void decrement() {
        lock.lock();
        try {
            count--;
            System.out.println("Decremented: " + count);
        } finally {
            lock.unlock();
        }
    }
}

通过以上内容，你可以全面了解Java编程的基础知识和高级特性。希望这些示例和解释能帮助你更好地掌握Java编程。继续学习和实践，你将能够开发出更复杂和高效的Java应用程序。