public  class rabbit
                {
                                public int month;
                                public int rabbitNumber;                                                                                                                        //对象的属性。
                                public int rb( int month )                                                         //定义一个方法调用属性。
                                        {
                                                        private int  f ,f1 ,f2 ;
                                                        f1=1;
                                                        f2=1;
                                                        for (int i = 3; i < month ; i++)
                                                        {
                                                                f = f2;
                                                                f2 =f1+f2;
                                                                f1 = f;
                                                        }
                                                        return rabbitNumber=f2;
                                        }
                }
help......................................

因为private修饰符是使用在类的 ，如果在在类中声明一个成员变量使用private修饰后，这个变量只能被这个类中的方法所访问，而在方法体中声明变量，这个变量的作用域是从这个变量声明直到方法体结束，如果再使用private修饰的话两者就会冲突，所以不能在方法体内声明一个变量为private，而且在方法里声明变量为private也没什么意义，方法内声明的变量的作用域本来就在方法体内，也在他本身的类中，自然也不会被其他类中的方法所访问

public int rb（）定义了可以让外界调用的方法，而执行到方法中private int  f ,f1 ,f2   又不允许外界调用，这不就矛盾了吗

1. ~~~~~~~~~~~~~~~~~~~~~~

复制代码

在类体中变量定义部分所声明的变量为类的成员变量，而在方法体中声明的变量和方法的参数则称为局部变量。
局部变量是不能使用public、protected、private和static关键字对局部变量进行修饰的。
本题中int  f ,f1 ,f2 都是局部变量。
将程序修改一下就可以了：


public  class Rabbit //默认的习惯把类的首字母大写;变量，方法的首字母小写!
{
        public static void main (String[] args)//没有主函数程序是不能运行的。
        {
                System.out.println("rabbitNumber="+rb(8));
        }
    public int month;
    public int rabbitNumber;                                                                                                                  
    public static int rb( int month )                                                        
      {
      int  f ,f1 ,f2 ;
      f1=1;
      f2=1;
      for (int i = 3; i < month ; i++)
      {
         f = f2;
         f2 =f1+f2;
         f1 = f;
      }
       return f2;//返回值需为int型
      }
}

  private声明在方法内没什么意义啊，反正也是在方法内运行，出方法就无效了。方法开始就有，方法结束就没了。Sun不可能让他合法的。

在类成员位置上声明的变量为成员变量，
权限修饰符有public，默认，protected(只有子类可以访问),private(只在本类中被访问)
而在方法体中声明的变量和方法的参数则称为局部变量。
局部变量是不能使用权限修饰符对局部变量进行修饰的。

朱俊 发表于 2012-3-28 12:21

恩 谢谢。

private int  f ,f1 ,f2 ;
f、f1、f2本身就在方法内部，属于局部变量，外界根本无法访问，方法调用结束后，变量自动释放空间。
所以根本没有必要进行私有。方法内，局部变量所以私有错误。

杨华威 发表于 2012-3-28 13:56
private int  f ,f1 ,f2 ;
f、f1、f2本身就在方法内部，属于局部变量，外界根本无法访问，方法调用结束后， ...

{:3_49:}才迷瞪过来。。。。

耿世玉 发表于 2012-3-28 13:58
才迷瞪过来。。。。

呵呵，明白了就好。知识就是在错误中积累得到的。

..我想知道你个类是什么个意思 那个功能方法是啥意思 。。。

抓哇 发表于 2012-3-28 14:09
..我想知道你个类是什么个意思 那个功能方法是啥意思 。。。

代码没发完，4楼是正解。

耿世玉 发表于 2012-3-28 14:21
代码没发完，4楼是正解。

私有修饰符是修饰类或者类成员的  局部变量不能用其修饰 去掉那个就可以了 别的我觉得都是OK的

抓哇 发表于 2012-3-28 14:26
私有修饰符是修饰类或者类成员的  局部变量不能用其修饰 去掉那个就可以了 别的我觉得都是OK的 ...

return rabbitNumber=f2;
这个不ok 啊。

局部变量私有是不对的

private 修饰符，修饰的是该类中的成员，用来修饰局部变量是非法的。所以这段代码的private去掉就可以，另外return rabbitNumber=f2;
这个不ok 啊。
楼主能不能发个完整代码，看看，要不给个主函数也行..别忘了调用rb函数时输入的month值最小是4。

吴玉辉 发表于 2012-3-28 18:48
private 修饰符，修饰的是该类中的成员，用来修饰局部变量是非法的。所以这段代码的private去掉就可以，另 ...

程序写的太乱了我都不好意思发上来。在论坛里搜兔子数列有类似的。{:3_47:}

去掉修饰符的问题，实在看不出你的return语句有什么问题。要不你先给rabbitNumber初始化随便赋个值试试?~~
这是我写的兔子数列，都可以运行，希望对你有帮助~
class SumPerMonth
{
        public static void main(String[] args)
        {
                System.out.println(sum(6));
        }
        public static int sum(int month)
        {
                int rabbitNumber = 1;
                int sum = 0;
                int temp = 1;
                for(int x=0;x<month;x++)
                {
                        if(x==0 || x==1 || x==2)
                                sum = 1;
                        else
                        {
                                sum = temp+rabbitNumber;
                                rabbitNumber = temp;
                                temp = sum;
                        }       
                }
                return sum*2;

        }
}
这个是类方法调用的：
class SumPerMonth1
{
        public static void main(String[] args)
        {
                RabSum rab = new RabSum();
                System.out.println(rab.sum(7));
        }
}
class RabSum
{
        private int rabbitNumber = 1;
        private int sum = 0;
        private int temp = 1;
        public int sum(int month)
        {
          for(int x=0;x<month;x++)
                {
                        if(x==0 || x==1 || x==2)
                                sum = 1;
                        else
                        {
                                sum = temp+rabbitNumber;
                                rabbitNumber = temp;
                                temp = sum;
                        }
                }
                return sum*2;
        }
}

private修饰：
在方法体中声明变量，这个变量的作用域是从这个变量声明直到方法体结束，
如果再使用private修饰的话两者就会冲突，所以不能在方法体内声明一个变量
为private，而且在方法里声明变量为private也没什么意义，方法内声明的变量
的作用域本来就在方法体内，也在他本身的类中，自然也不会被其他类中的方法
所访问。

在类成员位置上声明的变量为：成员变量
给你举一个小小的实例代码：
class stu
{
        private String name; //成员变量
        private int age;  //成员变量
       
        public void run()//定义一个方法“跑”（run()）
        {
                int stuFast; //在run()函数（也成为方法）当中声明了一个
                             //int 型的变量来控制跑的速度，注意该变量
                             //本身就只能在run()函数当中使用，默认为：
                             //private,因此就没有必要在加上修饰符了。
        }
}
public class Demo
{
        public static void main[String[] args]
        {
       
        }
}
权限修饰符有public，默认，protected(只有子类可以访问),private(只在本类中被访问)
而在方法体中声明的变量和方法的参数则称为局部变量。
局部变量是不能使用权限修饰符对局部变量进行修饰的。