java内部类总结

嵌套类分为静态嵌套类和内部类（即非静态嵌套类）
1：内部类和外部类同时被编译，内部类编译后的class文件名为外部类$内部类名.class
2: 内部类分为成员内部类，方法内部类，匿名内部类，静态嵌套类，
public   class OutClass{
  private int a;
  class InnerClass{
     public void say(){
     System.out.println(a);
}
}
public static void main(String[] args){
      OutClass.InnerClass inner = new OutClass().new InnerClass();
      inner.say();
}
}


以上这个就是成员内部类，在生成内部类的时候，其实内部类已经拥有外部类的一个引用了，所有内部类可以访问外部类的任何的变量和方法
内部类的this的引用，如果在成员内部类引用this的话就是指当前内部类实例如下：
如果内部类想引用外部类当前的对象呢：应该这杨写外部类名.this
public   class OutClass{
  private int a;
public  class InnerClass{
     public void say(){
     System.out.println(a);
      System.out.println(OutClass.this);
}
}
public static void main(String[] args){

      OutClass.InnerClass inner = new OutClass().new InnerClass();
      inner.say();
}
}

从以上这个内部类上来看可知，内部类的修饰符跟普通的类没有啥区别，可以用public ,private ,final,static 等，但是用static修饰的话，它内部不能都访问外部类的所有属性和方法了,因为
静态static没有this引用，它就仅仅能访问外部类的静态属性和方法了，

内部类也可以被别的类进行访问，最好的一种方法就是在当前的外部类生成一个产生内部类引用的方法类似这杨：
public   class OutClass{
  public InnerClass  getInnerClass{
   return new InnerClass();
}
  private int a;
  class InnerClass{
     public void say(){
     System.out.println(a);
}
}
}
当然内部类也可以继承别的类或者是实现别的 了！

如果一个继承一个内部类那么必须提供一个外部类的对象作为构造方法的参数例如：

class  OutClass{
   class InnerClass{
}
}

class  A extends InnerClass{
   public A(OutClass   outClass){
      outClass.super(); 
   }

}

方法内部类：

故名思意：方法内部类就是定义在方法内部的类类似如下

public   class OutClass{

   public void ask(){
     class  InnerClass{
          void good(){
         System.out.println("good");
          }
  }
  InnerClass inner = new InnerClass();
  inner.good();
}
}
}
方法内部类里面如果要方法外部类的方法内的局部参数的话，局部参数必须是final类型的，因为
方法内的参数是存在的java栈当中的，也就是方法结束的时候他就消失了，而类是放在堆中的，这杨就不能
同时控制堆和栈中的变量同时消失，因此必须是final类行的！当然方法内部类只能在方法内部进行实例话不能在方法外面
进行实例化不然就报错了！

匿名内部类：


继承式的内部类：
class  A{
   public void say(){
     System.out.println("hello");
}
}

public class B{
    public static void main(String[] args){
       A a = new A(){
         public void say(){
      System.out.println("hello----------");
}
};
      a.say();

}

}
这样得出的结果是hello------------------因为a已经继承A类的一个子类的引用了，这杨的话就调用子类的say方法，记住了这里必须是重写父类的方法，而不是造新的方法
不然没有意义的！详解请看多态的相关知识点


接口式的匿名内部类：

public interface A{
    void add();
  
}


public  class B{
   public static void main(String[] args){
      A a = new A(){
      public void add(){
        System.out.println("add");
}
};
a.add();
}
  

}
这个时候a就是实现A接口的类的一个引用了！

参数式的匿名内部类：
class  A{
   public void say(B b){
}
}

public C{
    public static void main(String[] args){
     A a = new A();
    a.say(new B(){
      public void add(){
   
}
});
     }
}


静态嵌套类：
public  class A{
   static class B{
}
}

这就是所谓的静态嵌套类,静态嵌套类里面的所有属性和方法都是静态的，因此外部类要访问内部类的静态方法和属性的话，必须是静态的，
因此静态嵌套类和少被使用！同时静态内部类访问外部类的属性和方法必须是静态的！


使用内部类的好处：
1：java是不支持多重继承的，因为可以每个内部类继承一个类，因为外部类是可以访问内部类的，因此这杨实现的效果多实现多继承是一样的！
2：内部类可以隐藏你不想让别人访问的方法和属性！