首页手记 Java主流技术教程：从入门到初级实战

Java主流技术教程：从入门到初级实战

标签：

Java

本文提供了全面的Java主流技术教程，涵盖了从基础知识到面向对象编程、数据结构与算法、网络编程、多线程与并发编程以及实战项目的详细介绍。文章内容丰富，适合初学者到中级开发者学习使用。通过本文，读者可以系统地掌握Java的核心技术和实际应用技巧。

Java主流技术教程：从入门到初级实战

1. Java基础入门

1.1 Java简介与安装配置

Java是一种广泛使用的编程语言，它具有平台无关性，可以在多种操作系统上运行。Java程序编译后生成字节码，可以在任何安装了Java虚拟机（JVM）的设备上运行。安装Java需要先到官方网站下载相应的版本，具体步骤如下：

访问Oracle官方网站下载Java开发工具包（JDK）。
根据操作系统选择对应的安装包，如Windows、macOS或Linux。
按照安装向导完成安装，并设置环境变量。设置环境变量需要修改系统变量PATH，确保JDK的bin目录被正确添加到PATH中。

1.2 Java开发环境搭建

Java开发环境的搭建步骤如下：

安装JDK后，需要选择合适的集成开发环境（IDE）。推荐使用IntelliJ IDEA或Eclipse。
如果选择IntelliJ IDEA，下载安装文件并按照向导安装。
打开IDE，创建一个新的Java项目。
配置项目依赖和构建工具（如Maven或Gradle）。

1.3 第一个Java程序

编写第一个Java程序，输出“Hello, World!”，步骤如下：

打开IDE，创建一个Java类，命名为HelloWorld。
在类中定义一个main方法，它是程序启动的入口点。
在main方法中调用System.out.println输出“Hello, World!”。

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

1.4 Java语法基础

Java语法包括变量声明、数据类型、运算符、流程控制语句等。以下是变量与类型的介绍：

变量声明与初始化：
变量在使用前必须声明类型和名称，并可选择初始化。

int age; // 声明一个整型变量
age = 25; // 初始化

数据类型：
Java的数据类型分为原始类型和引用类型。
- 原始类型：基本数据类型，如int, double, boolean等。
- 引用类型：如类、数组、接口等。
运算符：
包括算术运算符（+，-，*，/，%），比较运算符（==, !=, >, <, >=, <=），逻辑运算符（&&, ||, !）等。
流程控制语句：
包括if-else条件语句，switch语句，for，while，do-while循环语句。

int number = 5;
if (number > 10) {
    System.out.println("Number is greater than 10");
} else {
    System.out.println("Number is less than or equal to 10");
}

2. Java面向对象编程

2.1 类与对象

类是对象的蓝图，对象是类的实例。类定义了数据（字段）和行为（方法），而对象则是这些数据的具体实例。

定义类：
使用class关键字定义类，并可以包含字段和方法。

public class Person {
    String name;
    int age;

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

    public void setAge(int age) {
        this.age = age;
    }

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

创建对象：
使用new关键字创建对象实例，并可以调用方法。

Person person = new Person();
person.setName("John");
person.setAge(30);
person.displayInfo();

2.2 继承与多态

继承允许一个类继承另一个类的属性和方法。

定义继承：
使用extends关键字定义继承关系。

public class Student extends Person {
    String school;

    public void setSchool(String school) {
        this.school = school;
    }

    public void displayInfo() {
        super.displayInfo();
        System.out.println("School: " + school);
    }
}

多态：
多态允许子类对象被当作父类对象来使用。

Person person = new Student();
((Student)person).setSchool("ABC School");
person.displayInfo();

2.3 封装与抽象

封装是指将数据和方法封装在一起，隐藏内部复杂性，只暴露必要的方法。

封装：
使用private关键字保护字段，并提供公共方法来访问字段。

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

抽象：
抽象类和接口可以定义未实现的方法，强制子类实现。

public abstract class Animal {
    public abstract void makeSound();
}

public class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public interface Movable {
    void move();
}

public class Car implements Movable {
    public void move() {
        System.out.println("Moving");
    }
}

2.4 接口与异常处理

接口定义了一组方法，但不提供实现。异常处理可以捕获并处理程序中的错误。

接口：
使用interface关键字定义接口。

public interface Movable {
    void move();
}

public class Car implements Movable {
    public void move() {
        System.out.println("Moving");
    }
}

异常处理：
使用try-catch语句捕获并处理异常。

public class Example {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic error occurred: " + e.getMessage());
        }
    }
}

3. Java常用数据结构与算法

3.1 数组与集合框架

Java提供了多种数据结构，包括数组和集合框架。

数组：
数组是一个固定大小的元素列表。

int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;

集合框架：
Java集合框架提供了多种接口和实现类，如List, Set, Map等。

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

public class Example {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

3.2 常见排序算法

常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序等。

冒泡排序：

public class BubbleSort {
    public static void sort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        sort(arr);
        System.out.println("Sorted array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

插入排序：

public class InsertionSort {
    public static void sort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;

            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        sort(arr);
        System.out.println("Sorted array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

3.3 数据结构基础

常见的数据结构包括栈、队列、树等。

栈：
栈是一种后进先出（LIFO）的数据结构。

import java.util.Stack;

public class Example {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);

        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

队列：
队列是一种先进先出（FIFO）的数据结构。

import java.util.LinkedList;
import java.util.Queue;

public class Example {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(10);
        queue.add(20);
        queue.add(30);

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

树：
树是一种非线性数据结构，包含节点和边。

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class BinaryTree {
    public TreeNode root;

    public void add(int val) {
        root = addRecursive(root, val);
    }

    private TreeNode addRecursive(TreeNode current, int val) {
        if (current == null) {
            return new TreeNode(val);
        }

        if (val < current.val) {
            current.left = addRecursive(current.left, val);
        } else if (val > current.val) {
            current.right = addRecursive(current.right, val);
        }

        return current;
    }
}

public class Example {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        tree.add(50);
        tree.add(30);
        tree.add(70);
        tree.add(20);
        tree.add(40);
        tree.add(60);
        tree.add(80);
    }
}

4. Java网络编程入门

4.1 Socket编程基础

Socket编程允许程序在网络中进行通信。客户端和服务器之间使用TCP或UDP协议。

创建Socket：
客户端使用Socket类，服务器使用ServerSocket类。

import java.net.Socket;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String data = br.readLine();
            System.out.println("Data: " + data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ServerSocket：
服务器端代码接收客户端连接，并读取客户端发送的数据。

import java.net.ServerSocket;
import java.net.Socket;
import java.io.OutputStream;
import java.io.PrintWriter;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            Socket clientSocket = serverSocket.accept();
            OutputStream os = clientSocket.getOutputStream();
            PrintWriter out = new PrintWriter(os, true);
            out.println("Hello from server");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.2 HTTP协议简介

HTTP（超文本传输协议）用于客户端与服务器之间的数据传输。HTTP请求和响应分别包含请求行、头部和消息体。

HTTP请求：
从客户端发送到服务器的请求，包含请求行、头部和消息体。

import java.net.HttpURLConnection;
import java.net.URL;

public class HTTPClient {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            int responseCode = connection.getResponseCode();
            System.out.println("Response code: " + responseCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

HTTP响应：
从服务器返回给客户端的响应，包含状态行、头部和消息体。

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class HTTPServer {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://example.com");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.3 JSON与XML处理

JSON和XML是常见的数据交换格式，在网络编程中经常使用。

JSON处理：
使用org.json库处理JSON数据。

import org.json.JSONObject;

public class JSONExample {
    public static void main(String[] args) {
        JSONObject json = new JSONObject();
        json.put("name", "John");
        json.put("age", 30);
        System.out.println(json.toString());
    }
}

XML处理：
使用javax.xml.parsers库解析XML数据。

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;

public class XMLExample {
    public static void main(String[] args) {
        try {
            File inputFile = new File("input.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(inputFile);
            doc.getDocumentElement().normalize();
            NodeList nodeList = doc.getElementsByTagName("person");
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    Element element = (Element) node;
                    System.out.println("Name: " + element.getElementsByTagName("name").item(0).getTextContent());
                    System.out.println("Age: " + element.getElementsByTagName("age").item(0).getTextContent());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5. Java多线程与并发编程

5.1 线程基础与同步

Java多线程编程可以提高程序的执行效率。

创建线程：
使用Thread类创建线程。

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

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

线程同步：
使用synchronized关键字确保多个线程访问共享资源时不会产生冲突。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        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();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

5.2 死锁与线程安全

死锁是多个线程互相等待对方释放资源而造成的系统停止运行的情况。线程安全是指程序在多线程环境下能够正确地运行。

死锁：
死锁示例。

public class DeadlockExample {
    public static void main(String[] args) {
        Object resource1 = new Object();
        Object resource2 = new Object();

        new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1 acquired resource1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 1 acquired resource2");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2 acquired resource2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("Thread 2 acquired resource1");
                }
            }
        }).start();
    }
}

线程安全：
使用volatile关键字或原子类确保线程安全。

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSafeExample {
    private volatile int counter = 0;

    public void increment() {
        counter++;
    }

    public static void main(String[] args) {
        ThreadSafeExample example = new ThreadSafeExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.counter);
    }
}

5.3 常见并发工具类

Java提供了多种并发工具类，如ExecutorService, Semaphore, CountDownLatch等。

ExecutorService：
管理线程的执行，简化线程管理。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        for (int i = 0; i < 5; i++) {
            executorService.submit(() -> {
                System.out.println("Task running in thread: " + Thread.currentThread().getName());
            });
        }

        executorService.shutdown();
    }
}

Semaphore：
控制同时访问某一资源的线程数量。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final int MAX_THREADS = 3;
    private static Semaphore semaphore = new Semaphore(MAX_THREADS);

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            executorService.submit(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Task running in thread: " + Thread.currentThread().getName());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }

        executorService.shutdown();
    }
}

CountDownLatch：
用于等待所有线程执行完毕。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {
    public static void main(String[] args) {
        int numTasks = 5;
        CountDownLatch latch = new CountDownLatch(numTasks);
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < numTasks; i++) {
            executorService.submit(() -> {
                System.out.println("Task running in thread: " + Thread.currentThread().getName());
                latch.countDown();
            });
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All tasks completed");
    }
}

6. Java项目实战

6.1 小项目设计与实现

设计一个小项目，例如一个简单的图书管理系统。

需求分析：
- 用户管理：添加、删除、查询用户
- 图书管理：添加、删除、查询图书
- 借阅管理：用户借阅图书、归还图书
设计数据库模型：
- 用户表：User，包含id, name, email
- 图书表：Book，包含id, title, author
- 借阅表：BorrowRecord，包含id, user_id, book_id, borrow_date, return_date
实现功能：
使用Java和数据库连接进行操作。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class LibraryManager {
    private static Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/library", "user", "password");
    }

    public static void addUser(String name, String email) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("INSERT INTO User (name, email) VALUES (?, ?)")) {
            statement.setString(1, name);
            statement.setString(2, email);
            statement.executeUpdate();
        }
    }

    public static void deleteUser(int id) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("DELETE FROM User WHERE id = ?")) {
            statement.setInt(1, id);
            statement.executeUpdate();
        }
    }

    public static void addBook(String title, String author) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("INSERT INTO Book (title, author) VALUES (?, ?)")) {
            statement.setString(1, title);
            statement.setString(2, author);
            statement.executeUpdate();
        }
    }

    public static void deleteBook(int id) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("DELETE FROM Book WHERE id = ?")) {
            statement.setInt(1, id);
            statement.executeUpdate();
        }
    }

    public static void addUserBookRelation(int user_id, int book_id) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("INSERT INTO BorrowRecord (user_id, book_id) VALUES (?, ?)")) {
            statement.setInt(1, user_id);
            statement.setInt(2, book_id);
            statement.executeUpdate();
        }
    }

    public static void deleteBorrowRecord(int id) throws SQLException {
        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement("DELETE FROM BorrowRecord WHERE id = ?")) {
            statement.setInt(1, id);
            statement.executeUpdate();
        }
    }

    public static void main(String[] args) throws SQLException {
        addUser("John", "john@example.com");
        addBook("Java Programming", "John Smith");
        addUserBookRelation(1, 1);
        deleteUser(1);
        deleteBook(1);
        deleteBorrowRecord(1);
    }
}

6.2 单元测试与调试技巧

单元测试确保代码的正确性，调试技巧帮助定位和解决问题。

单元测试：
使用JUnit进行单元测试。

import org.junit.Test;
import static org.junit.Assert.*;

public class UnitTestExample {
    @Test
    public void testAdd() {
        int result = LibraryManager.add(1, 2);
        assertEquals(3, result);
    }
}

调试技巧：
使用IDE中的调试工具，设置断点，逐步执行代码，查看变量值等。

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

6.3 代码规范与重构

代码规范确保代码易于阅读和维护，重构改进代码结构。

代码规范：
遵循Java编码规范，如命名规范、注释、缩进等。

public class Example {
    public void exampleMethod() {
        System.out.println("Example method");
    }
}

重构：
重构是改善代码结构而不改变其功能。

public class Before {
    public void add(int a, int b) {
        int result = a + b;
        System.out.println(result);
    }
}

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

    public void printResult(int a, int b) {
        System.out.println(add(a, b));
    }
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

杨魅力

手记
篇

粉丝

57

获赞与收藏

264

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空