Java特性概述

一、Java語言特性

Java是一門面向對象的語言，它的特性包括類、對象、繼承、封裝、抽象、多態等。Java還有許多其他語言不具備的特性，這些都是Java的優勢之一。

1. 類和對象

public class Student {
    String name;
    int age;
    double score;

    public void printInfo() {
        System.out.println("姓名：" + name);
        System.out.println("年齡：" + age);
        System.out.println("成績：" + score);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "Tom";
        stu.age = 18;
        stu.score = 96.5;
        stu.printInfo();
    }
}

類是Java的基本單元，它包含了數據和方法。對象是類的一個實例，可以調用類中的方法和訪問類中的數據。

2. 繼承

public class Animal {
    String name;
    int age;

    public void eat() {
        System.out.println(name + "正在吃東西");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + "正在汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺財";
        dog.age = 3;
        dog.eat();
        dog.bark();
    }
}

Java中的繼承允許一個類繼承另一個類的屬性和方法，並且可以根據需要重寫繼承來的方法或者添加新的方法。

3. 封裝

public class Book {
    private String name;
    private String author;
    private double price;

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

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Book book = new Book();
        book.setName("Java從入門到精通");
        System.out.println(book.getName());
    }
}

Java中的封裝把數據和方法封裝在類中，外部不能直接訪問這些數據，需要通過方法來訪問。

4. 抽象

public abstract class Shape {
    public abstract double area();
}

public class Square extends Shape {
    double side;

    public Square(double side) {
        this.side = side;
    }

    public double area() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Square(4.0);
        System.out.println("正方形的面積為：" + shape.area());
    }
}

Java中的抽象類可以讓子類繼承並實現其中的抽象方法，這些抽象方法只有聲明，沒有具體的實現。

5. 多態

public class Animal {
    public void speak() {
        System.out.println("動物可以發出聲音");
    }
}

public class Cat extends Animal {
    public void speak() {
        System.out.println("貓發出「喵喵」聲");
    }
}

public class Dog extends Animal {
    public void speak() {
        System.out.println("狗發出「汪汪」聲");
    }
}

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

Java中的多態允許不同的子類實現同一個方法，可以通過父類的引用來調用這個方法，具有靈活性。

二、Java虛擬機特性

Java虛擬機（JVM）是Java的核心，它實現了Java語言的跨平台性，提供了自動內存管理、垃圾回收、動態位元組碼執行等特性。

1. 自動內存管理和垃圾回收

Java的自動內存管理和垃圾回收是通過Java虛擬機來實現的。它可以自動管理內存的分配和釋放，大大地簡化了程序員的工作，避免了內存泄漏和內存溢出等問題。

2. 動態位元組碼執行

Java編譯器將Java源代碼編譯成Java位元組碼，Java虛擬機可以執行這些位元組碼，實現了跨平台的特性。Java虛擬機可以在運行時動態地載入和執行位元組碼，這也為Java語言的動態性和靈活性提供了基礎。

3. 即時編譯

即時編譯是Java虛擬機中的一個重要特性，它可以將Java位元組碼編譯成本地機器碼，從而獲得更好的執行效率。即時編譯器會監測運行時的代碼，並對經常執行的代碼進行優化，提高程序的性能。

三、Java API特性

Java API（Application Programming Interface）是Java提供的一組類庫和方法，通過這些類庫和方法可以完成一些常見的任務，如IO操作、網路編程、GUI編程等。

1. IO操作

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            System.out.println("請輸入文字：");
            String line = br.readLine();
            System.out.println("輸入的文字是：" + line);
        } catch(IOException e) {
            System.out.println("發生IO異常");
        }
    }
}

Java提供了豐富的IO類和方法，可以實現對文件、網路中數據的讀取和寫入。上面的代碼演示了如何從控制台讀取用戶輸入的數據。

2. 網路編程

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 8888);
             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {

            String cmd = "Hello, server!";
            bw.write(cmd);
            bw.newLine();
            bw.flush();

            String response = br.readLine();
            System.out.println("伺服器返回：" + response);
        } catch (IOException e) {
            System.out.println("發生異常：" + e.getMessage());
        }
    }
}

public class Server {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8888);
             Socket socket = serverSocket.accept();
             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {

            String cmd = br.readLine();
            System.out.println("客戶端請求：" + cmd);
            String response = "Hello, client!";
            bw.write(response);
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            System.out.println("發生異常：" + e.getMessage());
        }
    }
}

Java中的網路編程可以實現Socket通信，通過套接字（socket）可以在網路中發送和接受數據。

3. GUI編程

import javax.swing.*;

public class Main {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Hello, Java");
        frame.setSize(200, 150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JLabel label = new JLabel("Hello, world!");
        frame.getContentPane().add(label);

        frame.setVisible(true);
    }
}

Java中的GUI（Graphical User Interface）編程可以使用Swing或JavaFX等類庫來構建GUI應用程序，實現窗口、按鈕、文本框等常見的界面元素，並添加動作或事件處理邏輯。

四、Java並發特性

Java並發編程是Java語言中的一個特性，它可以實現多個線程之間的並發執行，提高程序的效率和響應速度。

1. 線程

public class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("線程 " + Thread.currentThread().getId() + " 正在執行：" + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }
}

Java中的線程可以使用Thread類來創建，並且可以通過繼承Thread類來實現自定義的線程。線程可以並發地執行。

2. 同步和鎖

public class Counter {
    private long count = 0;

    public synchronized void add(long value) {
        this.count += value;
    }

    public long getCount() {
        return count;
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 10000; i++) {
            counter.add(1);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            System.out.println("發生異常：" + e.getMessage());
        }

        System.out.println("計數器的值為：" + counter.getCount());
    }
}

Java並發編程需要使用同步和鎖來保護共享的資源，否則會出現競爭條件和數據不一致的問題。上面的代碼演示了如何使用synchronized關鍵字實現對計數器的同步。

3. 線程池

public class MyTask implements Runnable {
    private int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    public void run() {
        System.out.println("任務 " + taskId + " 開始執行");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("發生異常：" + e.getMessage());
        }
        System.out.println("任務 " + taskId + " 執行完成");
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            executor.submit(new MyTask(i));
        }
        executor.shutdown();
    }
}

Java中的線程池可以實現線程的復用和調度。它可以管理一組線程，並在需要時分配和回收線程。上面的代碼演示了如何使用ExecutorService和ThreadPoolExecutor來創建線程池和提交線程任務。