如何实现PriorityQueue类继承Queue类并添加priority属性？

嘿，这个需求其实很常见——让子类继承父类的功能，同时扩展专属的属性和逻辑。我给你准备了两种主流编程语言的实现方案，你可以直接对应到自己的开发场景：

首先，先假设你的基础Queue类已经实现了核心操作（如果你的Queue类结构不同，只需要调整子类的继承逻辑即可）：

class Queue:
    def __init__(self):
        self.items = []
    
    def insert(self, item):
        self.items.append(item)
    
    def delete(self):
        if not self.is_empty():
            return self.items.pop(0)
        raise IndexError("Queue is empty")
    
    def search(self, item):
        return item in self.items
    
    def is_empty(self):
        return len(self.items) == 0

接下来创建PriorityQueue子类，继承Queue并添加优先级相关属性，同时适配优先级队列的核心逻辑：

class PriorityQueue(Queue):
    def __init__(self):
        super().__init__()  # 调用父类构造方法，继承父类的items等属性
        self.priority_map = {}  # 用字典存储元素与优先级的映射，键为元素，值为优先级数值
    
    # 重写insert方法，新增优先级参数
    def insert(self, item, priority_level):
        # 先调用父类的insert方法添加元素
        super().insert(item)
        # 记录当前元素的优先级
        self.priority_map[item] = priority_level
        # 可选：按优先级重新排序队列，确保高优先级元素排在队首（这里数值越小优先级越高，可根据需求调整）
        self.items.sort(key=lambda x: self.priority_map[x])
    
    # 新增方法：修改指定元素的优先级
    def update_priority(self, item, new_priority):
        if item in self.priority_map:
            self.priority_map[item] = new_priority
            # 修改后重新排序
            self.items.sort(key=lambda x: self.priority_map[x])
        else:
            raise ValueError("该元素不在优先级队列中")

核心要点：

• 用super().__init__()触发父类的构造逻辑，确保继承到父类的所有属性和方法
• priority_map是子类专属的属性，用来绑定元素和对应的优先级
• 重写insert方法，让它支持优先级参数，同时保证队列按优先级有序排列

先给出基础的Queue类实现（泛型设计让它支持多种数据类型）：

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

public class Queue<T> {
    protected List<T> items;

    public Queue() {
        items = new ArrayList<>();
    }

    public void insert(T item) {
        items.add(item);
    }

    public T delete() {
        if (!isEmpty()) {
            return items.remove(0);
        }
        throw new NoSuchElementException("队列已空");
    }

    public boolean search(T item) {
        return items.contains(item);
    }

    public boolean isEmpty() {
        return items.isEmpty();
    }
}

然后实现PriorityQueue子类，通过内部类封装元素与优先级的关系，同时继承父类的功能：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class PriorityQueue<T> extends Queue<T> {
    // 存储元素与优先级的绑定关系
    private List<PriorityEntry<T>> priorityEntries;

    // 内部类：封装元素和对应的优先级
    private static class PriorityEntry<T> {
        T item;
        int priority;

        public PriorityEntry(T item, int priority) {
            this.item = item;
            this.priority = priority;
        }
    }

    public PriorityQueue() {
        super(); // 调用父类构造，继承items属性
        priorityEntries = new ArrayList<>();
    }

    // 重载insert方法，支持指定优先级
    public void insert(T item, int priority) {
        priorityEntries.add(new PriorityEntry<>(item, priority));
        // 按优先级排序（数值越小优先级越高）
        priorityEntries.sort(Comparator.comparingInt(entry -> entry.priority));
        // 同步更新父类的items列表，保证父类的delete、search方法能正常工作
        items.clear();
        for (PriorityEntry<T> entry : priorityEntries) {
            items.add(entry.item);
        }
    }

    // 重写父类的insert方法，提供默认优先级
    @Override
    public void insert(T item) {
        insert(item, 1); // 默认优先级为1
    }

    // 新增方法：获取指定元素的优先级
    public Integer getPriority(T item) {
        for (PriorityEntry<T> entry : priorityEntries) {
            if (entry.item.equals(item)) {
                return entry.priority;
            }
        }
        return null;
    }
}

核心要点：

• 通过super()调用父类构造，确保继承父类的属性
• 用内部类PriorityEntry来绑定元素和优先级，比并行列表更易维护
• 重载insert方法支持优先级参数，同时同步父类的items列表，保证父类方法的兼容性

内容的提问来源于stack exchange，提问作者Goutham18