静态内部类

JAVA内部静态类 复习

内部类的作用：

1、隐藏你不想让别人知道的操作，也即封装性。

2、一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！

内部类的功能在于，每个内部类都能独立的继承一个接口的实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多重继承的解决方案变得完整，并且内部类允许继承多个非接口类型(类或抽象类)。通过内部类分别继承一个基类，外部类创建内部类的对象，并使用内部类的方法，变相地实现了多继承。 
java内部类有什么好处？为什么需要内部类？ 
1、举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

2、真正的原因是这样的，java中的内部类和接口加在一起，可以解决常被C++程序员抱怨java中存在的一个问题：没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

静态内部类和非静态内部类的区别
1、和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。
2、在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。

 

 

接口：
声明在接口中的属性自动成为public static final
声明在接口中的方法自动成为public
声明在接口中的类自动成为public static


如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：    
1. 要创建嵌套类的对象，并不需要其外围类的对象。    
2. 不能从嵌套类的对象中访问非静态的外围类对象。    
     

public class Z1 {    
       private static int i = 1;    
       private int j = 10;    
       public static void outer_f1() {    
       }    
     
       public void outer_f2() {    
       }    
     
       // 静态内部类可以用public,protected,private修饰    
       // 静态内部类中可以定义静态或者非静态的成员    
       static class Inner {    
              static int inner_i = 100;    
              int inner_j = 200;    
              static void inner_f1() {    
                      //静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)    
                     System.out.println("Outer.i" + i);    
                     outer_f1();    
              }    
     
              void inner_f2() {    
                     // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)     
                     // System.out.println("Outer.i"+j);    
                     // outer_f2();    
               System.out.println("非静态方法");
              }    
       }    
       class Innerz {    
          
           int inner_j = 200;    
          
  
           void inner_f2() {    
                  // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)     
                  // System.out.println("Outer.i"+j);    
                  // outer_f2();    
            System.out.println("非静态累非静态方法");
           }    
    }    
     
       public void outer_f3() {       // 外部类访问内部类的静态成员：内部类.静态成员    
              System.out.println(Inner.inner_i);    
              Inner.inner_f1();    
              // 外部类访问内部类的非静态成员:实例化内部类即可    
              Inner inner = new Inner();    
              inner.inner_f2();    
       }    
     
       public static void main(String[] args) {    
              new Z1().outer_f3();
              
              Z1.Inner z=new Z1.Inner();
              z.inner_f2();
              
              Z1 z1=new Z1();
              Z1.Innerz zz=z1.new Innerz();
              zz.inner_f2();
       }    
}
  
生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）