class Test
{
         private static int num =3;
         static class Inner
         {
                 void method()
                 {
                         System.out.println("num="+num);
                 }
         }
         static Inner function()
        {
                 return new Inner();  这句应该怎么理解，为什么这么写？
}
class  NiMingDemo
{
        public static void main(String[] args)
        {

                Test.function().method();
               
        }
}

static Inner function()
        {
                 return new Inner();
   }          这个方法返回值 是一个 Inner 类型的对象。  所以方法体中要new 一个对象嘛。

static Inner function()
        {
                 return new Inner();
   }          这个方法返回值 是一个 Inner 类型的对象。  所以方法体中要new 一个对象嘛。

由于外部类无法直接访问内部类,但是可以通过内部类的方法返回一个内部类的对象,通过这个对象来访问内部类方法。其实function 方法返回的是一个匿名对象。

1. class Test
   
2. {
   
3.          private static int num =3;
   
4.          static class Inner
   
5.          {
   
6.                  void method()
   
7.                  {
   
8.                          System.out.println("num="+num);
   
9.                  }
   
10.          }
    
11.          static Inner function()
    
12.         {
    
13.                  return new Inner();  这句应该怎么理解，为什么这么写？
    
14. }
    
15. class  NiMingDemo
    
16. {
    
17.         public static void main(String[] args)
    
18.         {
    
19. 
    
20.                 Test.function().method();//看主函数 这里 你这里要调用Inner里面的method方法 是不是要 有INNer的对象？？
    
21.                
    
22.         }
    
23. }
    

复制代码

static Inner function()
        {
                 return new Inner();  这句返回的是一个新建的Inner对象
}

return只要返回的内容和返回值类型相同就可以了；
static int[] function()
        {
           int[] arr={2,3,4,7};     
return arr;//这里返回的就是数组 arr
}

孙峰 发表于 2012-6-21 10:43
static Inner function()
        {
                 return new Inner();

但是并没有调用方法  方法就直接打印出来了？？这是为什么呢？？

1. class Test
   
2. {
   
3.           private static int num =3;
   
4.           static class Inner
   
5.          {
   
6.                  void method()
   
7.                   {
   
8.                           System.out.println("num="+num);
   
9.                   }
   
10.           }
    
11.           static Inner function()    //这个方法的返回值类型是 Inner类型
    
12.          {
    
13.                   return new Inner();  //这里返回的是一个Inner类型的匿名对象
    
14. }
    
15. class  NiMingDemo
    
16. {
    
17.          public static void main(String[] args)
    
18.         {
    
19. 
    
20.                 Test.function().method();    //这里相当于new Inner().method()，即创建了一个Inner类型的对象new Inner()，然后调用该对象的method()方法。
    
21.                                                         //Test.function()得到的是一个Inner类型的对象
    
22.         }
    
23. }
    

复制代码

static Inner function()
        {
                 return new Inner();  //这个函数的返回值类型是一个类类型的引用数据，这个函数执行完后的返回语句就应该是一个对象，这里返回的是一个匿名对象。
       }

static Inner function()
        {
                 return new Inner();  
       }
首先看函数的返回值是什么，是Inner，所以return  后面跟的一定是个Inner对象，换个写法你可能就明白了

static Inner function()
        {
                Inner  in = new Inner();
                 return  in;
       }

其实两种写法是一样的，只不过第一种写法的对象没有名字而已。第二种写法的对象有个名字

class Test
{
          private static int num =3;
          static class Inner
         {
                 void method()
                  {
                          System.out.println("num="+num);
                  }
          }
          static Inner function()//这个方法的作用就是为了把内部类对匿名对象的形式向外提供；
         {
                  return new Inner();//1 因为内部类是不能被外部类直接访问；但在开发过程中又必须使用内部类的方法；所以就Test就必须创建一个方法；把这个内部类的对象给
                                             //返回去以便别的类调用并使用其里面的方法；

}
class  NiMingDemo
{
         public static void main(String[] args)
        {

                Test.function().method();//之所以会打印打印是因为这个语句的原因；
              //Test.function()function是静态方法；所以可以被类名直接调用；
              //function()的返回值是Inner; 所以就相当于new Inner();
             //new Inner()是一个匿名对象；function().method()就相当于new Inner().method();而method()的结果就是打印语句；
/*
再给你说说匿名对象的特点吧；
Inner inner=new Inner(); 这是一个有名的对象；
inner.method();在这个时候其它是等同于new Inner().method()的；
他们的区别在于；匿名对象只能被使用一次；
假如Inner对对象中还有一个method2()的方法；
inner.method();inner.method2()这里表示的是一个Inner类型的对象inner调用了两次它的方法method()和method2()；
而new Inner().method(); 和new Inner().method2();这里的意思是两个Inner对分另调用了它的两个不同的方法；
因此当一个对象只被使用一次或者被作为参数进行传递时可以能匿名对象；否则就用有名对象。就是用有对象的引用；
*/
                 
        }
}

卜小斌 发表于 2012-6-21 11:28
但是并没有调用方法  方法就直接打印出来了？？这是为什么呢？？

主函数中 Test.function().method();      Test.function()，获得了一个对象：new Inner()。然后该对象调用method()方法。

static Inner function()
        {
                 return new Inner();  这句应该怎么理解，为什么这么写？//new Inner()是匿名对象的创建格式，返回对象的时候可以这么写
     }//这是一个获取内部类对象的方法

Test.function().method();//看主函数 这里 你这里要调用Inner里面的method方法 是不是要 有INNer的对象？？
因为function()方法返回的是Inner类型的对象，所以Test.function()就是Inner对象，可以调用method()方法

Test.function().method();//看主函数 这里 你这里要调用Inner里面的method方法 是不是要 有INNer的对象？？
static Inner function()是Test类中的静态方法，通过return new Inner();操作获得内部类Inner对象的实例。
然后通过实例对象完成内部类Inner的method()方法调用。

首先我们从main函数中分析：调用的是Test.function().method();分解如下：
1。“Test.function()”：说明是调用Test类中的静态方法function();
2。“.method()”:说明运算后的结果是返回一个对象，而且是Inner类型的对象，因为此程序中只有Inner类型的对象才能调用method();所以"Test.function()”返回值为Inner类型的对象；
3。如何保证function()返回值为Inner类型的呢，当然是new Inner();
其次我们从内部类这部分代码分析:
1。method()是静态内部类Inner的成员函数，Inner为静态的，而method()不为静态，所以我们无法用“类名.方法名”完成调用。
以下代码也能达到与LZ相同的效果

1. class Test{
   
2.       private static int num =3;
   
3.       static class Inner {
   
4.           static  void method(){
   
5.               System.out.println("num="+num);
   
6.             }
   
7.        }
   
8. }
   
9. class NiMingDemo{
   
10.    public static void main(String[] args){
    
11.           Test.Inner.method();
    
12.    }
    
13. }

复制代码

2。我们又知道要调用非静态的成员方法，只能用“对象.方法名”的格式，所以我们要拿Inner里面的method()，只能通过new Inner().method();

class Test
{
         private static int num =3;
         static class Inner          {
                 void method()
                 {
                         System.out.println("num="+num);
                 }
         }
         static Inner function()
        {
                 return new Inner();   调用过之后，执行代码，产生的就是Inner对象~Inner是一个内部类 请往上边看红色部分，产生对象后我们就可以调用里边的方法了                                                                                                                                      ~method()
        }
class  NiMingDemo
{
        public static void main(String[] args)
        {

                Test.function().method();  先不要看.method(),这实际上就是在调用方法function()
               
        }
}

class Test
{
         private static int num =3;
         static class Inner  //首先 这是内部类相信楼主应该知道吧
         {
                 void method()
                 {
                         System.out.println("num="+num);
                 }
         }
         static Inner function()  //而这里是new 了一个内部类， 然后把这个类返回，这样的话，只要new Test的这个类，调用这个方法，
                                               就会返回内部类，要想调用内部类的方法，就 直接  Test.function().method();这样就可以了
                                                Test.function(); 这个方法是反回了一个内部类吧，然后在.method() 内部类的方法就可以 了，
                                                 所以最后会打印num
        {
                 return new Inner();  这句应该怎么理解，为什么这么写？   

}
class  NiMingDemo
{
        public static void main(String[] args)
        {

                Test.function().method();
               
        }
}

class Test{
      private static int num =3;
      static class Inner {
          static  void method(){
              System.out.println("num="+num);
            }
       }
}
class NiMingDemo{
   public static void main(String[] args){
          Test.Inner.method();
   }
}
中Inner是Test的内部类，而method方法则是返回Inner的一个实例化对象，method方法是用static修饰的所以可以直接通过类名调用，无需实例化，就可以用Test.method（）；这样就返回了一个Inner对象，我们也可以这样写 Inner inner=Test.function（）；就相当于把inner实例化了。我们再看inner.function()这是一个非static修饰的方法所以我们无法直接通过类名调用，必须要获取Inner的实例，所以function方法中的 return Inner（）就不难理解了吧，它的作用就是返回Inner的实例。

Test.function().method();中要调用 的是静态内部类的成员，所以必须要先创建一个内部类的对象，而return new Inner();  对function返回的就是new 出来的一个Inner类的一个对象，没有它是不能访问method()方法的