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)

You can test if a positive integer n is a power of 2 with something like

(n & (n - 1)) == 0

If n can be non-positive (i.e. negative or zero) you should use

(n > 0) && ((n & (n - 1)) == 0)

If n is truly a power of 2, then in binary it will look like:

10000000...

so n - 1 looks like

01111111...

and when we bitwise-AND them:

  10000000...
& 01111111...
  -----------
  00000000...

Now, if n isn't a power of 2, then its binary representation will have some other 1s in addition to the leading 1, which means that both n and n - 1 will have the same leading 1 bit (since subtracting 1 cannot possibly turn off this bit if there is another 1 in the binary representation somewhere). Hence the & operation cannot produce 0 if n is not a power of 2, since &ing the two leading bits of n and n - 1 will produce 1 in and of itself. This of course assumes that n is positive.

This is also explained in "Fast algorithm to check if a positive number is a power of two" on Wikipedia.

Quick sanity check:

for (int i = 1; i <= 100; i++) {
    if ((i & (i - 1)) == 0)
        System.out.println(i);
}

1
2
4
8
16
32
64

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;
}

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.