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);
    }
}

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