Java——匿名内部类

最新推荐文章于 2025-05-20 14:00:45 发布

caigen001

最新推荐文章于 2025-05-20 14:00:45 发布

阅读量3.3k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： 3.Java基础知识笔记（毕向东）文章标签：匿名内部类静态内部类内部类匿名对象

本文链接：https://blog.youkuaiyun.com/caigen0001/article/details/89877058

3.Java基础知识笔记（毕向东）专栏收录该内容

9 篇文章

订阅专栏

博客主要介绍了匿名内部类，它是内部类的简化写法。前提是内部类可继承或实现外部类、接口，格式为 new 外部类名或接口名并覆盖代码。还提到匿名内部类是带内容的子类匿名对象，且定义方法最好不超3个，最后给出改写示例及测试题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

匿名内部类:

就是内部类的简化写法。
前提：

• 内部类可以继承或实现一个外部类或者接口。

格式为：

• new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容)}

简单理解：

• 就是建立一个建立一个带内容的外部类或者接口的子类匿名对象。

匿名内部类:

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式：new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

类型1：

//1.内部类，继承父类
class Father
{
	public void show()
	{
		System.out.println("Father::show()");
	}
}
class Outer
{
	class Inner extends Father
	{
		public void show()
		{
			System.out.println("Inner::show()");
		}
		public void sleep()
		{
			System.out.println("Inner::sleep()");
		}
	}

}
public class TestDemo0
{
	public static void main(String[] args)
	{
		new Outer().new Inner().show();
		new Outer().new Inner().sleep();
	}
}
/*
Inner::show()
Inner::sleep()
*/

改写成匿名内部类：

//1.改写成匿名内部类
class Father
{
	public void show()
	{
		System.out.println("Father::show()");
	}
}
class Outer
{
	public void function()
	{
		Father f = new Father()
		{
			public void show()
			{
				System.out.println("Inner::show()");
			}
			public void sleep()
			{
				System.out.println("Inner::show()");
			}
		};
		f.show();
//		f.sleep();//Father类中不存在sleep()
	}
}
public class TestDemo0
{
	public static void main(String[] args)
	{
		new Outer().function();
	}
}
/*
Inner::show()
*/

类型2：

//2.静态内部类，继承父类
class Father
{
	public void show()
	{
		System.out.println("Father::show()");
	}
}
class Outer
{
	static class Inner extends Father
	{
		public void show()
		{
			System.out.println("Inner::show()");
		}
		public void sleep()
		{
			System.out.println("Inner::sleep()");
		}
	}
}
public class TestDemo0
{
	public static void main(String[] args)
	{
		new Outer.Inner().show();
		new Outer.Inner().sleep();
	}
}
/*
Inner::show()
Inner::sleep() 
 */

改成匿名内部类：

class Father
{
	public void show()
	{
		System.out.println("Father::show()");
	}
}
class Outer
{
	public static void function()
	{
		Father f = new Father()
		{
			public void show()
			{
				System.out.println("Inner::show()");
			}
			public void sleep()
			{
				System.out.println("Inner::sleep()");
			}
		};
		f.show();
//		f.sleep();//Father类中不存在sleep()
	}
}
public class TestDemo0
{
	public static void main(String[] args)
	{

		Outer.function();
	}
}
//Inner::show()

类型3：

//3.静态内部中有静态方法，继承父类
class Father//一般类不能定义为静态类，只有内部类可以定义为静态类
{//只能在静态类型或者顶级类型中才能声明静态方法
	public static void show()//show()处在顶级类型中
	{
		System.out.println("Father::show()");
	}
}
class Outer
{
	static class Inner extends Father
	{
		public static void show()
		{
			System.out.println("Inner::show()");
		}
		public static void sleep()
		{
			System.out.println("Inner::show()");
		}
	}	
}
public class TestDemo0
{
	public static void main(String[] args)
	{
		Outer.Inner.show();
		Outer.Inner.sleep();
	}
}
/*
Inner::show()
Inner::sleep()
*/

改成匿名内部类：

class Father//一般类不能定义为静态类，只有内部类可以定义为静态类
{//只能在静态类型或者顶级类型中才能声明静态方法
	public static void show()//show()处在顶级类型中
	{
		System.out.println("Father::show()");
	}
}
class Outer
{	
	public static void function()
	{
		Father f = new Father()//Father类不能声明为静态类，所以其内不能存在静态方法
		{
			public static void show()//此静态方法不能隐藏Father中的实例方法
			{//只能在静态类型或者顶级类型中才能声明静态方法
				System.out.println("Inner::show()");
			}
			public static void sleep()
			{//只能在静态类型或者顶级类型中才能声明静态方法
				System.out.println("Inner::show()");
			}
		};
		f.show();
//		f.sleep();//Father类中不存在sleep()
	}
}
public class TestDemo0
{
	public static void main(String[] args)
	{
		Outer.function();
	}
}
/*
 不能转换为匿名内类，只能在静态类型或者顶级类型中才能声明静态方法。
匿名类Father不是静态类，所以其内不能定义静态方法。
 */

类型4.

//4.内部类，继承接口
abstract class Abstract
{
	void show() {};
}

class Outer
{
	class Inner extends Abstract
	{
		public void show()
		{
			System.out.println("Inner::show()");
		}
		public void sleep()
		{
			System.out.println("Inner::sleep()");
		}
	}
}

class  TestDemo0
{
	public static void main(String[] args) 
	{
		new Outer().new Inner().show();
		new Outer().new Inner().sleep();
	}
}
/*
 Inner::show()
Inner::sleep()
 */

转换为内部类：

abstract class Abstract
{
	void show() {};
}

class Outer
{
	public void function()
	{
		Abstract ab = new Abstract()
		{
			public void show()
			{
				System.out.println("Inner::show()");
			}
			public void sleep()
			{
				System.out.println("Inner::sleep()");
			}
		};
		ab.show();
//		ab.sleep();
	}
}

class  TestDemo0
{
	public static void main(String[] args) 
	{
		new Outer().function();
	}
}
//Inner::show()

类型5：

interface Abstract
{
	public abstract void show();
}
class Outer
{
	class Inner implements Abstract
	{
		public void show()
		{
			System.out.println("Inner show()");
		}
		public void sleep()
		{
			System.out.println("Inner sleep()");
		}
	}
}

public class TestDemo0
{
	public static void main(String[] args)
	{
		new Outer().new Inner().show();
		new Outer().new Inner().sleep();
	}
}
//Inner show()
//Inner sleep()

转换为匿名类：

interface Abstract
{
	public abstract void show();
}
class Outer
{
	public void function()
	{
		Abstract ab = new Abstract()
		{
			public void show()
			{
				System.out.println("Innre show()");
			}
			public void sleep()
			{
				System.out.println("Innre sleep()");
			}
		};
		ab.show();
//		ab.sleep();
	}
}

public class TestDemo0
{
	public static void main(String[] args)
	{
		new Outer().function();
	}
}
//Inner show()

类型6：

interface Abstract
{
	public abstract void show();
}
class Outer
{
	static class Inner implements Abstract
	{
		public void show()
		{
			System.out.println("Inner show()");
		}
	}
	static Inner function()
	{
		return new Inner();
	}
}

public class TestDemo0
{
	public static void main(String[] args)
	{
		Outer.function().show();
	}
}
//Inner show()

转换为匿名类：

interface Abstract
{
	public abstract void show();
}
class Outer
{
	static Abstract function()
	{
		return new Abstract()
				{
					public void show()
					{
						System.out.println("Inner show()");
					}
				};
	}
}

public class TestDemo0
{
	public static void main(String[] args)
	{
		Outer.function().show();
	}
}
//Inner show()

测试题：通过匿名类补足代码

interface Inter
{
    void method();
}
class Test
{
    //补足代码，通过匿名内部类
}
class InnerClassTest
{
    public static void mian(String[] args)
    {
        Test.function().method();
    }
}

参考答案及分析:

interface Inter
{
    void method();
}
class Test
{
    //补足代码，通过匿名内部类
    /*
    //内部类方法实现
    static class Inner implements Inter
    {
        public void method()
        {
            System.out.println("method run");
        }
    }
    static Inter function()
    {
        return new Inner();
    }
    */
    //使用匿名内部类来实现
    static Inter function()
    {
        return new Inter()
        {
            public void method()
            {
                System.out.println("method run");
            }
        };
    }
}
class InnerClassTest
{
    public static void mian(String[] args)
    {
        //Test.function():Test类中有一个静态的方法function()
        //.method():function这个方法运算后的结果是一个对象，而是一个Inter类型的对象
        //因为只有是Inter类型的对象，才可以调用method方法。
        //Inter in = Test.function();
        //in.method();
        Test.function().method();
        
 /*       
        show(new Inter()
        {
			public void method()
			{
				System.out.println("method show run");
			}
		});

	}
	public static void show(Inter in)
	{
		in.method();
	}
 */
 
}
/*
method run
*/