Powers of 2 can simply be computed by Bit Shift Operators

int exponent = ...
int powerOf2 = 1 << exponent;

Even for the more general form, you should not compute an exponent by "multiplying n times". Instead, you could do Exponentiation by squaring

When it's a power of 2 keep in mind that you can use a simple and fast shift expression: 1 << exponent

For example:

2² = 1 << 2 = (int) Math.pow(2, 2)
2¹⁰ = 1 << 10 = (int) Math.pow(2, 10)

For larger exponents (over 31) use long instead:

2³² = 1L << 32 = (long) Math.pow(2, 32)

BTW, in Kotlin you have shl instead of <<:

(Java) 1L << 32 = 1L shl 32 (Kotlin)

What you are asked for is to check if the number passed as an argument to the function is a power of 2, and if it is, what is the power of 2 that sums up to aNumber. (2^x = aNumber) - you want to find x.

For example if you pass 8 to the function, you should return 3, since 2^3 = 8. But if the number isn't the power of 2, you should return -1 - for example if the parameter is 9, there is no integral power of 2 that can result in 9.

Regarding your program, you can make it work with some minor modifications:

What you want to do is make a loop and in every iteration check if the input number is dividable by 2 (aNumber % 2 == 0), and if it is divide it by two (aNumber = aNumber / 2). If you can get to 1 in this way, that means that your number is a power of two, and you just have to count the iterations (number of times you divided aNumber by 2). So your function might look like this:

private static int powerOf2(int aNumber)
{
    int power = 0;
    if(aNumber % 2 != 0)
    {
        return -1;
    }
    else
    {
        System.out.print(aNumber + " is 2 raised to ");
        while (true)
        {
            if(aNumber % 2 == 0){
            aNumber /= 2;
            power++;
            if(aNumber == 1) return power;
            }else{
                return -1;
            }

        }

    }
}

The case with b<0 only makes sense with floating point numbers, so I changed the type of a and the return value to double.

public static double mathPower(double a, int b) 
{
    double result = 1;

    if (b < 0) {
       a = 1.0 / a;
       b = -b;
    }

    for (int  i = 0; i < b; i++) {
        result = result * a;
    }

    return result;
}

First, observe that pow(a,x) = exp(x * log(a)).

You can implement your own exp() function using the Taylor series expansion for e^x:

e^x = 1 + x + x²/2! + x³/3! + x⁴/4! + x⁵/5! + ...

This will work for non-integer values of x. The more terms you include, the more accurate the result will be.

Note that by using some algebraic identities, you only need to resort to the series expansion for x in the range 0 < x < 1 . exp(int + frac) = exp(int)*exp(frac), and there's no need to use a series expansion for exp(int). (You just multiply it out, since it's an integer power of e=2.71828...).

Similarly, you can implement log(x) using one of these series expansions:

log(1+x) = x - x²/2 + x³/3 - x⁴/4 + ...

or

log(1-x) = -1 * (x + x²/2 + x³/3 + x⁴/4 + ... )

But these series only converge for x in the interval -1 < x < 1. So for values of a outside this range, you might have to use the identity

log(pq) = log(p) + log(q)

and do some repeated divisions by e (= 2.71828...) to bring a down into a range where the series expansion converges. For example, if a=4, you'd have to take take x=3 to use the first formula, but 3 is outside the range of convergence. So we start dividing out factors of e:

4/e = 1.47151...

log(4) = log(e*1.47151...) = 1 + log(1.47151...)

Now we can take x=.47151..., which is within the range of convergence, and evaluate log(1+x) using the series expansion.

You are considering if n is negative in the n % 2 != 0 case, but not in the else case. To make it clearer, I would handle it in a different recursive case. Take the negative n handling out of the if block, and add this line after the if(n == 0) line.

if (n < 0) return 1 / myPow(x, -n);

This also eliminates the integer division you were doing in this line: return (1 / t * t * x);. It also had the error that you would have divided by t, multiplied by t, then multiplied by x, instead of dividing by the entire product.