内部类

最新推荐文章于 2025-12-05 17:02:52 发布

原创最新推荐文章于 2025-12-05 17:02:52 发布 · 87 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

内部类

概述

内部类：位于一个类内部的类就叫内部类
访问特点：

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员必须要创建对象

class Outer
{
    int num;
    public void show()
    {
        System.out.println("show...");
    }
    class Inner
    {
        public void test()
        {
            System.out.println(num+"...test...");
        }
    }
    public void outerTest()
    {
        Inner i=new Inner();
        i.test();
    }
}

内部类的分类

成员内部类：在成员位置定义的类。
局部内部类：在局部位置定义的类。

在测试类中创建内部类对象的格式

外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner i=new Outer().new Inner();
//我们可以通过该内部类对象在测试类中访问内部类的成员
i.test();

成员内部类可以被static和private修饰（外部类不能被static和private修饰）
被private修饰时，内部类无法在测试类中创建对象，所以需要在外部类中提供访问方法，比如outerTest方法
被static修饰后，内部类属于外部类，测试类中创建对象的格式为

外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner i=new Outer.Inner();

注意事项：

静态内部类访问的外部类数据必须用静态修饰
成员方法可以是静态的也可以是非静态的

public class Test {
    public static void main(String[] args) {
       Outer.Inner i=new Outer.Inner();
       i.test();
    }
}
class Outer
{
    static int num;
    public void show()
    {
        System.out.println("show...");
    }
    static class Inner
    {
        public void test()
        {
            System.out.println(num+"...test...");
        }
    }
    public void outerTest()
    {
        Inner i=new Inner();
        i.test();
    }
}

面试题：

class Outer {
		public int num = 10;
		class Inner {
			public int num = 20;
			public void show() {
				int num = 30;
				System.out.println(num);	//30，访问局部变量
				System.out.println(this.num);	//20，访问内部类中的变量
				System.out.println(new Outer().num); 	//10，访问外部类中的变量
			}
		}
	}
	class InnerClassTest {
		public static void main(String[] args) {
			Outer.Inner oi = new Outer().new Inner();
			oi.show();
		}	
	}

局部内部类注意事项：局部内部类访问的局部变量必须用final修饰
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。

匿名内部类

概述

匿名内部类：没有名称的类，主要用来创建对象
前提：存在一个类或者是接口，类可以是具体类也可以是抽象类
格式：

new 类名或者接口名(){
		重写方法;
	};

匿名内部类的本质：是一个继承了该类或者实现了该接口的子类匿名对象

匿名内部类的方法调用

匿名内部类调用一个方法

//因为匿名内部类本质是一个对象，我们可以在后面直接调用方法
public class Test
{
    public static void main(String[] args) 
    {
        new AA()
        {
            @Override
            public void show()
            {
                System.out.println("show...");
            }
        }.show();
    }
}
interface AA
{
    public abstract void show();
}

匿名内部类调用多个方法

/*
当一个类或者接口中有多个方法时，匿名内部类必须将抽象方法全部重写
非抽象方法如果需要重写内容就重写，不需要可以不重写
如果想要调用多个方法，就需要创建多个匿名内部类来调用多个方法
一个匿名内部类只能调用一个方法，和匿名对象一样
*/
public class Test2
{
    public static void main(String[] args)
    {
        new AA()
        {
            @Override
            public void show()
            {
                System.out.println("show...");
            }

            @Override
            public void test() {
                System.out.println("test...");
            }
        }.show();
        new AA()
        {
            @Override
            public void show()
            {
                System.out.println("show...");
            }

            @Override
            public void test() {
                System.out.println("test...");
            }
        }.test();
    }
}
interface AA
{
    public abstract void show();
    public abstract void test();
}
/*
我们也可以用多态的形式定义一个引用类型的变量来存储这个匿名内部类
这样也可以通过这个引用来调用多个方法
*/
public class Test2 {
    public static void main(String[] args) {
        AA a = new AA() {
            @Override
            public void show() {
                System.out.println("show...");
            }
            @Override
            public void test() {
                System.out.println("test...");
            }
        };
        a.show();
        a.test();
    }
}
interface AA
{
    public abstract void show();
    public abstract void test();
}

匿名内部类作为实参或者返回值

匿名内部类作为形参

/*
我们说过，当一个方法的形参是一个接口名或者抽象类名时，需要传入该类的子类对象
匿名内部类的本质就是接口或者一个类的子类，所以可以当作实参传递
*/
public class Demo {
    public static void main(String[] args) {
        test(new AA(){
            @Override
            public void show() {
                System.out.println("show");
            }
        });
    }
    public static void test(AA a)
    {
        a.show();
    }
}
abstract class AA{
    public abstract void show();
}

匿名内部类作为返回值

/*
同样的，如果一个方法的返回值类型是一个接口或者抽象类，我们可以返回该类子类对象
匿名内部类也可以作为返回值
*/
public class Demo {
    public static void main(String[] args) {
        test().show();
    }
    public static BB test()
    {
        return new BB() {
            @Override
            public void show() {
                System.out.println("show");
            }
        };
    }
}
abstract  class BB{
    public abstract void show();
}

当内部类为接口或者抽象类时

//当内部类为接口或者抽象类时，我们可以通过创建接口或者内部类的匿名内部类来重写并调用其中的方法
public class Demo5 {
    public static void main(String[] args) {
        new CC.Interface(){
            @Override
            public void show() {
                System.out.println("show");
            }
        }.show();
    }
}
class CC{
    interface Interface{
        public abstract void show();
    }
}

当内部类为接口或者抽象类且被private修饰时

/*
当内部类为接口或者抽象类且被private修饰时
因为被private修饰，所以我们要对外提供访问方法，用static修饰，是为了可以通过类名直接调用
在该方法中，我们可以通过创建接口或者抽象类的匿名内部类来重写并调用其中的方法
*/
public class Demo5 {
    public static void main(String[] args) {
        CC.get();
    }
}
class CC{
    private interface Interface{
        public abstract void test();
    }
    public static void get()
    {
        new Interface(){
            @Override
            public void test() {
                System.out.println("test");
            }
        }.test();
    }
}

面试题：匿名内部类中this关键字

interface Inter {
		public static final int a = 23 ;
	}
public class Test {
	public static void main(String[] args) {
		new Inter() {
			public void show() {
				System.out.println(this.a);
			}
		}.show();
	}
}
/*
因为匿名内部类调用的show方法，所以this代表匿名内部类
输出结果为23
*/