java下内部类

内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类

1.成员内部类（定义在类中的类叫成员内部类）

（1）成员内部类
public class DemolInnerClass {
    public static void main(String[] args) {
        //外部类名.内部类名 变量名= 外部类对象.内部类对象
        Outer.InnerClass oi = new Outer().new InnerClass();//外部类要访问内部类的成员，必须创建对象。
        oi.getNumber();
    }
}


class Outer{
    /*public*/private int number = 10;//定义在类中的变量叫成员变量
    class InnerClass{//定义在类中的类叫做成员内部类
        public void getNumber(){
            System.out.println(number);//成员内部类可以直接访问外部类的成员，包括私有
        }
    }
}

运行的结果：10

（2）成员内部类用private修饰，私有成员内部类

public class Demol2InnerClass {
    public static void main(String[] args) {
     OuterPrivate op = new OuterPrivate();
     op.getInnerPrivate();
    }
}

class OuterPrivate{
    private  int number = 10;
    private class InnerPrivate{ //成员内部类私有使用（private）
        public void  getNumber(){
            System.out.println(number);
        }
    }
 public void  getInnerPrivate(){//只能在外部类中创建内部对象进行访问
     InnerPrivate ip = new InnerPrivate();
     ip.getNumber();
 }

}

2.局部内部类

public class Demol3InnerClass {
    public static void main(String[] args) {
        OuterLocal outerLocal = new OuterLocal();
        outerLocal.LocalMethod();
    }
}
/* 局部内部类：在方法中定义的内部类
 * 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
       因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,
       当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,
       就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,
       也可以继续使用
*/
class OuterLocal{
    public void LocalMethod(){

       class LocalInner{//局部内部类:定义在成员方法中的类
           final int number = 10;
           public void getNumber(){
               System.out.println(number);
           }
       }
       LocalInner localInner = new LocalInner();
       localInner.getNumber();

    }
    /*public void run() {
        LocalInner localInner = new LocalInner();  //局部内部类,只能在其所在的方法中访问
        localInner.getNumber();
   }*/

}

3.静态成员内部类，

public class Demol4InnerClass {
    public static void main(String[] args) {
        //外部类名.内部类名 对象名 = 外部类名.内部类对象;
        OuterStatic.Inner1 oi = new OuterStatic.Inner1();
        oi.method();
        OuterStatic.Inner2.print();
    }
    
}
class OuterStatic{
    static class Inner1{//静态成员内部类:成员内部类被静态修饰的类
        public void method() {
            System.out.println("method");
        }
    }
    
    static class Inner2{
        public static void print() {
            System.out.println("print");
        }
    }
}

4.匿名内部类，就是没有名字的内部类

public class Demo1_NoNameInnerClass {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.method();
    }
}
/* A:匿名内部类
   * 就是内部类的简化写法。
* B:前提：存在一个类或者接口
   * 这里的类可以是具体类也可以是抽象类。
* C:格式：
      new 类名或者接口名(){
         重写方法;
      }
* D:本质是什么呢?
   * 是一个继承了该类或者实现了该接口的子类匿名对象。
*/
interface InnerInterface{
    public void print();
}
class Outer1{
    /*abstract*/ class Inner implements InnerInterface{
        public void print() {
            System.out.println("print");
        }
    }

    public void method(){
//        Inner i = new Inner();
//        i.print();
//        new Inner().print();//创建InnerInterface的子类Inner
//        InnerInterface i1 = new Inner();       //父类引用指向子类对象

//        上面的内部类可以用匿名内部类来实现
        new Inner(){
            public void print() {
                System.out.println("print");
            }
        }.print();
    }
}

猜你喜欢