Java编程入门指南 - 《Java基础教程》 - 严富坤的知识库专栏(yanfukun.com)

Java简介
- 什么是Java？
- Java 的主要特点
Java开发环境搭建
- 安装 Java Development Kit (JDK)
- 安装集成开发环境（IDE）
Java基本语法
面向对象编程（OOP）
常用类库
异常处理
- 异常的种类
- 异常处理机制
多线程编程
- 创建线程
- 线程通信
文件 I/O 操作
- 文件读取
- 文件写入
网络编程
- 使用 URL 类进行网络连接
- 使用 Socket 类进行网络通信
数据库操作
- 连接数据库
- 执行 SQL 语句
总结

Java 是一种功能强大且广泛使用的编程语言，适用于开发各种应用程序。从桌面应用到大型企业系统，Java 的应用场景非常广泛。本篇文章将为您提供一个全面的 Java 编程入门指南，涵盖 Java 的基础概念、环境搭建、基本语法、面向对象编程、常用类库、异常处理、多线程编程、文件 I/O 操作、网络编程以及数据库操作等内容。希望通过这篇文章，您能够掌握 Java 编程的基础知识，并具备独立开发 Java 应用程序的能力。

Java简介

什么是Java？

Java 是一种由 Sun Microsystems（现为 Oracle Corporation）开发的面向对象的编程语言和计算平台。它最早于 1995 年发布，并迅速成为最流行的编程语言之一。Java 的设计目标是”一次编写，到处运行”（Write Once, Run Anywhere, WORA），通过 Java 虚拟机（JVM）实现跨平台运行。

Java 的主要特点

跨平台：Java 程序可以在安装了 JVM 的任何操作系统上运行。
面向对象：Java 是一种纯面向对象的语言，支持封装、继承、多态等特性。
简单易学：Java 的语法简洁且接近自然语言，易于学习和使用。
安全性：Java 提供了一系列安全机制，确保代码在不受信任的环境中安全运行。
多线程：Java 内置了对多线程编程的支持，适合开发高并发应用。
强大的标准库：Java 提供了丰富的标准库，涵盖了常见的编程任务。

Java开发环境搭建

在开始编写 Java 程序之前，首先需要搭建 Java 开发环境。以下是搭建 Java 开发环境的步骤：

安装 Java Development Kit (JDK)

JDK 是用于开发 Java 应用程序的工具包，包含了 Java 编译器、运行时环境（JRE）、Java API 库等。您可以从 Oracle 官方网站下载最新版本的 JDK。

下载 JDK：
- 访问 Oracle JDK 下载页面。
- 选择适合您操作系统的版本进行下载。
安装 JDK：
- 根据操作系统的提示进行安装。
- 安装完成后，配置环境变量，将 JDK 的 bin 目录添加到系统的 PATH 中。

安装集成开发环境（IDE）

虽然您可以使用任何文本编辑器编写 Java 代码，但使用集成开发环境（IDE）可以显著提高开发效率。以下是几种常用的 Java IDE：

Eclipse：一个流行的开源 IDE，功能强大且扩展性好。
- 访问 Eclipse 官方网站下载并安装适合您操作系统的版本。
IntelliJ IDEA：一个广受欢迎的商业 IDE，功能强大且智能化程度高。
- 访问 IntelliJ IDEA 官方网站下载并安装适合您操作系统的版本。
NetBeans：一个开源 IDE，特别适合 Java 开发。
- 访问 NetBeans 官方网站下载并安装适合您操作系统的版本。

Java基本语法

在开始编写 Java 程序之前，首先需要了解 Java 的基本语法。以下是 Java 编程的基础知识：

Hello World 程序

让我们从一个简单的 Hello World 程序开始：

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

解释：

public class HelloWorld：定义了一个名为 HelloWorld 的公有类。
public static void main(String[] args)：定义了主方法，这是 Java 程序的入口点。
System.out.println("Hello, World!");：向控制台输出 “Hello, World!”。

数据类型

Java 提供了多种数据类型，包括基本数据类型和引用数据类型。

基本数据类型：
- 整型：byte、short、int、long
- 浮点型：float、double
- 字符型：char
- 布尔型：boolean
引用数据类型：
- 类：例如 String、Array
- 接口
- 数组

示例：

int age = 25;
double salary = 45000.50;
char grade = 'A';
boolean isJavaFun = true;

变量与常量

变量：在 Java 中，变量用于存储数据。变量必须先声明后使用。

示例：
```
int number;
number = 10;
```
常量：常量的值在程序运行过程中不会改变。使用 final 关键字声明常量。

示例：
```
final int MAX_VALUE = 100;
```

运算符

Java 提供了多种运算符，包括算术运算符、关系运算符、逻辑运算符和位运算符。

算术运算符：+、-、*、/、%

示例：

int sum = 10 + 5;
int difference = 10 - 5;
int product = 10 * 5;
int quotient = 10 / 5;
int remainder = 10 % 5;

关系运算符：==、!=、>、<、>=、<=

示例：

boolean isEqual = (10 == 5);
boolean isNotEqual = (10 != 5);

逻辑运算符：&&、||、!

示例：
```
boolean result = (10 > 5) && (5 < 3);
```

位运算符：&、|、^、~、<<、>>、>>>

示例：

int bitwiseAnd = 5 & 3;
int bitwiseOr = 5 | 3;

控制语句

Java 提供了多种控制语句，用于控制程序的执行流程。

条件语句：if、else if、else、switch

示例：

int score = 85;
if (score >= 90) {
    System.out.println("Grade: A");
} else if (score >= 80) {
    System.out.println("Grade: B");
} else {
    System.out.println("Grade: C");
}
int day = 3;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Invalid day");
        break;
}

循环语句：for、while、do-while

示例：

for (int i = 0; i < 5; i++) {
    System.out.println("i: " + i);
}
int j = 0;
while (j < 5) {
    System.out.println("j: " + j);
    j++;
}
int k = 0;
do {
    System.out.println("k: " + k);
    k++;
} while (k < 5);

数组

数组是用于存储多个同类型数据的容器。

声明和初始化数组：

int[] numbers = new int[5];
int[] moreNumbers = {1, 2, 3, 4, 5};

访问数组元素：

numbers[0] = 10;
int firstNumber = moreNumbers[0];

遍历数组：

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

面向对象编程（OOP）

Java 是一种面向对象的编程语言，面向对象编程（OOP）是其核心思想。以下是 Java 中面向对象编程的基础知识：

类与对象

类：类是对象的

模板，定义了对象的属性和行为。

示例：

   public class Person {
       String name;
       int age;
       void sayHello() {
           System.out.println("Hello, my name is " + name);
       }
   }

对象：对象是类的实例，通过类创建。

示例：

Person person = new Person();
person.name = "John";
person.age = 30;
person.sayHello();

构造方法

构造方法用于在创建对象时初始化对象的状态。

示例：

public class Person {
    String name;
    int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}
// 使用构造方法创建对象
Person person = new Person("John", 30);
person.sayHello();

继承

继承是面向对象编程的核心特性之一，通过继承，一个类可以继承另一个类的属性和方法。

示例：

// 父类
public class Animal {
    void eat() {
        System.out.println("This animal is eating.");
    }
}
// 子类
public class Dog extends Animal {
    void bark() {
        System.out.println("The dog is barking.");
    }
}
// 使用继承创建对象
Dog dog = new Dog();
dog.eat();
dog.bark();

多态

多态是指同一操作可以作用于不同的对象，并产生不同的结果。通过方法重载和方法重写实现多态。

方法重载：同一类中，多个方法可以有相同的名字，但参数不同。

示例：

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

方法重写：子类可以重写父类的方法，以提供特定的实现。

示例：

public class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound.");
    }
}
public class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}
// 使用多态
Animal animal = new Cat();
animal.makeSound();  // 输出 "Meow"

抽象类与接口

抽象类：抽象类是不能实例化的类，可以包含抽象方法（没有方法体）和具体方法。

示例：

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

接口：接口是完全抽象的类，定义了类必须实现的方法。一个类可以实现多个接口。

示例：

public interface Animal {
    void eat();
    void sleep();
}
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("The dog is eating.");
    }
    @Override
    public void sleep() {
        System.out.println("The dog is sleeping.");
    }
}

常用类库

Java 提供了丰富的类库，以下是一些常用的类库：

java.lang

java.lang 包包含了 Java 语言的核心类，如基础数据类型的包装类、String 类、Math 类等。

String 类：用于处理字符串。

示例：

String message = "Hello, World!";
int length = message.length();
String upperCaseMessage = message.toUpperCase();

Math 类：提供了常用的数学运算方法。

示例：

double result = Math.sqrt(16);
int max = Math.max(10, 20);

java.util

java.util 包包含了 Java 的集合框架、日期时间类、随机数生成器等。

集合框架：

List 接口及其实现类 ArrayList：

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");

Set 接口及其实现类 HashSet：

Set<String> set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("cherry");

Map 接口及其实现类 HashMap：

Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.put("cherry", 3);

日期时间类：

Date 类：
```
Date date = new Date();
```

Calendar 类：

Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);

java.io

java.io 包提供了系统输入输出的功能，包括文件操作、数据流等。

文件操作：

创建文件：

File file = new File("example.txt");
if (file.createNewFile()) {
    System.out.println("File created: " + file.getName());
} else {
    System.out.println("File already exists.");
}

写入文件：

FileWriter writer = new FileWriter("example.txt");
writer.write("Hello, World!");
writer.close();

读取文件：

FileReader reader = new FileReader("example.txt");
int data;
while ((data = reader.read()) != -1) {
    System.out.print((char) data);
}
reader.close();

java.nio

java.nio 包提供了新的 I/O 功能，包括缓冲区、通道等。

缓冲区：

ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello, World!".getBytes());
buffer.flip();

通道：

FileChannel channel = new FileOutputStream("example.txt").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello, World!".getBytes());
buffer.flip();
channel.write(buffer);
channel.close();

异常处理

异常是程序运行过程中发生的错误，Java 提供了异常处理机制，以确保程序能够平稳地处理错误。

异常的种类

受检异常（Checked Exception）：必须在代码中进行处理的异常，例如 IOException。
运行时异常（Runtime Exception）：不强制处理的异常，例如 NullPointerException。
错误（Error）：通常由 JVM 抛出，表示严重错误，例如 OutOfMemoryError。

异常处理机制

try-catch 语句：

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Caught an arithmetic exception: " + e.getMessage());
}

try-catch-finally 语句：

try {
    FileReader reader = new FileReader("example.txt");
} catch (FileNotFoundException e) {
    System.out.println("File not found: " + e.getMessage());
} finally {
    System.out.println("This block is always executed.");
}

throws 关键字：

public void readFile(String fileName) throws IOException {
    FileReader reader = new FileReader(fileName);
}

自定义异常：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}
public class Test {
    public void testMethod() throws CustomException {
        throw new CustomException("This is a custom exception.");
    }
}

多线程编程

多线程编程是指在一个程序中同时执行多个线程。Java 提供了丰富的多线程编程支持，使得开发高并发应用变得更加容易。

创建线程

通过继承 Thread 类：

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
MyThread thread = new MyThread();
thread.start();

通过实现 Runnable 接口：

```java public class MyRunnable implements Runnable {
```
public void run() {
    System.out.println("Thread is running.");
}
```
}

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

();


#### 线程同步
线程同步是指在多线程环境下控制多个线程对共享资源的访问。Java 提供了多种同步机制，如 `synchronized` 关键字和 `Lock` 接口。
1. **synchronized 关键字**：
   ```java
   public class Counter {
       private int count = 0;
       public synchronized void increment() {
           count++;
       }
       public int getCount() {
           return count;
       }
   }

Lock 接口：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public int getCount() {
        return count;
    }
}

线程通信

线程通信是指在多线程环境下，线程之间相互发送信号或数据。Java 提供了多种线程通信机制，如 wait()、notify() 和 notifyAll() 方法。

wait()、notify() 和 notifyAll() 方法：

public class Message {
    private String message;
    public synchronized void setMessage(String message) {
        this.message = message;
        notify();
    }
    public synchronized String getMessage() {
        while (message == null) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return message;
    }
}
public class Producer extends Thread {
    private final Message message;
    public Producer(Message message) {
        this.message = message;
    }
    public void run() {
        message.setMessage("Hello, World!");
    }
}
public class Consumer extends Thread {
    private final Message message;
    public Consumer(Message message) {
        this.message = message;
    }
    public void run() {
        System.out.println("Message received: " + message.getMessage());
    }
}
public class Test {
    public static void main(String[] args) {
        Message message = new Message();
        Producer producer = new Producer(message);
        Consumer consumer = new Consumer(message);
        producer.start();
        consumer.start();
    }
}

文件 I/O 操作

文件 I/O 操作是指对文件进行读写操作。Java 提供了多种文件 I/O 类，允许我们方便地进行文件操作。

文件读取

使用 FileReader：

try {
    FileReader reader = new FileReader("example.txt");
    int data;
    while ((data = reader.read()) != -1) {
        System.out.print((char) data);
    }
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}

使用 BufferedReader：

try {
    BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}

文件写入

使用 FileWriter：

try {
    FileWriter writer = new FileWriter("example.txt");
    writer.write("Hello, World!");
    writer.close();
} catch (IOException e) {
    e.printStackTrace();
}

使用 BufferedWriter：

try {
    BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"));
    writer.write("Hello, World!");
    writer.newLine();
    writer.write("This is Java file I/O.");
    writer.close();
} catch (IOException e) {
    e.printStackTrace();
}

网络编程

网络编程是指通过网络进行数据传输。Java 提供了丰富的网络编程类库，允许我们方便地进行网络编程。

使用 URL 类进行网络连接

try {
    URL url = new URL("http://example.com");
    BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}

使用 Socket 类进行网络通信

客户端代码：

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
            writer.println("Hello, Server!");
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("Server response: " + reader.readLine());
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器端代码：

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Server started...");
            Socket socket = serverSocket.accept();
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("Client message: " + reader.readLine());
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
            writer.println("Hello, Client!");
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据库操作

Java 提供了 JDBC（Java Database Connectivity）API，用于连接和操作数据库。

连接数据库

加载数据库驱动：

try {
    Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

建立连接：

String url = "jdbc:mysql://localhost:3306/testdb";
String username = "root";
String password = "password";
try {
    Connection connection = DriverManager.getConnection(url, username, password);
    System.out.println("Connected to the database.");
} catch (SQLException e) {
    e.printStackTrace();
}

执行 SQL 语句

创建表：

try {
    Statement statement = connection.createStatement();
    String sql = "CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(50), email VARCHAR(50))";
    statement.executeUpdate(sql);
    System.out.println("Table created.");
} catch (SQLException e) {
    e.printStackTrace();
}

插入数据：

try {
    String sql = "INSERT INTO users (id, name, email) VALUES (?, ?, ?)";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    preparedStatement.setInt(1, 1);
    preparedStatement.setString(2, "John Doe");
    preparedStatement.setString(3, "john.doe@example.com");
    preparedStatement.executeUpdate();
    System.out.println("Data inserted.");
} catch (SQLException e) {
    e.printStackTrace();
}

查询数据：

try {
    String sql = "SELECT * FROM users";
    Statement statement = connection.createStatement();
    ResultSet resultSet = statement.executeQuery(sql);
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
    }
} catch (SQLException e) {
    e.printStackTrace();
}

更新数据：

try {
    String sql = "UPDATE users SET name = ? WHERE id = ?";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    preparedStatement.setString(1, "Jane Doe");
    preparedStatement.setInt(2, 1);
    preparedStatement.executeUpdate();
    System.out.println("Data updated.");
} catch (SQLException e) {
    e.printStackTrace();
}

删除数据：

try {
    String sql = "DELETE FROM users WHERE id = ?";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    preparedStatement.setInt(1, 1);
    preparedStatement.executeUpdate();
    System.out.println("Data deleted.");
} catch (SQLException e) {
    e.printStackTrace();
}

总结

Java 作为一种功能强大且广泛使用的编程语言，具备跨平台、面向对象、简单易学、安全性高、多线程支持强等特点。本文从 Java 的基本概念开始，逐步介绍了开发环境的搭建、基本语法、面向对象编程、常用类库、异常处理、多线程编程、文件 I/O 操作、网络编程以及数据库操作等内容。通过学习这些知识，您将掌握 Java 编程的基础，并能够独立开发各种应用程序。希望

本文能够为您的 Java 学习之旅提供有力的支持。