Java泛型抽象类的实例化与设计实践

public abstract class AbstractMiniMap<K, V> implements MiniMap<K, V> {
    // ... 类成员和方法 ...
    public AbstractMiniMap() {
        // 构造器实现
    }
}

public static void main(String[] args) {
    // 错误示例：直接实例化抽象类
    AbstractMiniMap<Double, Double> asd = new AbstractMiniMap<>(20,30); // 编译错误
}

public static void main(String[] args) {
    // 解决方案一：使用匿名内部类
    // 假设 AbstractMiniMap 没有抽象方法需要实现
    AbstractMiniMap<Double, Double> map1 = new AbstractMiniMap<Double, Double>() {
        // 如果 AbstractMiniMap 有抽象方法，需要在此处实现它们
        // 例如：
        // @Override
        // public void push(Double key, Double value) { /* 实现 */ }
        // @Override
        // public Double remove(Double key) { /* 实现 */ }
    };
    System.out.println("使用匿名内部类创建的实例：" + map1.getClass().getName());
    // 可以在此调用 map1 的方法进行测试
}

// 修改后的 AbstractMiniMap 类声明 (不推荐作为通用解决方案，仅作演示)
// public class MiniMapImpl<K, V> implements MiniMap<K, V> { // 建议同时修改类名以符合规范
public class AbstractMiniMap<K, V> implements MiniMap<K, V> { // 移除 abstract 关键字
    // ... 其他代码不变 ...

    public AbstractMiniMap() {
        this.size = 0;
        this.keys = new Object[CAPACITY];
        this.vals = new Object[CAPACITY];
    }
    // ... 其他方法 ...
}

public static void main(String[] args) {
    // 解决方案二：移除 abstract 关键字后直接实例化 (如果类不再是抽象的)
    // 注意：如果 AbstractMiniMap 移除 abstract 后仍然有抽象方法，这会导致编译错误
    // 并且通常建议将类名从 AbstractMiniMap 修改为更具体的名称，如 MiniMapImpl
    AbstractMiniMap<Double, Double> map2 = new AbstractMiniMap<>(); // 假设已移除 abstract
    System.out.println("移除 abstract 后创建的实例：" + map2.getClass().getName());
}

// 解决方案三a：创建特定类型子类
public class DoubleMiniMap extends AbstractMiniMap<Double, Double> {
    // 构造器：可以调用父类的构造器
    public DoubleMiniMap() {
        super(); // 调用 AbstractMiniMap 的无参构造器
    }

    // 如果 AbstractMiniMap 有抽象方法，必须在此处实现它们
    // 例如：
    // @Override
    // public void push(Double key, Double value) {
    //     // 具体实现
    // }
    // @Override
    // public Double remove(Double key) {
    //     // 具体实现
    //     return null;
    // }
}

public static void main(String[] args) {
    // 实例化特定类型子类
    DoubleMiniMap map3a = new DoubleMiniMap();
    System.out.println("使用特定类型子类创建的实例：" + map3a.getClass().getName());
}

// 解决方案三b：创建泛型子类
public class GenericMiniMap<K, V> extends AbstractMiniMap<K, V> {
    // 构造器：可以调用父类的构造器
    public GenericMiniMap() {
        super(); // 调用 AbstractMiniMap 的无参构造器
    }

    // 如果 AbstractMiniMap 有抽象方法，必须在此处实现它们
    // 例如：
    // @Override
    // public void push(K key, V value) {
    //     // 具体实现
    // }
    // @Override
    // public V remove(K key) {
    //     // 具体实现
    //     return null;
    // }
}

public static void main(String[] args) {
    // 实例化泛型子类
    GenericMiniMap<Double, Double> map3b = new GenericMiniMap<>();
    GenericMiniMap<String, Integer> map3c = new GenericMiniMap<>();
    System.out.println("使用泛型子类创建的实例 (Double, Double)：" + map3b.getClass().getName());
    System.out.println("使用泛型子类创建的实例 (String, Integer)：" + map3c.getClass().getName());
}