您可以将其用作递归幂函数：

public static int powerOf2(int number) {
    if (number == 0) {
        return 1;
    } else {
        return 2 * powerOf2(number - 1);
    }
}

或者，作为一行正文：

return number > 0 ? 2 * powerOf2(number - 1) : 1;

你应该定义另一个递归方法来递归计算Math.pow（2，n）。但是我建议做2的移位操作来快速计算Math.pow（2，n）。例如移位2〈〈（n-1）将在这里做hob。

如果你想学习递归，以法波纳契级数为例。

public int getNthFibonacci( int n )
    {
        if ( n == 1 || n == 2 ) 
            return 1;

      else
        return getNthFibonacci( n-1 ) + getNthFibonacci( n-2 );
    }

public static void main(String[] args){

        Recursion myRecursor = new Recursion();
        System.out.println( myRecursor.getNthFibonacci(5) );

    }

但在您的情况下，它可以通过for循环轻松完成。

public static void main(String[] args) {

       int sum = 0;     
        for (int number = 20; number>0; number--)
        {
            sum += Math.pow(2,number);
        }

        System.out.println(sum);

}

更一般的解决方案：

public static int pow (int base, int ex) {
    if (ex == 0) {
        return 1;
    } else if (ex == 1) {
        return base;
    } else if(ex > 1) {
        return (pow(base, ex - 1) * base);
    } else {
        return pow(base, ex + 1) / base;
    }
}

这将处理传递的值为整数的所有可能情况。

也许有点远离严格的问题，你的问题是计算总和几何级数其中 * 是一个系列之间的一个常数比连续的条款 *。
你的第一个元素等于1（2的幂等于0），你的比值等于2，所以你可以用一个常见的、众所周知的等式来代替递归：

public long computGemetricSeries(int n) {
  long firstElem = 1;
  long ratio = 2;

  return (firstElem * (1 - Math.pow(ration,n)) / (1 - ratio));
}

或者对于一般术语（不仅是幂o 2）：

public long computGeometricSeries(int n, double ration, double firstElem) {
   return (firstElem * (1 - Math.pow(ration,n)) / (1 - ration));
}

如果你真的想在这里递归，你可以把Math.pow(ration,n)改成其他答案中提出的递归函数。
我认为它不会帮助解决你的问题，但会是一个很好的好知道答案。

public class ComputePowerUsingRecursion {

    public static void main(String[] args) {    
        System.out.println(computePower(2,5));  // Passing 2 for power of 2
        System.out.println(computePower(2,-5)); // Number would be +ve or -ve
    }

    /**
     * <p>Compute power</p>
     * 
     *  p(x,n)  =  1              if(x=0)
     *          =  x*p(x,n-1)     if(n>0)
     *          =  (1/x)*p(x,n+1) if(n<0)  
     * @param x
     * @param n
     * @return
     */
    public static double computePower(double x, double n){
        //base case
        if(n==0){
            return 1;
        }else if(n>0){   //recursive condition for postive power
            return x*computePower(x, n-1);
        }else if(n<0){  //recursive condition for negative power
            return (1/x)*computePower(x, n+1);
        }else{ 
            return -1;
        }
    }
}

public static void main (String[] args){
    Integer output = 0;
    output = sumOfThePower(end, 1, 1); //input the number you like at 'end' to get the sum
    System.out.println(output);
}
public static Integer sumOfThePower (int end, int start, int mul){
if (start <= end){
    mul =2 * mul;
    return mul + sumOfThePower(end, start + 1, mul);
}
else{
    return 1;
}
}

从这个问题我的假设是你想加上一个例子，

2 + 4 + 8 = 14 by calling func(3)
2 + 4 + 8 + 16 = 30 by calling func(4)

如果是的话，你可以试试，

public static int SumPowerOf2(int number) {
if (number == 1) {
    return 2;
} else {
    return 2 + (2 * powerOf2(number - 1));
}

通过每个堆栈的帧，我们应该对SumPowerOf2（3）进行以下分析

SumPowerOf2(3) => 2 + (2 * SumPowerOf2(2)) = 2 + 2(6) => 2 + 12 => 14
SumPowerOf2(2) => 2 + (2 * SumPowerOf2(1)) => 2 + 2(2) => 2 + 4 => 6
SumPowerOf2(1) => 2