Java 内部类

Day02

Java内部类

---

• 优点：能获得外部类的私有属性；

• 注意：一个java类中可以有多个class类，但是只能有一个public class

内部类分为：

1. 成员内部类

2. 静态内部类

3. 方法内部类

4. 匿名内部类

内部类不会因为类的加载或成员方法的加载而加载进入内存，只会在被调用的时候才会被加载进入内存

 

成员内部类

• 特性：在外部类中的成员位置

eg:

public class Demo03 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }   
}
​
class Outer{
    int num = 1;
    public void method() {
        System.out.println(num);
    }
    //成员位置
    class Inner{
        int num = 2;
        public void show() {
            int num = 3;
            //想要访问成员---就近原则
            System.out.println(num);
            
            System.out.println(this.num);
            
            //通过所属类访问
            System.out.println(Outer.this.num);
            
        }
    }
}

• 物理文件特性：

  外部类经过编译后在bin目录下的class文件的文件名为：Out$Inner.class

  • $ 表示所属

     

局部内部类

• 特性：在外部类中的方法中；

public class Demo03 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }   
}
​
class Outer{
    int num = 1;
    public void method() {
        System.out.println(num);
    }
    
    class Inner{
        int num = 2;
        public void show() {
            int num = 3;
            //想要访问成员---就近原则
            System.out.println(num);
            
            System.out.println(this.num);
            
            //通过所属类访问
            System.out.println(Outer.this.num);
            
        }
    }
}

• 物理文件特性：

  外部类经过编译后在bin目录下的class文件的文件名为：Out$1Inner.class

  • $ 表示所属

  • 1 表示局部

• 注意：

  • 局部内部类不能被访问权限符修饰， static 也不行

  • jdk 1.8 之后，在局部内部类中访问的局部变量是一个常量(默认被 final 修饰)

   

静态内部类

• 特性：内部类被静态关键字 ( static ) 所修饰

eg：

public class Demo03 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
        Outer.Inner in = new Outer.Inner();
        in.show();
        in.show2();
    }   
}
​
class Outer{
    static int num = 1;
    public void method() {
        System.out.println(num);
    }
    
    static class Inner{
        public void show() {
            int num = 3;
            //就近原则
            System.out.println(num);
                        
        }
        public void show2() {
            System.out.println(Outer.num);
        }
    }
}

 

匿名内部类

• 特性：不需要创建具体的子类型，而创建出父类型的子对象；

eg：

public class Demo03{
    public static void main(String[] args) {
        //普通写法，多态
        ter t = new ret();
        t.method();
        t.show();
        
        //匿名内部类
        ter tt = new ter() {        //多态 接口类型 变量名 = 匿名实现类对象
            public void method() {
                System.out.println("天上掉下个猪八戒");
            }
            public void show() {
                System.out.println("天上掉下个林妹妹");
            }
            
        };
        //此上操作与 ter tt = new ret();     类似
        
        tt.method();
        tt.show();
    }
}
​
interface ter{
    abstract void method();
    abstract void show();
}
class ret implements ter{
    public void method() {
        System.out.println("实现接口方式的method方法");
    }
    public void show() {
        System.out.println("实现接口方式的show方法");
    }
}

 

 

拓展

内部类的继承

优点：

• 在外部没有被暴露出来内部类；

• 可以通过内部类的方法对类进行继承重写，或者通过接口实现，通过公共的方式对其内部类进行访问。因为内部类通常是被封装在外部类中；

public class Demo03{
    public static void main(String[] args) {
        new Outer().getObject();
        AbsDemo in  = new Outer().getObject();
        in.show();
    }
        
}
​
class Outer{
    int num = 4;
    private class Inner extends AbsDemo{
        void show() {
            System.out.println("继承方法");
        }
    }
    
    public AbsDemo getObject() {
        return new   Inner();
    }
}
//抽象方法
abstract class AbsDemo{
    abstract void  show();
    
}