Java继承与高级特性

Xiaoyu_0825

279人浏览 · 2026-06-13 22:36:10

Xiaoyu_0825 · 2026-06-13 22:36:10 发布

Java继承与高级特性深度解析

Java继承基础

继承是面向对象编程的核心概念之一，允许子类复用父类的属性和方法。Java通过extends关键字实现单继承，通过接口实现多继承效果。子类可以重写父类方法（@Override），或通过super调用父类实现。

class Animal {
    void eat() { System.out.println("Eating..."); }
}
class Dog extends Animal {
    @Override
    void eat() { System.out.println("Dog eats meat"); }
}

泛型（Generics）

泛型提供编译时类型安全检查，避免运行时类型转换错误。通过类型参数化实现代码复用，常见于集合框架。

class Box<T> {
    private T content;
    void setContent(T content) { this.content = content; }
    T getContent() { return content; }
}
// 使用示例
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello Generics");

类型通配符（?）和边界（extends/super）增强灵活性：

void printList(List<? extends Number> list) {
    for (Number num : list) System.out.println(num);
}

Java类加载机制

类加载分为加载、验证、准备、解析、初始化五个阶段，由类加载器（ClassLoader）完成。双亲委派模型（Parent Delegation Model）确保类加载的安全性：

Bootstrap ClassLoader：加载JRE核心库（如rt.jar）。
Extension ClassLoader：加载jre/lib/ext目录下的扩展类。
Application ClassLoader：加载用户类路径（-classpath）的类。

自定义类加载器需继承ClassLoader并重写findClass方法：

class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name); // 从自定义路径读取字节码
        return defineClass(name, classData, 0, classData.length);
    }
}

Java反射机制（Reflection）

反射允许程序在运行时动态获取类信息并操作对象，常用于框架开发（如Spring）。核心类包括：

Class：表示类或接口。
Field：类的成员变量。
Method：类的方法。
Constructor：类的构造器。

示例：动态调用方法

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.newInstance();
Method method = clazz.getMethod("setName", String.class);
method.invoke(user, "Alice");

枚举类型（Enum）

枚举是类型安全的常量集合，可添加方法和字段。Java枚举本质是继承java.lang.Enum的类。

enum Color {
    RED("#FF0000"), GREEN("#00FF00");
    private String hexCode;
    Color(String hexCode) { this.hexCode = hexCode; }
    public String getHexCode() { return hexCode; }
}
// 使用示例
Color red = Color.RED;
System.out.println(red.getHexCode());

Java注解（Annotation）

注解为代码添加元数据，可用于编译检查（如@Override）、运行时处理（如Spring的@Autowired）。自定义注解需通过@interface定义：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
    String value() default "defaultTask";
}

运行时通过反射处理注解：

Method method = target.getClass().getMethod("annotatedMethod");
if (method.isAnnotationPresent(LogExecutionTime.class)) {
    LogExecutionTime annotation = method.getAnnotation(LogExecutionTime.class);
    System.out.println("Logging: " + annotation.value());
}

实用案例：动态代理

结合反射和接口实现动态代理，常用于AOP（面向切面编程）：

interface Service { void serve(); }
class RealService implements Service {
    public void serve() { System.out.println("Real service"); }
}
class DynamicProxyHandler implements InvocationHandler {
    private Object target;
    DynamicProxyHandler(Object target) { this.target = target; }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}
// 使用示例
Service proxy = (Service) Proxy.newProxyInstance(
    Service.class.getClassLoader(),
    new Class[]{Service.class},
    new DynamicProxyHandler(new RealService())
);
proxy.serve();