Glad you're taking on Java!

You should study Object Oriented Programming (OOP), which is core in Java, a little bit more to use classes in a more suitable and efficient way.

The general rule of a class is "one class one purpose" which it looks like you're trying to apply, but since you don't have any objects, it becomes a bit arbitrary.

An example would be to have a class called `Calcualtor` that has functions for what a calculator could do, then you could have another class called `InputHandler` that handles the reading from the user interface _(in this case that's the terminal)_. It's very bad to call the Main class in all classes, it's very backwards, main is supposed to handle the other classes and there's only one Main.

Because of the structure you have here you notice that you find yourself using `static` a lot, we call this "static overuse". If you apply OOP properly you won't need static unless there's an intended use, like a variable that never changes and is the same for all objects of that type.

You should be fine by just rearranging your methods into objects and call them from main:


    public class Main {
        public static void main(String[] args) {
            InputHandler inputHandler = new InputHandler();
            inputHandler.start();
        }
    }

Input Handler:

    public class InputHandler {
        /* Notice how I put the calculator and scanner up in the 
           object-scope, you can now re-use them throughout this object.
        */
        private Calculator calculator = new Calculator();
        private Scanner sc = new Scanner(System.in);
        private boolean keepOn = true;
    
        public void start() {
            System.out.println("Welcome to my calculator!");
            performAction(1);
            while(keepOn == true) {
                calculate();
            }
        }
        
        public void calculate() {
           int action = selectAction();
           performAction(action);
        }
    
        public double getFirstNumber() {
            System.out.println("Input the 1st number");
            return sc.nextDouble();
        }
    
        public double getSecondNumber() {
            System.out.println("Input the 2nd number");
            return sc.nextDouble();
        }
    
        public char chooseOperator() {
            System.out.println("What to do?" +
                    "\n + for add" +
                    "\n - for minus" +
                    "\n * for multiply" +
                    "\n / for divide" +
                    "\n % for mod" +
                    "\n ^ for first number into the power of second number");
    
            String operator = sc.next();
            return operator.charAt(0);
        }
    
        public int selectAction() {
            System.out.println("Dormammu, I came to bargain! " +
                    "Wanna do some extra calculations?" +
                    "\n 1 - for 'Yes'" +
                    "\n 2 - for 'No'");
            int dormammu = sc.nextInt();
            return dormammu;
        }
    
        public double performCalculation() {
            char operand = chooseOperator();
            double firstNumber = getFirstNumber();
            double secondNumber = getSecondNumber();
            double result = calculator.calculate(firstNumber, secondNumber, operand);
            System.out.println("The result of " + firstNumber + operand + secondNumber + "is: " + result);
            return result;
        }
    
        public void performAction(int action) {
            switch (action) {
                case 1:
                    performCalculation();
                    break;
                case 2:
                    System.out.println("Okay! Nobody misses you" +
                            "\n But here's the calculations you've done so far");
                    for (int i = 0; i < calculator.calculations.size(); i++) {
                        System.out.println(calculator.calculations.get(i));
                    }
                    keepOn = false;
                    break;
                default:
                    System.out.println("Shit, wrong answer, try again!");
                    calculate();
            }
        }
    }
    
And the calculator:

    public class Calculator {
        public Vector<Double> calculations = new Vector<>();
    
        public double calculate(double firstNumber, double secondNumber, char operand) {
            switch (operand) {
                case '+':
                    calculations.addElement((firstNumber + secondNumber));
                    return firstNumber + secondNumber;
                case '-':
                    calculations.addElement((firstNumber - secondNumber));
                    return firstNumber - secondNumber;
                case '*':
                    calculations.addElement((firstNumber * secondNumber));
                    return firstNumber * secondNumber;
                case '/':
                    calculations.addElement((firstNumber / secondNumber));
                    return firstNumber / secondNumber;
                case '%':
                    calculations.addElement((firstNumber % secondNumber));
                    return firstNumber % secondNumber;
                case '^':
                    calculations.addElement(Math.pow(firstNumber, secondNumber));
                    return Math.pow(firstNumber, secondNumber);
                default:
                    System.out.println("Oops! Received an operand that's not supported! How'd that happen?");
                    throw new UnsupportedOperationException();
            }
        }
    }

This is just a small refactoring of your code. You should always treat user input with great care and use `try-catch` to make sure the input is what you expect. Your application will crash if you type `no` instead of `2`.

Also notice how I used some recursion in `performAction(int action)` where if you do not get the expected answer it re-attempts to do the calculation. This however only works if the other answer is a digit. I'd recommend you try to read a String and then `try` to convert it to an int using `Integer.valueOf("1")` and `catch` errors if it's not a number.