class MyCircularQueue:

    def __init__(self, k: int):
        self.data = [0] * k
        self.head = 0
        self.tail = -1
        self.size = 0
        self.capacity = k

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        self.tail = (self.tail + 1) % self.capacity
        self.data[self.tail] = value
        self.size += 1
        return True

    def deQueue(self) -> bool:
        if self.isEmpty():
            return False
        self.head = (self.head + 1) % self.capacity
        self.size -= 1
        return True

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        return self.data[self.head]

    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        return self.data[self.tail]

    def isEmpty(self) -> bool:
        return self.size == 0

    def isFull(self) -> bool:
        return self.size == self.capacity

The circular queue is implemented using an array with fixed capacity. The operations are performed based on FIFO principle, and the last position is connected back to the first position to make a circle. We keep a head and tail pointer, as well as the current size of the queue. Whenever an element is enqueued, we move the tail pointer forward (circulating back to the start of the array when necessary) and increase the size. When an element is dequeued, we move the head pointer forward and decrease the size. We can check if the queue is empty by comparing the size to 0 and check if the queue is full by comparing the size to the capacity. All operations have O(1) time complexity.

class MyCircularQueue {
public:
    MyCircularQueue(int k) {
        data.resize(k);
        head = 0;
        tail = -1;
        size = 0;
        capacity = k;
    }

    bool enQueue(int value) {
        if (isFull()) {
            return false;
        }
        tail = (tail + 1) % capacity;
        data[tail] = value;
        size++;
        return true;
    }

    bool deQueue() {
        if (isEmpty()) {
            return false;
        }
        head = (head + 1) % capacity;
        size--;
        return true;
    }

    int Front() {
        if (isEmpty()) {
            return -1;
        }
        return data[head];
    }

    int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return data[tail];
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity;
    }

private:
    vector<int> data;
    int head, tail, size, capacity;
};

The circular queue is implemented using an array with fixed capacity. The operations are performed based on FIFO principle, and the last position is connected back to the first position to make a circle. We keep a head and tail pointer, as well as the current size of the queue. Whenever an element is enqueued, we move the tail pointer forward (circulating back to the start of the array when necessary) and increase the size. When an element is dequeued, we move the head pointer forward and decrease the size. We can check if the queue is empty by comparing the size to 0 and check if the queue is full by comparing the size to the capacity. All operations have O(1) time complexity.