Java編程開發全能指南

一、Java基礎

Java是一門簡單、安全、可移植、面向對象、高性能、健壯的編程語言。其語法易於閱讀和編寫，是開發企業級應用的首選語言之一。

Java變量和數據類型

Java有八種基本數據類型，分別為byte、short、int、long、float、double、char和boolean。變量是用於存儲數據的存儲空間，可以為變量指定數據類型。在Java中，變量有局部變量、類變量和實例變量。

public class Test {
    // Java中的類變量
    static int count = 0; 
    
    // Java中的實例變量
    String name;
    
    public void run() {
        // Java中的局部變量
        int i = 0;
    }
}

Java流控制語句

Java中的流控制語句包括if/else、switch、for、while和do/while語句。

public class Test {
    public static void main(String[] args) {
        // if/else語句
        int num = 10;
        if (num > 0) {
            System.out.println("num is positive");
        } else {
            System.out.println("num is zero or negative");
        }
        
        // switch語句
        int dayOfWeek = 3;
        switch (dayOfWeek) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Other day");
                break;
        }
        
        // for循環
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        
        // while循環
        int i = 0;
        while (i < 10) {
            System.out.println(i);
            i++;
        }
        
        // do/while循環
        int j = 0;
        do {
            System.out.println(j);
            j++;
        } while (j < 10);
    }
}

二、Java面向對象編程

Java是一門面向對象的編程語言，其基本概念包括類、對象、繼承、封裝和多態。

Java類的定義

Java通過class關鍵字定義類，類中包含屬性和方法。

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

Java對象的創建和使用

Java通過new關鍵字創建對象，並通過點操作符訪問對象的屬性和方法。

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

Java繼承

Java使用extends關鍵字實現繼承。

public class Student extends Person {
    private String school;
    
    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old, and I study at " + school + ".");
    }
}

Java封裝

Java通過訪問修飾符實現封裝，將類的屬性和方法隱藏起來，只允許通過公共方法進行訪問。

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 int getAge() {
        return age;
    }
}

Java多態

Java通過方法重寫和方法重載實現多態。

public class Animal {
    public void move() {
        System.out.println("I'm moving");
    }
}

public class Dog extends Animal {
    public void move() {
        System.out.println("I'm running");
    }
    
    public void bark() {
        System.out.println("Woof!");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Animal();
        Animal animal2 = new Dog();
        
        animal1.move();
        animal2.move();
        
        Dog dog = new Dog();
        dog.bark();
    }
}

三、Java高級特性

Java還有許多高級特性，如異常處理、反射、註解、泛型、並發編程等。

Java異常處理

Java通過try/catch/finally語句處理異常。

public class Test {
    public static void main(String[] args) {
        try {
            // 可能拋出異常的代碼
        } catch (Exception ex) {
            // 異常處理代碼
        } finally {
            // finally代碼塊中的代碼始終會被執行
        }
    }
}

Java反射

Java反射可以在程序運行時動態獲取類的信息，並且創建類的對象、調用類的方法和訪問類的屬性。

public class Test {
    public static void main(String[] args) throws Exception {
        // 獲取類的信息
        Class clazz = Class.forName("java.lang.String");
        System.out.println("Class name: " + clazz.getName());
        
        // 創建類的對象
        Object obj = clazz.newInstance();
        
        // 調用類的方法
        Method method = clazz.getMethod("toUpperCase");
        String result = (String) method.invoke(obj);
        System.out.println("Result: " + result);
        
        // 訪問類的屬性
        Field field = clazz.getDeclaredField("value");
        field.setAccessible(true);
        char[] value = (char[]) field.get(obj);
        value[0] = 'H';
        System.out.println("Modified string: " + obj);
    }
}

Java註解

Java註解是一種在程序代碼中添加元數據的方式，它可以用於描述類、屬性、方法和參數。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Range {
    int min() default 0;
    int max() default 100;
}

public class Person {
    @Range(min = 18, max = 60)
    private int age;
    
    public void setAge(int age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Field field = Person.class.getDeclaredField("age");
        Range range = field.getAnnotation(Range.class);
        System.out.println("Min: " + range.min());
        System.out.println("Max: " + range.max());
    }
}

Java泛型

Java泛型是一種將類型參數化的方式，它可以在編譯時檢查類型的合法性，並且在運行時不會出現類型轉換異常。

public class Stack {
    private List list = new ArrayList();
    
    public void push(T element) {
        list.add(element);
    }
    
    public T pop() {
        int index = list.size() - 1;
        T element = list.get(index);
        list.remove(index);
        return element;
    }
}

public class Test {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push("hello");
        stack.push("world");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

Java並發編程

Java並發編程可以提高程序的效率和性能，但同時也會帶來一些線程安全的問題，如死鎖和數據競爭等。

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Counter counter = new Counter();
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    counter.increment();
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    counter.increment();
                }
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(counter.getCount());
    }
}

四、總結

Java是一門功能強大、適用廣泛的編程語言，其高度的可移植性和豐富的開發庫為開發者提供了快速開發企業級應用的能力。開發者應該紮實掌握Java的基礎知識和面向對象編程思想，並深入學習Java的高級特性，如異常處理、泛型和並發編程等。