Java内部类

Java内部类是Java中比较重要的一部分，准备多花几天学习下。
以下是Java内部类的一些示例：
1、 在内部类中调用外部类和在外部类中调用内部类
* 外部类的内部类会自动创建对外部类的引用，所以外部类中的任何元素都可以被内部内访问，private也可以。

//package innerClass;public class InnerClass {    private String name="huangbiao";    class demo{        public void syso(){            System.out.println("some thing");            System.out.println(name);        }        //内部类中建立外部类对象        public InnerClass returnFatherClass(){            return InnerClass.this;        }    }    class dem2{        String lable="";        public dem2(String i){            this.lable=i;        }    }    public demo returnReference(){        return new demo();    }    public static void main(String[] args) {        InnerClass in=new InnerClass();        //外部中建立内部类对象        InnerClass.demo de=in.new demo();        InnerClass dem=de.returnFatherClass();    }}

2、 方法中调用内部类
* 使用关键字外部类名.内部类名 引用名 = 外部类引用.new,而内部类中调用外部类关键字为外部类名.this。

package innerClass;public class PartInnerClass {    interface showSomeThing{            }    public showSomeThing method(){        class show implements showSomeThing{            String b;             public show(String i){                this.b=i;            }            public void print(){                System.out.println(b);            }        }        return new show("2");    }}

3、 内部类中实现接口以及接口中实现内部类

package innerClass;interface demo{    public void show(int i);    //接口中的内部类可以实现外围接口    class Demo implement demo{    //    public static void main(String[] Args){    //可以在其中声明测试方法。    }    }}interface demo2{    public void show2(String b);}public class InterceptereAndInnerClass {    class innerOne implements demo{        public int i=0;        @Override        public void show(int i) {            // TODO Auto-generated method stub            this.i= i;        }}    class innerTwo implements demo2{        String i;        @Override        public void show2(String b) {            // TODO Auto-generated method stub            this.i=b;            System.out.println(i);        }    }    public demo returnInnerOne(){        return new innerOne();    }    public demo2 returnInnerTwo(){        return new innerTwo();    }    public static void main(String[] args) {        InterceptereAndInnerClass in=new InterceptereAndInnerClass();        //Type mismatch: cannot convert from demo to InterceptereAndInnerClass.innerOne        //错误，不能再向下转型：        //InterceptereAndInnerClass.innerOne inOne=in.returnInnerOne();        demo de=in.returnInnerOne();      }}

1. 匿名内部类
   
   • 匿名内部类没有构造函数，但是抽象类有，所以可以在抽象类中定义构造函数，实现匿名类的默认构造函数，如果用接口实现就会默认使用无参构造。
   • 匿名内部类中的参数必须是final的（如果不在内部类中直接使用的话就不需要是final的，有些情况在构造器中使用）
     代码如下：

package com.innerClazz;interface Wrap2{}abstract class Wrap{    public Wrap(int x){    }}public class InnerClazz_NoName {    int a=1;    public Wrap returnWrap(final int x){        return new Wrap(x){            public void showSomeThing(){                a = a+x;            }        };//标记结束    }    public Wrap2 returnWrap2(){        return new Wrap2(){        };    };}

1. 嵌套类和多层嵌套内部类
   即将内部类声明为Static，
   
   • 此时内部类没有了默认的指向外部类的引用
   • 创建这个内部类时直接创建就可以了
   • 不能访问外部类中非静态的变量

package com.innerClazz;public class InnerClazz_Static {    private int i=0;    static class Some{        //不能访问i    }     public void some(){        Some s = new Some();    }    class A{        class B{        }    }    public void show(){        //多层嵌套内部类        InnerClazz_Static.A.B b =new InnerClazz_Static().new A().new B();    }}

1. 内部类的继承与覆盖
   内部类可以被继承，但是不能被覆盖，但是可以通过集成内部类的方式覆盖,通过方法将继承类中的内部类对象传上去，调用内部类中的方法
   代码如下：

        package com.innerClazz;class Some{    SomeThing so;    class SomeThing{        public void say(){            System.out.println("say");        }    }    public void setSo(SomeThing st){        so = st;    }}public class InnnerClazz_Extends extends Some{    class Ok extends Some.SomeThing{        public Ok(Some s){            s.super();        }        public void say(){            System.out.println("sys extends");        }    }    public static void main(String[] args) {        Some s = new Some();        InnnerClazz_Extends.Ok o = new InnnerClazz_Extends().new Ok(s);         s.setSo(o);    }}

内部类真的很重要，这方面要多看下。