JAVA学习过程中的几个问题3

Question

1.哪位大侠能说讲一讲静态内部类，与静态成员的区别。
不是很理解静态内部类，它是在什么时候生成的，它能干什么用？2.为什么不可以System.out.println(局部类里有返回值的函数)；为什么输出局部类里有返回值的函数？3.可以举几个局部类应用的例子。

Answer 1

http://blog.csdn.net/fgakjfd/archive/2010/02/02/5282646.aspx这样的常识还是多google一下比较好    给分吧    上门是传送门

Answer 2

1. 内部类可以声明为private或protected，可以声明为static
2. 内部类中可以直接访问外部类的方法。
3. 内部类中可以直接访问外部类的数据成员
4. 在外部类的静态方法中创建内部类对象，必须采用“外部类名.内部类名”的形式指定对象的类型，并且非静态内部类的对象必须通过外部类对象来创建。如：
public static void f(){
OuterClass out = new OuterClass();
OuterClass.InnerClass in = out.new InnerClass();
}
5. 不能通过外部类对象访问内部类成员
6. 不能通过内部类对象访问外部类成员
7. 静态内部类对象可以直接采用“外部类名.内部类名”形式创建
 OuterClass.M m = new OuterClass.M();8. 私有内部类无法通过第4条创建

Answer 3

1.哪位大侠能说讲一讲静态内部类，与静态成员的区别。
不是很理解静态内部类，它是在什么时候生成的，它能干什么用？2.为什么不可以System.out.println(局部类里有返回值的函数)；为什么输出局部类里有返回值的函数？3.可以举几个局部类应用的例子。-----------------------------------------------------------------------希望不要再讲静态内部类的访问和使用规择，跪求高手现身。

Answer 4

我以前看 think in java 这里就没看明白
直接跳过了 一直没用过···

Answer 5

1.静态成员应该明白吧，正常的内部类可以访问主类的所有变量和方法，因为里面有一个指向主类的引用，而静态内部类不存指向主类的引用，所以只能访问主类的静态变量和方法。不知道这样说明白不？
2.不太明白，能说详细点不》？？？
3.局部类是内部匿名类还是普通的内部类
内部匿名类一般在swing的实践监听用的比较多，类似js的闭包，对于闭包不太明白的可以google一下
内部类一般是在内部使用的，如果是public static的内部类，就和正常的类是一样的。其他的主要是为了封装操作或者方便使用而已，视实际情况而定。

Answer 6

1.静态内部类与静态成员的区别不大,只是使用时不太一样,比如调用静态内部类的静态方法InerClass.method().如果内部类不是静态类,那么里面是不能有静态成员的.为了让不同的内部类对象共享内部类的变量或方法,所以用静态内部类.生成是在你调用了内部静态类的静态成员或者new其对象时.
2.局部类?java里面好像没有这个说法,是c#的吧?你的意思是内部类?如果内部类的方法不是静态方法的话必须要通过内部类的对象来调用.至于为什么我们可以这样子理解:引入内部类就是为了把一些相似的东西封装起来作为一个更小的类,如果外部类又还可以直接调用的话就等于没有封装了.
3.就像上面所说的内部类可以把更小的属性封装起来,比如教室类,教室类的内部类黑板,那么你这个黑板内部类就可以封装黑板的属性,比如尺寸品牌价格等.不过据说内部类效率比较低最好还是用继承来实现.比较常用的例子:比如你可以把事件监听写在内部类里面,或者用于多线程(如:new InerThreadClass().start()).
其实这些都是基础知识,多看下书会更容易明白.实践还要加理论

Answer 7

LZ是说类似这样的吧 这样就可以调用了public class Main {

private int ii=0;
static class ClassThree {
public void print(){
System.out.println(new Main().ii);
}
}
}
public class Main2 {
public static void main(String[] args){
new Main.ClassThree().print();
}

}
但是一般大家 都是这么用的public class Main {

private int ii=0;
static class ClassThree {
public static void print(){
System.out.println(new Main().ii);
}
}
}
public class Main2 {
public static void main(String[] args){
Main.ClassThree.print();
}
}在JDK1.6里写的例子 

Answer 8

.哪位大侠能说讲一讲静态内部类，与静态成员的区别。 下面这篇博文讲还可以了
http://hi.baidu.com/yingxiaoqiangy/blog/item/5281c11dc64a276df724e47f.html

Answer 9

   clsaa A{
      static class B{
      }
      class C{      }
      static void main(){
          B b = new B(); 
          C c = new C(); //error  
     }
  }

Answer 10

/////////////////////////////////内部类 内部类，有时叫做嵌套类，被附加到JDK1.1及更高版本中。内部类允许一个类定义被放到另一个类定义里。内部类是一个有用的特征，因为它们允许将逻辑上同属性的类组合到一起，并在另一个类中控制一个类的可视性。 6.14.1     内部类基础 
        下述例子表示使用内部类的共同方法： 
1． import   java.awt.*; 
2． import   java.awt.event.*;   
3． public   class   MyFrame   extends   Frame{   
4．         Button   myButton; 
5．         TextArea   myTextArea; 
6．         int   count;;   
7． 
8．         public   MyFrame(){ 
9．                 super( "Inner   Class   Frame "); 
10．           myButton   =   new   Button( "click   me "); 
11．           myTextArea   =   new   TextArea();   
12．           add(myButton,BorderLayout,CENTER);   
13．           add(myTextArea,BorderLayout,NORTH); 
14．           ButtonListener   bList   =   new   ButtonListener();   
15．           myButton.addActionListener(bList);   
16．   }   
17．   class   ButtonListener   implements   ActionListener{   
18．       public   void   actionPerformed(ActionEvent   e){   
19．       count   ++   
20．           myTextArea.setText( "button   clicked "   +   { 
21．                   count   +   "times "); 
22．       } 
23．   }//   end   of   innerclass   ButtonListener 
24． 
25．   public   static   void   main(String   args[]){   
26．       MyFrame   f   =   new   MyFrame(); 
27．       f.setSize(300,300); 
28．       f.setVisible(true); 
29．   } 
30． }   //   end   of   class   MyFrame           前面的例子包含一个类MyFrame，它包括一个内部类ButtonListener。编译器生成一个类文件，MyFrame$ButtonListener.class以及toMyFrame.class。它包含在MyFrame.class中，是在类的外部创建的。 6.14.2     如何做内部类工作？ 
        内部类可访问它们所嵌套的类的范围。所嵌套的类的成员的访问性是关键而且很有用。对嵌套类的范围的访问是可能的，因为内部类实际上有一个隐含的引用指向外部类上下文（如外部类“this”）。 
1. public   class   MyFrame   extends   Frame{ 
2.         Button   myButton; 
3.         TextArea   myTextarea; 
4.         public   MyFrame(){ 
5.             ...................... 
6.             ...................... 
7.             MyFrame$ButtonListener   bList   =   new   
8.                               MyFrame$ButtonListener(this);   
9.             myButton.addActionListener(bList);   
10.       } 
11.       class   MyFrame$ButtonListener   implements   
12.       ActionListener{ 
13.       private   MyFrame   outerThis; 
14.       Myframe$ButtonListener(MyFrame   outerThisArg){   
15.             outerThis   =   outerThisArg;   
16.       } 
17.       
18.       public   void   actionPerformed(ActionEvent   e)   {   
19.       outerThis.MyTextArea.setText( "buttonclicked ");   
20.       ...................... 
21.       ...................... 
22.       } 
23.       public   static   void   main(String   args[]){ 
24.           MyFrame   f   =   new   MyFrame(); 
25.           f.setSize(300,300); 
26.           f.setVisible(true); 
27.       } 
28. }   
        有时可能要从static方法或在没有this的某些其它情况下，创建一个内部类的一个实例（例如，main）。可以如下这么做： 
public   static   void   main(String   args[]){ 
        MyFrame   f   =   new   MyFrame(); 
        MyFrame.ButtonListener   bList   = 
                      f.new   ButtonListener();   
        f.setSize(50,50); 
        f.setVisible(true);   
} 
内部类属性： 
  内部类有如下属性： 
        类名称只能用在定义过的范围中，除非用在限定的名称中。内部类的名称必须与所嵌套的类不同。 
        内部类可以被定义在方法中。这条规则较简单，它支配到所嵌套类方法的变量的访问。任何变量，不论是本地变量还是正式参数，如果变量被标记为final，那么，就可以被内部类中的方法访问。 
内部类可以使用所嵌套类的类和实例变量以及所嵌套的块中的本地变量。 
内部类可以被定义为abstract. 
        属性 
        只有内部类可以被声明为private或protected，以便防护它们不受来自外部类的访问。访问保护不阻止内部类使用其它类的任何成员，只要一个类嵌套另一个。 
        一个内部类可以作为一个接口，由另一个内部类实现。 
        被自动地声明为static的内部类成为顶层类。这些内部类失去了在本地范围和其它内部类中使用数据或变量的能力。 
        内部类不能声明任何static成员；只有顶层类可以声明static成员。因此，一个需求static成员的内部类必须使用来自顶层类的成员。