贴一个小程序

1. /*
   
2. 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n，当输入n为奇数时，调用函数1/1+1/3+...+1/n
   
3. */
   
4. import java.io.*;
   
5. class GetSum
   
6. {
   
7.         public static void main(String[] args) throws IOException
   
8.         {
   
9.                 BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
   
10.                 double n=Integer.parseInt(bufr.readLine());
    
11.                 if(n%2==0)
    
12.                         System.out.println(new GetSum_2().qiuHe(n));
    
13.                 else
    
14.                         System.out.println(new GetSum_3().qiuHe(n));
    
15.                 bufr.close();
    
16. 
    
17.                 //System.out.println("Hello World!");
    
18.         }
    
19. }
    
20. //接口
    
21. interface QiuHe
    
22. {
    
23.         public double qiuHe(double n);
    
24. }
    
25. 
    
26. //求偶数
    
27. class GetSum_2 implements QiuHe
    
28. {
    
29.         public double qiuHe(double n)
    
30.         {       
    
31.                 double sum=0;
    
32.                 for (int x=2;x<=n ;x+=2 )
    
33.                 {
    
34.                         sum+=1.0/x;
    
35.                 }
    
36.                 return sum;
    
37.         }
    
38. }
    
39. 
    
40. //求奇数
    
41. class GetSum_3 implements QiuHe
    
42. {
    
43.         public double qiuHe(double n)
    
44.         {
    
45.                 double sum=0;
    
46.                 for (int x=1;x<=n ;x+=2 )
    
47.                 {
    
48.                         sum+=1.0/x;
    
49.                 }
    
50.                 return sum;
    
51.         }
    
52. }
    

复制代码

上面的例子是不是类似指针的功能，这个题还可以用递归做出来

1. /*
   
2. 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n，当输入n为奇数时，调用函数1/1+1/3+...+1/n
   
3. 使用递归
   
4. */
   
5. 
   
6. class Demo_3
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 double a=getSum(2);
    
11.                 System.out.println(a);
    
12.         }
    
13.         public static double getSum(int n)
    
14.         {
    
15.                 while(n!=0)
    
16.                 {
    
17.                 if(n==1)
    
18.                         return 1.0;
    
19.                 else if(n%2==0)
    
20.                         return 1.0/n+getSum(n-2);
    
21.                 else if(n%2==1)
    
22.                         return 1.0/n+getSum(n-2);
    
23.                 }
    
24.                 return 0.0;
    
25.         }
    
26. }
    

复制代码

JAVA中的引用变量代表的是对象的地址值，相当于指针

接口不算是指针，在java中引用差不多实现了指针的功能。
指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解，所以java放弃了指针。但实质上每一个new语句返回的都是一个指针的引用。一个对象会从实际的存储空间的某个位置开始占据一定数量的存储体。该对象的指针就是一个保存了对象存储地址的变量，并且这个存储地址就是对象在存储空间中的起始地址。在许多高级语言中指针是一种数据类型，而在Java中是使用对象的引用来替代的。考虑如下代码：
People p = NULL; q = new People("Jack","0001");

      这里创建了两个对于对象引用的变量p和q。变量p初始化为null，null是一个空指针，它不指向任何地方，也就是它不指向任何类的对象，因此null可以赋值给任何类的对象的引用。变量q是一个对于People类的实例的引用，操作符new的作用实际上是为对象开辟足够的内存空间，而引用p是指向这一内存空间地址的指针。

在java中的变量引用相当于指针操作的功能

Java没有函数指针，但提供了Reflection反射机制。你可以参考API文档.另外，Java在一般常见的模拟函数指针（或者说实现类似功能）的地方用的是接口和类（通常是匿名的内部类），也就是说，通过传递对象引用实现的。