JAVA主流技术学习涵盖了从基础回顾到面向对象编程、集合框架、异常处理、IO操作与多线程等核心领域,旨在全面掌握JAVA编程的精髓与实践。
JAVA 是一种面向对象的、跨平台的编程语言,由 Sun Microsystems 开发并于 1995 年发布。它旨在简化编写、部署和维护代码的过程,使得开发者能在不同操作系统上运行和维护应用程序。JAVA 的核心特点是其强大的类库、面向对象编程原则以及垃圾回收机制。
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(); } }
这些类都是 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()); } }
这些类分别用于存储键值对、无重复元素的集合和有序集合。
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()); } } }
错误用于描述程序无法修复的运行时问题,异常则用于描述可以被程序捕获和处理的问题。
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); } }
利用 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 的各种基础和高级特性,为后续更深入的学习打下坚实的基础。