Certainly! Building a virtual machine (VM) with an operand stack and a context stack for frames involves simulating how a typical stack-based virtual machine operates. Below is a simple example in Java that demonstrates the core structure of such a VM.

### VM Components

1. **Operand Stack**: This is where the runtime stores intermediate operands during execution of instructions.
2. **Context Stack (Frame Stack)**: This manages the call stack containing frames, each of which can hold the context for a particular method invocation, including local variables, the instruction pointer (program counter), etc.

### Simplified VM Example in Java

```java
import java.util.List;
import java.util.Stack;

public class SimpleVM {

    // Operand Stack
    private Stack<Integer> operandStack = new Stack<>();

    // Context Stack
    private Stack<Frame> contextStack = new Stack<>();

    // Basic instruction set
    public void execute(List<String> instructions) {
        Frame currentFrame = new Frame();
        contextStack.push(currentFrame);

        while (currentFrame.instructionPointer < instructions.size()) {
            String instruction = instructions.get(currentFrame.instructionPointer);
            currentFrame.instructionPointer++;

            switch (instruction) {
                case "PUSH":
                    currentFrame.instructionPointer++;
                    try {
                        int value = Integer.parseInt(instructions.get(currentFrame.instructionPointer));
                        operandStack.push(value);
                    } catch (NumberFormatException e) {
                        throw new IllegalArgumentException("Invalid PUSH operand.");
                    }
                    break;
                case "POP":
                    operandStack.pop();
                    break;
                case "ADD":
                    int b = operandStack.pop();
                    int a = operandStack.pop();
                    operandStack.push(a + b);
                    break;
                case "SUB":
                    int d = operandStack.pop();
                    int c = operandStack.pop();
                    operandStack.push(c - d);
                    break;
                case "MUL":
                    int f = operandStack.pop();
                    int e = operandStack.pop();
                    operandStack.push(e * f);
                    break;
                case "DIV":
                    int h = operandStack.pop();
                    int g = operandStack.pop();
                    operandStack.push(g / h);
                    break;
                case "PRINT":
                    System.out.println(operandStack.peek());
                    break;
                case "CALL":
                    currentFrame = new Frame();
                    contextStack.push(currentFrame);
                    break;
                case "RETURN":
                    currentFrame = contextStack.pop();
                    break;
                default:
                    throw new IllegalArgumentException("Unknown instruction: " + instruction);
            }
        }
    }

    // Context Frame that holds the program counter and local variables can be added here too
    private class Frame {
        int instructionPointer = 0;
        // You can add local variables here if needed
    }

    public static void main(String[] args) {
        // Example Instructions
        List<String> instructions = List.of(
                "PUSH", "10",
                "PUSH", "20",
                "ADD",
                "PUSH", "5",
                "SUB",
                "PRINT" // Should print 25
        );

        SimpleVM vm = new SimpleVM();
        vm.execute(instructions);
    }
}
```

### Breakdown of the VM workings:

1. **Core Operations**:
   - `PUSH`: Pushes a value onto the operand stack.
   - `POP`: Pops the top value from the operand stack.
   - `ADD`, `SUB`, `MUL`, `DIV`: Performs arithmetic operations on the top two items of the operand stack and pushes the result back onto the stack.
   - `PRINT`: Outputs the value at the top of the operand stack.
   - `CALL`: Starts a new context frame on the context stack.
   - `RETURN`: Returns from the current context frame to the previous one.

2. **Frame Management**:
   - The `Frame` class simulates a method call frame, and `contextStack` manages all the frames.
   - When you do a `CALL`, a new frame is pushed, and when you do a `RETURN`, the current frame is popped.

3. **Instruction Pointer Management**:
   - The `instructionPointer` field in the `Frame` tracks the current instruction.

### Running Example
Running the example provided in the `main` method will execute the simple list of instructions and print the result `25` to the console, demonstrating basic arithmetic stack operations.

### Extensibility
- **Local Variables**: Each `Frame` could be expanded to hold local variables.
- **Complex Instructions**: You could implement more advanced instructions like `IF`, `LOOP`, or even method arguments.
- **Multiple Data Types**: Extend the stack to handle different types such as `float`, `String`, or more complex objects.

This example provides a foundational understanding of how a stack-based virtual machine could work in Java. You can easily build upon this with more robust features as needed for your use cases.