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来创建线程池和提交线程任务。