Java主流技术教程：入门到实践的全面指南

Java主流技术教程全面覆盖Java基础知识讲解，从安装与配置环境到面向对象编程原理，通过分析基本语法结构，深入探讨封装、继承和多态特性。文章进一步介绍Java集合框架，比较ArrayList、LinkedList和HashMap的使用场景，强调性能考量。此外，教程涉及异常处理与多线程编程，通过实战项目指导读者构建待办事项应用，实现任务管理功能。

首先，我们需要在自己的计算机上安装Java开发环境。下载并安装Java开发工具包（JDK）对于Windows用户，可通过访问Oracle官方网站下载最新版本的JDK(https://www.oracle.com/java/technologies/javase-downloads.html)。安装过程中选择“所有用户”选项以全局安装JDK。

为验证Java环境是否成功安装，可以在命令行输入以下命令：

java -version

如果安装成功，命令行会显示Java的版本信息。

基本操作

Java是一种静态类型语言，这意味着在编译时，类型信息会被检查。下面是一些基本的Java语句：

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

变量与数据类型

Java中定义变量时，需要先声明类型和名称，然后初始化变量值。Java的主要数据类型包括：

• 整型：int, long
• 浮点型：float, double
• 字符型：char
• 布尔型：boolean

例如，声明一个整型变量：

int age = 25;

声明并初始化一个字符变量：

char grade = 'A';

封装

封装是将数据和操作数据的方法捆绑在一起，形成一个独立的模块。这有助于隐藏内部细节，提高代码复用性和安全性。例如：

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

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 class Student extends Person {
    private String school;

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

    public String getSchool() {
        return school;
    }

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

多态

多态允许子类对象被当作父类对象使用，主要通过方法重写实现：

public class Person {
    public void speak() {
        System.out.println("I am here.");
    }
}

public class Student extends Person {
    @Override
    public void speak() {
        System.out.println("Hello, I am a student.");
    }
}

public class Teacher extends Person {
    public void speak() {
        System.out.println("Greetings, I am a teacher.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Person student = new Student();
        Person teacher = new Teacher();

        speak(person);
        speak(student);
        speak(teacher);
    }

    public static void speak(Person p) {
        p.speak();
    }
}

常用集合类

Java集合框架提供了丰富的数据结构以存储和操作数据。下面是一些常用的集合类：

ArrayList

ArrayList是一个实现列表接口的类，允许元素的动态添加、删除和查找。

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        System.out.println("Fruits: " + fruits);
        fruits.remove("banana");
        System.out.println("Fruits after removal: " + fruits);
    }
}

LinkedList

LinkedList类提供了双向链表，插入和删除元素操作效率较高。

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> fruits = new LinkedList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        System.out.println("Fruits: " + fruits);
        fruits.remove("banana");
        System.out.println("Fruits after removal: " + fruits);
    }
}

HashMap

HashMap是一个基于哈希表的映射接口实现类，用于键值对的存储。

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> fruits = new HashMap<>();
        fruits.put("apple", 1);
        fruits.put("banana", 2);
        fruits.put("cherry", 3);

        System.out.println("Fruits: " + fruits);
        fruits.remove("banana");
        System.out.println("Fruits after removal: " + fruits);
    }
}

性能比较

在选择集合类时，需要考虑性能和应用需求。例如：

• ArrayList：适用于随机访问和遍历，但在插入和删除操作时效率较低。
• LinkedList：适用于频繁的插入和删除操作，但在随机访问时效率较低。
• HashMap：快速的键值查找，适合需要高速查找的应用。

异常处理是编程中处理错误或异常情况的重要机制。使用try-catch-finally结构处理异常：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero.");
        } finally {
            System.out.println("Finally block executed.");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

多线程编程允许并发执行任务，提高程序性能。Java提供了Thread类和synchronized关键字来管理线程和共享资源：

public class ThreadExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread 1 executing: " + i);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread 2 executing: " + i);
            }
        });

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

public class ThreadSafetyExample {
    private static int counter = 0;

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

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

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

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

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

    private static synchronized void increment() {
        counter++;
    }
}

项目需求

实现一个简单的待办事项应用，允许用户添加、删除、查看和标记任务为已完成。

项目代码

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

public class TodoApp {
    private List<String> todos;

    public TodoApp() {
        this.todos = new ArrayList<>();
    }

    public void addTask(String task) {
        todos.add(task);
    }

    public void removeTask(String task) {
        todos.remove(task);
    }

    public void viewTodos() {
        for (String todo : todos) {
            if (isDone(todo)) {
                System.out.println(todo + " (Done)");
            } else {
                System.out.println(todo);
            }
        }
    }

    public void markTodoDone(int index) {
        if (index >= 0 && index < todos.size()) {
            todos.set(index, todos.get(index) + " (Done)");
        }
    }

    private boolean isDone(String todo) {
        return todo.contains("(Done)");
    }
}

public class Main {
    public static void main(String[] args) {
        TodoApp todoApp = new TodoApp();
        todoApp.addTask("Buy groceries");
        todoApp.addTask("Learn Java");
        todoApp.addTask("Call mom");
        todoApp.markTodoDone(1);
        todoApp.viewTodos();
    }
}

通过上述文章，我们详细了解了Java基础知识、OOP原理、集合框架、异常处理、多线程编程和一个简单的实战项目，为Java学习者提供了全面的指导和实践经验。