• 方法：必须由其所在类或对象调用才有意义。若方法含有参数：

      1. 形参：方法声明时的参数；

      2. 实参：方法调用时实际传给形参的参数值

 

    • Java的实参值如何传入方法：Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本传入方法内，而参数本身不受影响。

 

      • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参；

      • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。

（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。

（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。

（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。

  1. //定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个
  2. //findArea()方法返回圆的面积。
  3. public class Circle {
  6.     double radius;
  7.     public double findArea(){
  8.        double m=Math.PI*radius*radius;
  10.         return m;
  11.     }
  13. //    public static void main(String[] args) {
  14. //        Circle c1=new Circle();
  15. //        c1.radius=12;
  16. //        c1.findArea();
  17. //        System.out.println(c1.findArea());
  18. //    }
  19. }
  1. //Circle
  2. //（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义
  3. //如下：public void printAreas(Circle c, int time)
  4. //在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
  5. //例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
  6. // （3）在main方法中调用printAreas()方法，调
  7. //用完毕后输出当前半径值。程序运行结果如图
  8. //所示
  9. import java.util.Scanner;
  11. public class PassObject {
  13.    public void printAreas(Circle c,int time ){
  14.             Circle c3 = new Circle();
  15.             System.out.println("Radius\t\t"+"Ares");
  16.          for (int i=0;i<=time;i++)
  17.          {
  18.              c3.radius=i;
  19.              double s=c3.findArea();
  21.              System.out.println( c3.radius+"\t\t\t"+s);
  22.          }
  23.        System.out.println("now radius is:"+(c3.radius+1));
  25.    }
  27.     public static void main(String[] args) {
  28.         PassObject p1=new PassObject();
  29.         Circle c2=new Circle();
  30.         p1.printAreas(c2,5);
  32.     }
  34. }

 

  1. public class recursionTest1 {
  2.     public int ff(int n)
  3.     {
  4.         if (n==1)
  5.         {
  6.             return 1;
  7.         }else
  8.         {
  9.             return n*ff(n-1);
  10.         }
  11.     }
  13.     public static void main(String[] args) {
  14.         recursionTest1 re=new recursionTest1();
  15.         int s=re.ff(10);
  16.         System.out.println(s);
  17.     }
  18. }

 

 

 

  1. public class recursionTest2 {
  2.     public int recursion2(int m)
  3.     {
  4.         if (m==0)
  5.         {
  6.             return 1;
  7.         }else if (m==1)
  8.         {
  9.             return 4;
  10.         }else
  11.         {
  12.             return 2*recursion2(m-1)+recursion2(m-2);
  13.         }
  14.     }
  16.     public static void main(String[] args) {
  17.         recursionTest2 re2=new recursionTest2();
  18.         int x=re2.recursion2(10);
  19.         System.out.println(x);
  20.     }
  21. }

 

 

 

  1. public class recursionTest3 {
  2.     public static void main(String[] args) {
  3.   recursionTest3 re3=new recursionTest3();
  4.         System.out.println("f(10)="+re3.jj(10));
  5.         System.out.println("f(9)="+re3.jj(9));
  6.         System.out.println("f(8)="+re3.jj(8));
  7.         System.out.println("f(11)="+re3.jj(11));
  8.         System.out.println("f(12)="+re3.jj(2));
  10.     }
  11.     public long jj(int x)
  12.     {
  13.         if (x==21)
  14.         {
  15.             return 4;
  16.         }else if (x==20)
  17.         {
  18.             return 1;
  19.         }else if (x<20)
  20.         {
  21.             return jj(x+2)-(2*jj(x+1));
  22.         }else
  23.         {
  24.             return 2*jj(x-1)+jj(x-2);
  25.         }
  26.     }
  28. }

 

 

 

  1. public class recursionTest4 {
        public int  Fibonacci(int f)
        {
            int num=0;
            if (f==1)
            {
                return 1;
            }else if (f==2)
            {
                return 1;
            }else
            {
                return Fibonacci(f-1)+Fibonacci(f-2);
            }

        }

        public static void main(String[] args) {
            recursionTest4 re4=new recursionTest4();
            int x=re4.Fibonacci(8);
            System.out.println("第八位为："+x);
            int m=8;
            System.out.println("打印前八位：");
            for (int i=1;i<=m;i++)
            {
                System.out.print(re4.Fibonacci(i)+"\t");
            }

        }
    }

 

 

 

版权声明：本文为coopermini原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/coopermini/p/14545615.html