Java基础：掌握核心知识，助力Android面试成功

Java 基础：Android 面试必备知识

Android 开发是当今最受欢迎的职业选择之一。如果你打算参加 Android 客户端开发岗位的面试，那么你需要对 Java 基础有一个扎实的理解。Java 是 Android 开发的基础，掌握其核心概念对于写出高效、可靠的代码至关重要。

面向对象编程

面向对象编程 (OOP) 是构建应用程序的一种方式，它将数据和行为封装成对象。OOP 具有三大特性：

• 封装： 隐藏对象的内部状态，只暴露必要的接口。
• 继承： 子类可以继承父类的属性和方法。
• 多态： 子类可以重写父类的方法，提供不同的实现。

示例：

// 定义一个 Person 类
public class Person {
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 和 setter 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// 定义一个 Student 类，继承自 Person 类
public class Student extends Person {
    private int studentId;

    // 构造函数
    public Student(String name, int age, int studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    // 重写 getName() 方法
    @Override
    public String getName() {
        return "Student: " + super.getName();
    }
}

// 创建 Person 和 Student 对象
Person person = new Person("John Doe", 30);
Student student = new Student("Jane Doe", 25, 12345);

// 输出对象的属性
System.out.println(person.getName()); // 输出："John Doe"
System.out.println(student.getName()); // 输出："Student: Jane Doe"

Java 集合框架

Java 集合框架是一个功能强大的工具包，用于存储和管理数据集合。它提供了各种集合类型，如列表、集合和映射，以满足不同的需求。

示例：

// 创建一个 ArrayList 来存储字符串
List<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");
names.add("Bob");

// 遍历列表并打印元素
for (String name : names) {
    System.out.println(name);
}

异常处理

异常处理允许你优雅地处理程序运行时的错误情况。Java 提供了广泛的异常类，你可以使用 try-catch 块来捕获和处理异常。

示例：

try {
    // 代码可能会引发异常
} catch (Exception e) {
    // 处理异常
}

IO流

IO流用于在程序和外部数据源（如文件、网络）之间读写数据。Java 提供了各种流类型，如文件输入流、文件输出流、缓冲读取器和缓冲写入器。

示例：

// 从文件中读取数据
try (BufferedReader reader = new BufferedReader(new FileReader("myfile.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每一行
    }
}

多线程

多线程允许程序同时执行多个任务。Java 提供了各种多线程类，如线程、可运行和执行器服务，以满足不同的并发编程需求。

示例：

// 创建一个新线程
Thread thread = new Thread(() -> {
    // 在新线程中执行的代码
});

// 启动线程
thread.start();

JNI

JNI（Java 本地接口）允许 Java 程序与本地代码（如 C/C++ 代码）交互。它允许你调用本地代码中的函数并从本地代码中调用 Java 方法。

示例：

// 从 Java 调用 C 代码
try {
    System.loadLibrary("本机库");
    nativeMethod();
} catch (UnsatisfiedLinkError e) {
    // 处理错误
}

Java 虚拟机

Java 虚拟机 (JVM) 是运行 Java 程序的运行时环境。它负责加载、执行和管理 Java 程序。

示例：

// 获取当前运行时环境
Runtime runtime = Runtime.getRuntime();

// 获取可用内存
long memory = runtime.totalMemory();

// 打印可用内存
System.out.println("可用内存：" + memory + " 字节");

Java 字节码

Java 字节码是 JVM 执行的指令集。它是由 Java 编译器从 Java 源代码编译而来的。

示例：

// 使用 javac 编译 Java 源代码
javac 源文件.java

// 查看编译后的字节码
javap -c 编译后类文件.class

Java 内存模型

Java 内存模型 (JMM) 定义了 Java 程序中变量的可见性和一致性规则。它确保多个线程可以同时访问共享数据，而不会产生数据竞争或不一致。

示例：

// 创建一个共享变量
int count = 0;

// 创建两个线程来更新共享变量
Thread thread1 = new Thread(() -> {
    for (int i = 0; i < 100000; i++) {
        count++;
    }
});

Thread thread2 = new Thread(() -> {
    for (int i = 0; i < 100000; i++) {
        count++;
    }
});

// 启动线程
thread1.start();
thread2.start();

// 等待线程完成
thread1.join();
thread2.join();

// 打印共享变量的值
System.out.println("最终计数：" + count);

Java 垃圾回收机制

Java 垃圾回收机制自动回收不再使用的 Java 对象，以释放内存空间。它是一个并发过程，在后台运行，不会影响程序的执行。

示例：

// 创建一个对象
Object object = new Object();

// 让对象不可访问
object = null;

// 垃圾回收器会自动回收对象

反射

反射允许你检查和修改类和对象在运行时的元数据。它使你可以动态加载类、创建对象、调用方法和设置字段。

示例：

// 获取 Class 对象
Class<?> clazz = Class.forName("类名");

// 创建对象
Object object = clazz.newInstance();

// 调用方法
Method method = clazz.getMethod("methodName");
method.invoke(object);

泛型

泛型允许你编写类型安全的代码，而不必指定具体的类型参数。它消除了类型转换和强制转换的需要。

示例：

// 创建一个泛型类
<T> class MyList<T> {
    // ...
}

// 创建一个字符串列表
MyList<String> myList = new MyList<>();

// 添加元素到列表中
myList.add("元素 1");
myList.add("元素 2");

// 检索列表中的第一个元素
String firstElement = myList.get(0);

注解

注解允许你向类、方法和字段添加元数据。它们可以用于各种目的，如配置、文档化和验证。

示例：

// 在类上添加一个注解
@Deprecated
public class MyDeprecatedClass {
    // ...
}

// 在方法上添加一个注解
@Override
public void myMethod() {
    // ...
}

Lambda 表达式

Lambda 表达式允许你编写更简洁和更易读的代码。它们是一个匿名函数，没有名称或访问修饰符。

示例：

// 使用 Lambda 表达式创建线程
Thread thread = new Thread(() -> {
    // ...
});

// 使用 Lambda 表达式过滤列表
List<String> filteredList = names.stream().filter(name -> name.startsWith("J")).toList();

Stream API

Stream API 提供了一个统一的框架来处理集合数据。它提供了各种操作，如过滤、映射和归约，以简化常见的数据处理任务。

示例：

// 使用 Stream API 计算列表中的元素和
int sum = names.stream().mapToInt(String::length).sum();

// 使用 Stream API 找出列表中最长的字符串
String longestName = names.stream().max(Comparator.comparing(String::length)).get();

模块化

模块化允许你将大型应用程序分解成更小的、可重用的模块。它提高了代码的可维护性、可重用性和可扩展性。

示例：

// 创建一个模块
module myModule {
    // ...
}

// 使用模块
import myModule.*;

线程同步

线程同步控制多个线程对共享数据的并发访问。它防止线程竞争和数据不