内部类

概念

类中的类

内部类分类

1.成员内部类：类中方法外

① 一般成员内部类：

class 类名{}

② 静态成员内部类:

static class 类名{}

③ 私有成员内部类:

private class 类名{}

2.局部内部类：方法中

3.内部类的命名：

外部类的名称 + $ + 内部类的名称

一般成员内部类

1.一般成员内部类中调用外部类的非静态方法：直接调用。 
2.外部类的非静态成员调用一般成员内部类的非静态成员：创建对象，然后再调用。
3.一般成员内部类中不允许有静态方法。但是可以有static final修饰的静态成员属性。
4.外部类的外面创建内部类的对象： 
1> 数据类型

外部类名.内部类名

代码

package com.demo; 
public class 一般成员内部类 { 
    public static void main(String[] args) {
        B.InnerB ib = new B().new InnerB();
    }
}
class B{
    int a = 15;
    public void show(){
        System.out.println("22222");
        InnerB ib = new InnerB(); 
        ib.fun(); 
    }
    class InnerB{ 
        static final int b= 10; 
        public void fun(){ 
            show(); a = 16;
            System.out.println("1111111111111");
        }
        //一般成员内部类中不允许有静态方法。 
        // public static void fun1(){} 
    } 
}

静态成员内部类

静态成员内部类：

① 静态成员内部类中非静态方法中调用外部类的非静态方法：创建外部类的对象，调用方法。

② 静态成员内部类中非静态方法调用外部类的静态方法：直接调用。

③ 外部类的非静态方法调用静态成员内部类中的非静态：创建内部类的对象，调用方法。

④ 外部类的非静态方法调用静态成员内部类中的静态方法：内部类名.方法名称(参数)

⑤ 静态成员内部类中静态方法中调用外部类的静态方法：直接调用

⑥ 静态成员内部类中静态方法中调用外部类的非静态方法:创建外部类的对象，调用方法。

⑦ 外部类的静态方法调用静态成员内部类中的静态：内部类名.方法名称(参数)

⑧ 外部类的静态方法调用静态成员内部类中的非静态：创建内部类的对象，调用方法。

总结：

1》静态成员内部类中方法调用外部类的静态方法：直接调用。

2》静态成员内部类中方法调用外部类的非静态方法：创建外部类的对象，调用方法。

3》外部类的方法调用静态成员内部类的静态方法：内部类名.方法名称(参数)

4》外部类的方法调用静态成员内部类的非静态方法:创建内部类的对象，调用方法。

2.外部类外创建内部类的对象:

外部类的名称.内部类的名称对象的名称 = new 外部类名.内部类名()

代码

package com.demo;
public class 静态成员内部类 { 
    public static void main(String[] args) { 
        M.InnerM mm = new M.InnerM(); 
    } 
}
class M{
    public void show(){
        InnerM im = new InnerM();
        im.fun();
        InnerM.sf();
    }
    public static void sk(){ 
        InnerM.sf();
        InnerM im = new InnerM();
        im.fun(); 
    }
    //静态成员内部类
    static class InnerM{
        public void fun(){
            // 由于外部类的show方法必须在有外部类的对象时，才能使用。
            M m = new M(); 
            m.show(); 
            sf();
            System.out.println("111111111111111"); 
        }
        public static void sf(){
            sk();
            M m = new M();
            m.show(); 
            System.out.println("222222222222");
        } 
    } 
}

私有成员内部类

1.用法同一般成员内部类：

① 在私有成员内部类的非静态方法中调用外部类的方法：直接调用。

② 外部类的非静态成员调用私有成员内部类的非静态成员：创建内部类的对象，调用方法。

③ 外部类的静态成员调用私有成员内部类的非静态成员：先创建外部类的对象，再创建内部类的对象，调用方法。

2.外部类的外面创建私有成员内部类的对象：

不能。

代码

package com.demo;
public class 私有成员内部类 {
    public static void main(String[] args) {
    }
}
class F{ 
    public void fun(){
        InnerF in = new InnerF();
        in.show();
    }
    public static void sf(){
        F f = new F();
        InnerF ik = f.new InnerF();
        ik.show(); 
    }
    //私有成员内部类 
    private class InnerF{
        public void show(){
            fun();
            sf();
        }
    } 
}

局部内部类

1.局部内部类：方法中的类

代码

package com.demo;
/**
	1.局部内部类： 方法中的类 
*/
public class 局部内部类 {
    public static void main(String[] args) {
        K k = new K();
        k.fun(); 
    } 
}
class K {
    public void fun(){
        //局部内部类 
        /*class InnerK{ 
        	public void show(){ 
        		System.out.println("22222");
                } 
         }
         //创建内部类的对象 调用方法
         InnerK in = new InnerK();
         in.show();*/ 
        //匿名对象 
        /* TM t = new ZiTM(); 
        t.fun1();*/
        //一次性调用:实质就是对象。 
        new TM(){
            @Override 
            public void fun1() {
            }
        };
    } 
}
interface TM{ 
    public void fun1();
}
class ZiTM implements TM{ 
    @Override 
    public void fun1() { 
    }
}
class ZiTM1 implements TM{
    @Override
    public void fun1() { 
    } 
}