4.6内部类

内部类的定义
一个类定义在另一个类中这样的类被称为内部类。
内部类的性

• 内部类定义的位置可以在两处：1.当作外部类的成员来定义，2.在外部类的方法中定义。

1.非静态内部

• 非静态内部类和外部类其他的非静态成员一样也是依赖于外部类的对象，要先创建内部类对象必须先创建外部类对象。内部类对象既可以在外部类方法中创建，也可以在外部类之外创建：

    <外部类类名>.<内部类类名> 引用变量= 外部类对象引用.new<内部类构造方法>；
    <外部类类名>.<内部类类名> 引用变量=外部类类名.<外部类构造方法>.new<内部类构造方法>;
  

外部类创建非静态内部类对象示例：

class outter{
    class intter{
        void tt(){
        }
    }
}
public class Test{
    public static void main(String args[]){
    //先创建外部类对象
        outter t1=new outter();
        //第一种方式创建内部类对象
        outter.intter t2=t1.new intter();
        t2.tt();
        //第二种方式创建内部类对象
        outter.intter t3=new outter().new intter();
        t2.tt();
    }
}

• 非静态内部类作为外部类的一个成员，他可以访问外部类的所有成员，即使这个成员是private修饰的。反之在外部类中也可以访问内部类的所有成员，但之前要先创建内部类对象。

  访问示例

//非静态内部类与外部类访问示例！
class Outter{
    private int oi=4;
    private class Inner{
        private int ii;
        //static double di 不能声明静态成员，否则编译错误。
        static final int oo=5;//可以创建静态常量！
        Inner(int i){
            ii=i;
        }
        //访问外部类中的私有成员变量
        private void outio(){
            System.out.println("外部类中的私有成员变量的值为："+oi);
        }
        private void outii(){
            System.out.println("内部类中的私有成员变量的值为："+ii);
        }
    }
    //在外部类创建的outo（）方法中创建非静态内部类对象并访问内部类的私有方法！
    void outo(){
        Inner in=new Inner(7);
        in.outio();
        in.outii();
    }
}
public class OutterInner {
public static void main(String args[]){
    Outter ou=new Outter();
    ou.outo();//这里调用外部类的方法从而访问内部类的方法！
}
}
//：非静态内部类中不能定义静态属性，静态方法，静态初始化块。（静态常量除外）。

• 非静态内部类作为外部类的一个成员，他可以访问外部类的所有成员，即使这个成员是private修饰的。

• 非静态内部类类名不可以和外部类相同，但是方法名可以相同。当外部类成员变量，内部类局部变量，内部类成员变量相同时，有效的是局部变量。

  访问外部类的成员变量方式：外部类类名。this。外部类成员变量。
  访问内部类的成员变量方式：this。内部类成员变量。
  

非静态内部类与外部类同名变量的访问示例

class outter{
     int a;
     outter(int a){
         this.a=a;
     }
    class intter{
        int a;
        void tt(){
        int a=8;
        System.out.println("内部类的局部变量：a="+a);
        System.out.println("内部类的成员变量：this.a="+this.a);
        System.out.println("外部类的成员变量：outter.intter.a="+outter.this.a);
        }
        intter(int a){
            this.a=a;
        }
    }
}
public class Test{
    public static void main(String args[]){
        outter t1=new outter(2);
        outter.intter t2=t1.new intter(6);
        t2.tt();
    }
}

2.静态内部类

• 内部类定义时前面加上static就是静态内部类，静态内部类不依赖于外部类的对象，而是依赖于外部类，可以将静态内部类当作时外部类的一个静态方法来看，所以在创建静态内部类的对象时不需要先创建外部类的对象。
  静态内部类使用示例

class Outter{
    static int i=3;
    double d=5.6;
    static class Inner{
        double id=8.9;
        static double sid=7.2;
        void out(){
            System.out.println("外部类中的静态变量成员的值为："+i);
            //在静态内部类中不能访问外部类中的非静态成员
            //System.out.println("外部类中的静态变量成员的值为："+d);  不合法！
        }
    }
}
public class OutterTest {
public static void main(String args[]){
    //不需要产生外部类对象,直接创建内部类对象！
    Outter.Inner oi=new Outter.Inner();
    oi.out();
    System.out.println("内部类中的静态成员变量的值为："+Outter.Inner.sid);
}//外部类名。内部类名 对象名=new 外部类名。内部类名（）！
}