JAVA主流技术学习：从入门到提升-原创手记-慕课网

概述

JAVA主流技术学习涵盖了从基础回顾到面向对象编程、集合框架、异常处理、IO操作与多线程等核心领域，旨在全面掌握JAVA编程的精髓与实践。

JAVA基础回顾

JAVA简介

JAVA 是一种面向对象的、跨平台的编程语言，由 Sun Microsystems 开发并于 1995 年发布。它旨在简化编写、部署和维护代码的过程，使得开发者能在不同操作系统上运行和维护应用程序。JAVA 的核心特点是其强大的类库、面向对象编程原则以及垃圾回收机制。

JDK、JVM理解

JAVA 开发工具包（JDK）包含了编写、编译和运行 JAVA 应用程序所需的所有组件。JVM（Java Virtual Machine）是 JAVA 应用程序运行的基础，它允许在不同操作系统上运行 JAVA 代码，实现了平台无关性。

数据类型、变量、运算符

JAVA 的数据类型分为基本类型和引用类型。基本类型包括：byte、short、int、long、float、double、char 和 boolean。引用类型则包含类、接口、数组等。变量需要在声明时指定类型，并赋予初始值。

public class BasicTypes {
    public static void main(String[] args) {
        int age = 25; // 整数类型
        float salary = 5000.99f; // 浮点类型
        char grade = 'A'; // 字符类型
        boolean isValid = true; // 布尔类型

        System.out.println("Age: " + age);
        System.out.println("Salary: " + salary);
        System.out.println("Grade: " + grade);
        System.out.println("IsValid: " + isValid);
    }
}

JAVA 的运算符包括算术运算符、赋值运算符、比较运算符、逻辑运算符等。这些运算符用于执行基本的数学操作和数据比较。

控制结构：条件语句、循环语句

JAVA 提供了 if、else、switch、for、while 和 do-while 等控制结构，用于实现流程控制。

public class ControlStructures {
    public static void main(String[] args) {
        int x = 10;
        if (x > 0) {
            System.out.println("x 是正数");
        } else {
            System.out.println("x 不是正数");
        }

        for (int i = 1; i <= 5; i++) {
            System.out.println("循环次数: " + i);
        }

        int count = 0;
        do {
            System.out.println("循环执行次数: " + count);
            count++;
        } while (count < 3);
    }
}

面向对象编程

类与对象的创建

类是对象的蓝图，包含了对象的属性和方法。创建对象时，会根据类的定义实例化一个对象。

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

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

    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Tom", 20);
        person.introduce();
    }
}

封装、继承、多态

封装是隐藏对象的内部实现细节，只通过公共接口暴露外部可以操作的对象。继承允许创建一个类来继承另一个类的属性和方法。多态使得不同类的对象可以以相同的方式处理，增加了代码的灵活性和复用性。

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
    }
}

接口与抽象类

接口定义了一系列方法和常量，类实现了接口后必须实现接口中的所有方法。抽象类可以包含抽象方法，子类必须实现这些方法。

public interface Flyable {
    void fly();
}

public abstract class Bird implements Flyable {
    public void eat() {
        System.out.println("Bird eats seeds.");
    }

    @Override
    public void fly() {
        System.out.println("Bird flies.");
    }
}

public class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow flies fast.");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird bird = new Sparrow();
        bird.eat();
        bird.fly();
    }
}

静态成员与实例成员

静态成员属于类，而不是实例，可以被类直接访问。实例成员属于对象，每个对象都有各自的副本。

public class MyClass {
    private String privateField;
    public static int staticField;

    public MyClass(String field) {
        privateField = field;
    }

    public static void staticMethod() {
        staticField = 100;
    }

    public void instanceMethod() {
        System.out.println("Instance field: " + privateField);
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass.staticMethod();
        MyClass instance = new MyClass("Hello");
        instance.instanceMethod();
    }
}

集合框架

ArrayList、LinkedList、Vector区别

这些类都是 java.util 包下的集合类，用于存储对象集合。

public class ArrayListVsLinkedList {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        LinkedList<String> list2 = new LinkedList<>();

        list1.add("A");
        list1.add("B");
        list1.add("C");
        list2.add("A");
        list2.add("B");
        list2.add("C");

        System.out.println("ArrayList size: " + list1.size());
        System.out.println("LinkedList size: " + list2.size());
    }
}

HashMap、HashSet、TreeMap应用

这些类分别用于存储键值对、无重复元素的集合和有序集合。

public class CollectionUsage {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);
        map.put("Date", 4);
        map.remove("Banana");

        System.out.println("HashMap: " + map);

        HashSet<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Date");

        System.out.println("HashSet: " + set);

        TreeMap<String, Integer> sortedMap = new TreeMap<>(map);
        System.out.println("TreeMap (sorted): " + sortedMap);
    }
}

集合的迭代与遍历

使用 for-each 循环或者 Iterator 接口进行遍历。

public class CollectionIteration {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        // 使用 for-each 循环
        for (String element : list) {
            System.out.println(element);
        }

        // 使用 Iterator
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

异常处理

错误与异常的区别

错误用于描述程序无法修复的运行时问题，异常则用于描述可以被程序捕获和处理的问题。

try、catch、finally块

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int[] array = {1, 2};
            System.out.println(array[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught an ArrayIndexOutOfBoundsException: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed.");
        }
    }
}

自定义异常和异常链

自定义异常继承自 Exception 类，异常链使用 throws 关键字。

public class CustomException {
    public static void process(int value) throws MyException {
        if (value < 0) {
            throw new MyException("Value is negative.");
        }
    }

    public static void main(String[] args) {
        try {
            process(-10);
        } catch (MyException e) {
            System.out.println("Caught MyException: " + e.getMessage());
        }
    }
}

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

IO操作

文件读写操作

利用 FileReader, FileWriter, BufferedReader, BufferedWriter 等类实现文件操作。

import java.io.*;

public class FileIO {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            writer.write("Hello, World!");
        } catch (IOException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

字符串输入输出

使用 BufferedReader 和 BufferedWriter 进行字符串的读取和写入。

import java.io.*;

public class StringIO {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("Read: " + line);
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

文件路径操作

使用 File 类来处理文件路径。

import java.io.File;

public class PathOperations {
    public static void main(String[] args) {
        File file = new File("example.txt");
        System.out.println("File path: " + file.getAbsolutePath());
        System.out.println("File exists: " + file.exists());
        System.out.println("Directory exists: " + file.isDirectory());
        System.out.println("File is a file: " + file.isFile());
    }
}

多线程

线程创建与启动

创建线程有两种方式：继承 Thread 类或实现 Runnable 接口。

public class ThreadCreation {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread running: " + i);
                }
            }
        });

        thread.start();
    }
}

线程同步与等待通知

使用 synchronized 关键字保证线程安全，并配合 wait() 和 notify() 方法实现同步。

public class ThreadSynchronization {
    private static Object lock = new Object();

    public static class ThreadA extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread A: " + i);
                    lock.notify();
                    lock.wait();
                }
            }
        }
    }

    public static class ThreadB extends Thread {
        @Override
        public void run() {
            synchronized (lock) {
                lock.wait();
                lock.notify();
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread B: " + i);
                }
            }
        }
    }

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();
        threadA.start();
        threadB.start();
    }
}

自定义线程池

使用 ExecutorService 和 ThreadPoolExecutor 来创建和管理线程池。

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

public class CustomThreadPool {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Thread ID: " + Thread.currentThread().getId());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executor.shutdown();
    }
}

并发集合和原子类使用

并发集合如 ConcurrentHashMap，原子类如 AtomicInteger 用于提高性能和简化多线程编程。

public class ConcurrentUsage {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("A", 1);
        map.put("B", 2);

        AtomicInteger count = new AtomicInteger(0);
        count.incrementAndGet(); // 原子操作

        Thread thread1 = new Thread(() -> {
            map.put("C", 3);
        });

        Thread thread2 = new Thread(() -> {
            count.incrementAndGet();
        });

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Map: " + map);
        System.out.println("Count: " + count.get());
    }
}

通过这些示例代码，学习者可以逐步理解并实践 JAVA 的各种基础和高级特性，为后续更深入的学习打下坚实的基础。