Java面向对象_内部类

概念：内部类就是类的内部定义的类

成员内部类格式如下：class Outer{

class Inner{}

}

编译上述代码会产生两个文件:Outer.class和Outer$Inner.class

在外部创建内部类对象

内部类除了可以在外部类中产生实例化对象，也可以在外部类的外部来实例化。所以内部类的访问：通过"外部类.内部类"的形式表示

Outer out=new Outer();//产生外部类实例

Outer.Inner in=null;//声明内部类对象

in=out.new Inner();//实例化内部类对象

public class Practice14 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Outer o=new Outer();
        o.print();

        //直接在外部使用内部类,不推荐使用
        Outer.Inner in=o.new Inner("在外部使用内部类");
        in.print();
    }
}

class Outer{
    public void print(){
        //在外部类实例化内部类，并调用方法
        Inner i=new Inner("成员内部类");
        i.print();
    }
    class Inner{
        private String name;
        public Inner(String name){
            this.name=name;
        }
        public void print(){
            System.out.println(name);
        }
    }
}

方法内部类格式如下：class Outer{

　　　　　　　　　　　　　public void doSomething(){

　　　　　　　　　　　　　　　　class Inner{

　　　　　　　　　　　　　　　　　　public void seeOuter(){}

　　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　}

　　　　　　　　　　　　　}

注意：1.方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化

　　　　　 2.方法内部类对象不能使用该内部类所在方法的非final局部变量

 public class Practice14 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Outer o=new Outer();
         o.print1();

     }
 }

 class Outer{

     public void print1(){
         final int x=10;//方法内部类对象不能使用该内部类所在方法的非final局部变量
         //在方法内创建内部类
         class Inner1{
             public void print(){
                 System.out.println("我是方法内部类"+x);
             }
         }
         Inner1 i=new Inner1();//只能在定义该内部类的方法内实例化
         i.print();
     }

 }

静态内部类：在一个类内部定义一个静态内部类:静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。

　　　　　　class Outer{

　　　　　　　　static class Inner{}

　　　　　　class Test{

　　　　　　　　public static void main(String[] args){

　　　　　　　　　　Outer.Inner n=new Outer.Inner();

　　　　　　}

　　　　　　}

 public class Practice14 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
        //在外部直接使用静态内部类(创建静态内部类对象不需要依赖外部类的对象)
         //静态内部类在之后的安卓编程中经常使用（重点）
        Outer.Inner o=new Outer.Inner();
        o.print();
     }
 }

 class Outer{
     static class Inner{
         public void print(){
             System.out.println("静态");
         }
     }    

 }

匿名内部类：匿名内部类就是没有名字的内部类。有三种情况：继承式的匿名内部类;接口市的匿名内部类;参数式的匿名内部类;

在使用匿名内部类时，记住以下原则:

1.不能有构造方法，只能有一个实例

2.不能定义任何静态成员、静态方法

3.不能是public,protected,private,static

4.一定是在new的后面，用其隐含实现一个接口或实现一个类

5.匿名内部类为局部的，所以局部内部类的所有限制都对其生效

 public class Practice14 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
        Boy b=new Boy();
        b.print();

        b.print2(new Child(){
           public void desc(){
               System.out.println("参数式的匿名内部类");
           }
        });
     }
 }

 interface Child{
     public void desc();
 }

 class Boy{
     public void print(){
         Child C=new Child(){
             public void desc(){
                 System.out.println("接口市的匿名内部类");
             }
         };
         C.desc();
     }
     public void print2(Child ch){
         ch.desc();
     }
 }

定义内部类时优先考虑静态内部类，可以防止内存溢出。