Java面试题教程全面涵盖从基础概念到高级编程技巧，包括变量与数据类型、控制结构、函数与方法、异常处理、面向对象编程、集合类与多线程、输入输出与文件操作，以及数据结构与算法。本文旨在为Java开发者提供深入理解与实战经验，助力面试表现优异。

Java基础概念

变量与数据类型

在Java中，变量是用于存储数据的容器。声明变量时，需要指定变量的类型与名称。Java的基本数据类型，如int、float、boolean，这些类型属于primitive类型。示例代码如下：

public class Main {
    public static void main(String[] args) {
        int age = 25;
        float salary = 5500.99f;
        boolean isMarried = true;

        System.out.println("Age: " + age);
        System.out.println("Salary: " + salary);
        System.out.println("Married: " + isMarried);
    }
}

Java中还包括reference类型，如String、Object等，这些类型存储的是对象的引用。

控制结构

Java提供了多种控制结构，包括if-else语句、switch语句、for循环、while循环和do-while循环。下面是一个示例：

public class ControlFlow {
    public static void main(String[] args) {
        int x = 10;
        if (x > 5) {
            System.out.println("x is greater than 5.");
        } else {
            System.out.println("x is not greater than 5.");
        }

        switch (x) {
            case 1:
                System.out.println("Value is 1.");
                break;
            case 2:
                System.out.println("Value is 2.");
                break;
            default:
                System.out.println("Default case.");
        }

        int y = 0;
        while (y < 5) {
            System.out.println("y is: " + y);
            y++;
        }

        do {
            System.out.println("Do-while loop iteration.");
        } while (false);
    }
}

函数与方法

方法是用于完成特定任务的一组可执行代码。Java方法的定义包括方法名、参数和返回类型。

public class Methods {
    public static void main(String[] args) {
        System.out.println(greet("John"));
    }

    public static String greet(String name) {
        return "Hello, " + name + "!";
    }
}

异常处理

Java的异常处理机制通过try、catch、finally等关键词实现。示例代码如下：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero.");
        }
    }

    public static void divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Division by zero.");
        }
        System.out.println("Result: " + (a / b));
    }
}

面向对象编程

类与对象

类是对象的蓝图，包含属性和方法。对象是类的实例。示例代码如下：

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

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

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

public class Main {
    public static void main(String[] args) {
        Student john = new Student("John", 20);
        john.greet();
    }
}

封装、继承、多态

封装是隐藏对象内部细节，只暴露对外接口。继承允许一个类继承另一个类的属性和方法。多态允许子类覆盖或实现父类的方法。

public abstract class Animal {
    public abstract void makeSound();
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

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

接口与实现

接口定义一组方法签名，类实现接口时必须实现接口中的所有方法。

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

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

内部类与静态内部类

内部类嵌套在另一个类中，可以访问外部类的成员。

public class OuterClass {
    private String name;

    public class InnerClass {
        public void printName() {
            System.out.println(name);
        }
    }

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

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.setName("John");
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.printName();
    }
}

集合类与多线程

常用集合类与并发集合类

Java集合并发类提供了线程安全的集合实现。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentDemo {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("John", "123");
        map.put("Jane", "456");

        // 支持并发操作
        new Thread(() -> {
            map.put("Mike", "789");
        }).start();

        System.out.println(map);
    }
}

多线程基础

多线程基础包括线程创建、同步和并发控制。

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                myMethod();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                myMethod();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Total count: " + total);
    }

    public static synchronized void myMethod() {
        total++;
    }

    private static int total = 0;
}

输入输出与文件操作

文件读写操作

文件读写操作是Java中常见的任务，可以使用File类与FileInputStream、FileOutputStream等类来实现。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class FileIO {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("src/main/resources/input.txt");
             FileOutputStream fos = new FileOutputStream("src/main/resources/output.txt")) {

            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

输入输出流

输入输出流提供了读写不同类型数据的接口，如BufferedReader、BufferedWriter、DataInputStream、DataOutputStream等。

import java.io.*;

public class IOTutorial {
    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) {
                writer.write(line);
                writer.newLine();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数据结构与算法

常见数据结构与基本算法

数据结构如数组、链表、栈、队列、树、图，以及基本算法如排序、查找、递归等是编程的基石。

数组：

public class Array {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

链表（单链表）：

public class LinkedList {
    private static class Node {
        int data;
        Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    private Node head;

    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        Node current = list.head;
        while (current != null) {
            System.out.println(current.data);
            current = current.next;
        }
    }
}

排序算法（快速排序）：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
}

这些示例和代码片段旨在帮助你理解Java的基础概念、面向对象编程、集合、多线程、输入输出操作以及数据结构和算法的基本应用。掌握这些内容将为你的Java编程技能打下坚实的基础，并为面试准备提供有力支持。