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

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