JAVA内部类介绍与详解

JAVA内部类分类

成员内部类
静态内部类
局部内部类
匿名内部类

内部类解释：Java种的内部类是在一个类内部定义另一个类。

为什么需要内部类？

内部类继承自某个类或实现某个接口，内部类的代码操作可以创建其外部类的对象。所以可以将其入围是进入外部类的门窗
每个内部类都可独立的继承一个接口的实现，所以不管外部类是否已经集成某个接口的实现。对于内部类是没有影响的，而且内部类提供的使得外部类具有了类似多重继承的效果，解决了一些设计与变成的问题，使得。接口解决部分，内部类也有效的解决一部分"多重继承"的问题:

广泛意义上的内部类一般来说包括这四种：

成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类

作为外部类的一个成员存在，与外部类的成员属性，方法并列

class Outer{
	// 成员属性
	private int name;
	private int age = 10;
	// 成员方法
	// 外部类的非静态方法访问成员内部类
	public void outerMethods(){
		new Inner().innerOuterVariable();
		System.out.print("成员方法");
	}
	public static void outerStaticMethods() {
		System.out.println("静态成员方法");
		Inner inner = new Outer().new Inner();
		System.out.println(inner.a);
	}
	
	// 成员内部类
	class Inner {
		// 内部类的成员变量
		int a = 10;
		private int name;// 内部类和外部类的实例变量可以共存
		// static int b =20; 成员内部类中不能定义静态成员变量
		public void innerMethods(){
			System.out.print("内部类成员方法");
		}
		
		public void innerOuterVariable() {
			// 在内部类中访问内部类自己的变量直接用变量名
			// 调用外部类的成员变量
			System.out.println(age);
			// 成员内部类中，可以访问外部类的所有成员
			// 在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
			System.out.println(Outer.this.age);
			// 在内部类中访问内部类自己的变量也可以用this.变量名
			System.out.println(this.a);
		}
	}
}

【注意】

成员内部类中，不能定义静态成员
成员内部类中，可以访问外部类的所有成员
内部类中不允许定义静态变量
内部类和外部类的实例变量可以共存
在内部类中访问内部类自己的变量直接用变量名
在内部类中访问内部类自己的变量也可以用this.变量名
在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
外部类的非静态方法访问成员内部类
外部类的静态方法访问成员内部类，与在外部类的外部访问成员内部类一样
内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

静态内部列

静态内部作为外部类的一个静态成员存在，与外部类的成员属性，方法并列

public class Outer {
    // 成员变量
    private int age = 23;
    // 静态成员变量
    private static String name = "李敢敢";
    // 成员方法
    public void outerInnerMethods() {
        System.out.println("我是外部类的成员方法");
        // 调用内部类的静态成员变量
        System.out.println(Inner.number);
        // 调用内部类类的静态成员方法
        Inner.innerStaticMethods();
        // 调用内部类的成员变量
        System.out.println(new Inner().age);
        // 调用内部类的成员方法
        new Inner().innerMethods();
    }
    // 静态成员方法
    public static void outerInnerStaticMethods(){
        System.out.println("我是外部类的静态成员方法");
        // 调用内部类的静态成员变量
        System.out.println(Inner.number);
        // 调用内部类类的静态成员方法
        Inner.innerStaticMethods();
        // 调用内部类的成员变量
        System.out.println(new Inner().age);
        // 调用内部类的成员方法
        new Inner().innerMethods();
    }
    // 静态内部类
    static class  Inner {
        // 静态内部类的成员变量
        int age = 20;
        String sex = "女";
        // 静态内部类的静态变量
        static int number = 1;
        // 静态内部类的成员方法
        public  void innerMethods(){
            System.out.println("我是静态内部类的成员方法");
            // 调用外部类的静态成员变量
            System.out.println(name);
            // 调用外部类的静态成员方法
            outerInnerStaticMethods();
            // 调用外部类的成员变量
            System.out.println(new Outer().age);
            // 调用外部类的成员方法
            new Outer().outerInnerMethods();
        }
        // 静态内部类的静态方法
        public static void innerStaticMethods(){
            System.out.println("我是静态内部类的静态方法");
            // 调用外部类的静态成员变量
            System.out.println(name);
            // 调用外部类的静态成员方法
            outerInnerStaticMethods();
            // 调用外部类的成员变量
            System.out.println(new Outer().age);
            // 调用外部类的成员方法
            new Outer().outerInnerMethods();
        }
    }

}

静态内部类可以用public,protected,private修饰
静态内部类中可以定义静态或者非静态的成员
静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
外部类访问内部类的静态成员：内部类.静态成员
外部类访问内部类的非静态成员:实例化内部类即可

注意：

生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner(); 而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类

局部内部类

在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

public class Outer {
    // 成员变量
    private int age;
    // 静态成员变量
    private static String name;
    // 成员方法
    public void innerOuterMethods(){
        int innerOuterMethodsVariable = 10;
        // 局部内部类
        class Inner {
            // 成员变量
            private int age;
            // 局部内部类不能有静态成员变量
            // private static String name;
            // 局部内部类的成员方法
            public void innerMethods(){
                // 调用内部类的成员变量
                System.out.println(age);
                // 调用外部类成员方法的变量,此变量如果不加入final的或java内部默认加上final
                // 因为只有final定义的成员变量存在于方法区，而非存在于堆栈。存活的生命周期长。
                System.out.println(innerOuterMethodsVariable);
                // 调用外部类的成员变量
                System.out.println(Outer.this.age);
            }
            // 局部内部类不能有静态成员方法
            // public static void innerStaticMethods(){}
        }
    }
    // 静态成员方法
    public static void innerOuterStaticMethods(){

    }
}

局部内部类中可以定义与外部类同名的变量
局部内部类中不可以定义静态变量
如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
用this.变量名访问的也是内部类变量
用外部类名.this.内部类变量名访问的是外部类变量
访问局部内部类必须先有外部类对象

匿名内部类

匿名内部类就是没有名字的内部类。

使用场景：

只用到类的一个实例。
类在定义后马上用到。
类非常小（SUN推荐是在4行代码以下）
给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则：
　　匿名内部类不能有构造方法。
　　匿名内部类不能定义任何静态成员、方法和类。
　　匿名内部类不能是public,protected,private,static。
　　只能创建匿名内部类的一个实例。
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

interface InnerClass{
    void test();
}
public class Outer {
    // 成员变量
    private int age;
    // 静态成员变量
    private static String name;
    // 成员方法
    public void innerOuterMethods() {
    }
    // 静态成员方法
    public void innerOuterStaticMethods() {

    }
    public InnerClass getInnerClass(final int num, String str){
        return new InnerClass() {
            @Override
            public void test() {
                System.out.println("这里是匿名内部类");
            }
        };
    }

}

知识是无价的，代码是开源的。
希望能对他人有所帮助！！！

敢敢-李

发布了9 篇原创文章 · 获赞 15 · 访问量 2243

私信关注