Creating a virtual machine runtime in Java that has an operand stack and a context stack for frames involves implementing the core components of a simple runtime environment. Here’s a basic implementation of such a runtime:

### Step 1: Define the Frame for the Call Stack

Frames will be used to model the contexts that the virtual machine (VM) executes.

```java
import java.util.Stack;

class Frame {
    private Stack<Integer> operandStack;
    private int[] localVariables;

    public Frame(int maxLocals) {
        operandStack = new Stack<>();
        localVariables = new int[maxLocals];
    }

    public void push(int value) {
        operandStack.push(value);
    }

    public int pop() {
        return operandStack.pop();
    }

    public void setLocalVariable(int index, int value) {
        localVariables[index] = value;
    }

    public int getLocalVariable(int index) {
        return localVariables[index];
    }

    public Stack<Integer> getOperandStack() {
        return operandStack;
    }
}
```

### Step 2: Define the Virtual Machine

The virtual machine will use a stack of Frames to manage function calls.

```java
import java.util.Stack;

class VirtualMachine {
    private Stack<Frame> contextStack;

    public VirtualMachine() {
        contextStack = new Stack<>();
    }

    public void pushFrame(Frame frame) {
        contextStack.push(frame);
    }

    public void popFrame() {
        contextStack.pop();
    }

    public Frame currentFrame() {
        return contextStack.peek();
    }

    public void execute(byte[] bytecode) {
        int pc = 0; // program counter

        while (pc < bytecode.length) {
            int opcode = bytecode[pc++];
            switch (opcode) {
                case 0x01: // ICONST_0
                    currentFrame().push(0);
                    break;

                case 0x02: // ICONST_1
                    currentFrame().push(1);
                    break;

                case 0x03: // IADD (Addition)
                    int value1 = currentFrame().pop();
                    int value2 = currentFrame().pop();
                    currentFrame().push(value1 + value2);
                    break;

                case 0x04: // ISTORE (Store variable)
                    int index = bytecode[pc++];
                    int value = currentFrame().pop();
                    currentFrame().setLocalVariable(index, value);
                    break;

                case 0x05: // ILOAD (Load variable)
                    index = bytecode[pc++];
                    currentFrame().push(currentFrame().getLocalVariable(index));
                    break;

                case 0x06: // RETURN
                    popFrame();
                    return;

                default:
                    throw new IllegalArgumentException("Unknown opcode " + opcode);
            }
        }
    }
}
```

### Step 3: Define a Sample Bytecode Program

This sample program will create a frame, run the virtual machine, and exercise the functionality to perform some arithmetic and store results.

```java
public class VirtualMachineDemo {
    public static void main(String[] args) {
        VirtualMachine vm = new VirtualMachine();

        // Sample bytecode: Equivalent to:
        // int a = 1 + 0;
        // return a;
        byte[] bytecode = new byte[] {
            0x02,         // ICONST_1: Push 1 onto the operand stack
            0x01,         // ICONST_0: Push 0 onto the operand stack
            0x03,         // IADD: Add the top two values
            0x04, 0x00,   // ISTORE 0: Store the result in local variable at index 0
            0x05, 0x00,   // ILOAD 0: Load the value from index 0 onto the operand stack
            0x06          // RETURN: Return from the frame
        };

        Frame mainFrame = new Frame(1); // A single local variable
        vm.pushFrame(mainFrame);

        vm.execute(bytecode);

        // Output the result
        int result = mainFrame.getOperandStack().pop();
        System.out.println("Result is: " + result);
    }
}
```

### Explanation:

1. **Frame Class:** Manages the operand stack and local variables.
2. **Virtual Machine Class:** Simulates a basic VM that can execute a simple sequence of bytecodes.
3. **Bytecode Implementation:** The codes simulate integer operations (add, store, load).

### Output:
```
Result is: 1
```

### Extending the VM:

If you wish to expand this virtual machine, consider adding more opcodes such as subtraction (`ISUB`), multiplication (`IMUL`), branching (`GOTO`), function calls, and even object-like structures.

This is a simple framework that gives you the fundamentals needed to implement a basic operating VM for learning purposes or simple projects.