千峰Java教程：068. 内部类详解②

最新推荐文章于 2022-01-20 20:10:27 发布
最新推荐文章于 2022-01-20 20:10:27 发布
阅读量1.1k 收藏
点赞数
分类专栏： 【Java】初学 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silent0001/article/details/90477671
版权

书接上文

静态内部类

在一个类内部定义一个静态内部类：

静态的含义是该内部类可以像其他成员一样，没有外部类对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。下面代码我们重点看有关Inner3的代码：

public class Demo1
{
	public static void main(String[] args)
	{
		Outer outer = new Outer();
		
		//在外部创建成员内部类的实例：
		/*Outer.Inner inner =outer.new Inner();
		//调用内部类方法：
		inner.print();
		
		outer.innerPrint();
		outer.show();*/
		
		Outer.Inner3 n = new Outer.Inner3();//Inner3的内部类
		n.print();
	}
}

class Outer
{
	private String name;
	//添加这个方法：
	public void innerPrint()
	{
		Inner inner = new Inner();
		inner.print();
	}
	private class Inner//成员内部类
	{
		public void print()
		{
			System.out.println("成员内部类");
		}
	}
	public void show()//方法内部类
	{
		int x = 10;
		class Inner2//
		{
			public void print()
			{
				//x++;//这里就会出现错误: 从内部类引用的本地变量必须是最终变量或实际上的最终变量，因为上面的x=10这个10就已经是最终变量了，int x = 10;可以理解成final int x = 10;
				System.out.println("方法内部类"+x);
			}
		}
		Inner2 inner2 = new Inner2();//增加这行跟下面这行
		inner2.print();
	}
	static class Inner3
	{
		public void print()
		{
			System.out.println("这是静态内部类");
		}
	}	
}
/*
结果：
这是静态内部类
*/

这样写的目的就是基于封装的概念，内部类跟外部类之间一定是有关系的，否则不会出现内部类概念。比如你家里的亲戚能住在你家，一般大街上一个人能随便让他住在自己家吗？说是有相对关系，只不过，这个相对关系比较独立，这个内部类附属在外部类里面，有一定的关系，但是没有实际上的代码调用关系，这就是封装。刚才说了，在静态内部类里面是不能访问外部类的属性的（在普通内部类和方法内部类可以），因为静态类里面只能访问静态变量。

匿名内部类

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

匿名内部类三种情况：

（1）继承式的匿名内部类；

（2）接口式的匿名内部类；

（3）参数式的匿名内部类。

 

先看继承式匿名内部类：

public class Demo1
{
	public static void main(String[] args)
	{
		Outer outer = new Outer();
		
		//在外部创建成员内部类的实例：
		/*Outer.Inner inner =outer.new Inner();
		//调用内部类方法：
		inner.print();
		
		outer.innerPrint();
		outer.show();
		
		Outer.Inner3 n = new Outer.Inner3();//Inner3的内部类
		n.print();*/
		
		outer.print1();
	}
}

class Outer
{
	private String name;
	//添加这个方法：
	public void innerPrint()
	{
		Inner inner = new Inner();
		inner.print();
	}
	private class Inner//成员内部类
	{
		public void print()
		{
			System.out.println("成员内部类");
		}
	}
	public void show()//方法内部类
	{
		int x = 10;
		class Inner2//
		{
			public void print()
			{
				//x++;//这里就会出现错误: 从内部类引用的本地变量必须是最终变量或实际上的最终变量，因为上面的x=10这个10就已经是最终变量了，int x = 10;可以理解成final int x = 10;
				System.out.println("方法内部类"+x);
			}
		}
		Inner2 inner2 = new Inner2();//增加这行跟下面这行
		inner2.print();
	}
	static class Inner3
	{
		public void print()
		{
			System.out.println("这是静态内部类");
		}
	}
	public void print1()//继承式匿名内部类
	{
		Cat cat = new Cat()//新建一个对象
		{
			public void eat()
			{//加大括号，表示实现
				System.out.println("cat:匿名继承内部类");
			}
		};//这里一定要加分号，从61行到这一行是一条语句。	
		cat.eat();
	}
}

abstract class Cat//抽象类，下面要有抽象方法，应加abstract
{
	public abstract void eat();
}
/*
结果：
cat:匿名继承内部类
*/
//这个内部类创建以后，也会产生成一个Outer$1.class文件

然后是接口式匿名内部类：

public class Demo1
{
	public static void main(String[] args)
	{
		Outer outer = new Outer();
		
		//在外部创建成员内部类的实例：
		/*Outer.Inner inner =outer.new Inner();
		//调用内部类方法：
		inner.print();
		
		outer.innerPrint();
		outer.show();
		
		Outer.Inner3 n = new Outer.Inner3();//Inner3的内部类
		n.print();*/
		
		outer.print1();
		outer.print2();
	}
}

class Outer
{
	private String name;
	//添加这个方法：
	public void innerPrint()
	{
		Inner inner = new Inner();
		inner.print();
	}
	private class Inner//成员内部类
	{
		public void print()
		{
			System.out.println("成员内部类");
		}
	}
	public void show()//方法内部类
	{
		int x = 10;
		class Inner2//
		{
			public void print()
			{
				//x++;//这里就会出现错误: 从内部类引用的本地变量必须是最终变量或实际上的最终变量，因为上面的x=10这个10就已经是最终变量了，int x = 10;可以理解成final int x = 10;
				System.out.println("方法内部类"+x);
			}
		}
		Inner2 inner2 = new Inner2();//增加这行跟下面这行
		inner2.print();
	}
	static class Inner3
	{
		public void print()
		{
			System.out.println("这是静态内部类");
		}
	}
	public void print1()//继承式匿名内部类
	{
		Cat cat = new Cat()//新建一个对象
		{
			public void eat()
			{//加大括号，表示实现
				System.out.println("cat:匿名继承内部类");
			}
		};//这里一定要加分号，从61行到这一行是一条语句。	
		cat.eat();
	}
	public void print2()//接口式匿名内部类
	{
		Eat eat = new Eat()//接口是不能被新建的，所以我们加了个大括号，来实现这个接口，然后，大括号后面记得要加分号
		{
			public void eat()
			{
				System.out.println("cat:匿名接口式内部类");
			}
		};
		eat.eat();
	}
}

interface Eat
{
	public void eat();
}

abstract class Cat//抽象类，下面要有抽象方法，应加abstract
{
	public abstract void eat();
}
/*
结果：
cat:匿名继承内部类
cat:匿名接口式内部类
*/
//再创建这个匿名内部类时，就又会生成一个Outer$2.class文件

然后是参数是内部类

public class Demo1
{
	public static void main(String[] args)
	{
		Outer outer = new Outer();
		
		//在外部创建成员内部类的实例：
		/*Outer.Inner inner =outer.new Inner();
		//调用内部类方法：
		inner.print();
		
		outer.innerPrint();
		outer.show();
		
		Outer.Inner3 n = new Outer.Inner3();//Inner3的内部类
		n.print();*/
		
		outer.print1();
		outer.print2();
		outer.print3(new Eat()
		{
			public void eat()//方法在这里写
			{
				System.out.println("参数式匿名内部类");//这里不要加eat了，会提示错误: 找不到符号
			}
		});//也可以传多个参数，中间加逗号，那样写就比较复杂了
	}
}

class Outer
{
	private String name;
	//添加这个方法：
	public void innerPrint()
	{
		Inner inner = new Inner();
		inner.print();
	}
	private class Inner//成员内部类
	{
		public void print()
		{
			System.out.println("成员内部类");
		}
	}
	public void show()//方法内部类
	{
		int x = 10;
		class Inner2//
		{
			public void print()
			{
				//x++;//这里就会出现错误: 从内部类引用的本地变量必须是最终变量或实际上的最终变量，因为上面的x=10这个10就已经是最终变量了，int x = 10;可以理解成final int x = 10;
				System.out.println("方法内部类"+x);
			}
		}
		Inner2 inner2 = new Inner2();//增加这行跟下面这行
		inner2.print();
	}
	static class Inner3
	{
		public void print()
		{
			System.out.println("这是静态内部类");
		}
	}
	public void print1()//继承式匿名内部类
	{
		Cat cat = new Cat()//新建一个对象
		{
			public void eat()
			{//加大括号，表示实现
				System.out.println("cat:匿名继承内部类");
			}
		};//这里一定要加分号，从61行到这一行是一条语句。	
		cat.eat();
	}
	public void print2()//接口式匿名内部类
	{
		Eat eat = new Eat()//接口是不能被新建的，所以我们加了个大括号，来实现这个接口，然后，大括号后面记得要加分号
		{
			public void eat()
			{
				System.out.println("cat:匿名接口式内部类");
			}
		};
		eat.eat();
	}
	public void print3(Eat eat)//参数式匿名内部类,要往方法里传一个参数（把接口当参数）
	{
		eat.eat();
	}
}

interface Eat
{
	public void eat();
}

abstract class Cat//抽象类，下面要有抽象方法，应加abstract
{
	public abstract void eat();
}
/*
结果：
cat:匿名继承内部类
cat:匿名接口式内部类
参数式匿名内部类
*/

在使用匿名内部类时，要记住以下几个原则：

（1）不能有构造方法，只能有一个实例

（2）不能定义任何形态成员、静态方法

（3）不能是public、protected、private、static

（4）一定是在new的后面，用其隐含实现一个接口或继承一个类

（5）匿名内部类为局部的，所以局部内部类的所有限制都对其生效

小低能儿
关注
专栏目录
Java ElasticSearch6入门教程 62集(千峰)
weixin_44884277的博客
04-10 624
课程介绍 ElasticSearch(简称ES)：是一个基于Lucene构建的开源、分布式、RESTful的全文本搜索引擎；它还是一个分布式实时文档存储，其中每个field均是被索引的数据且可被搜索；也是一个带实时分析功能的分布式搜索引擎，并且能够扩展至数以百计的服务器存储及处理PB级的数据。 目录1 ~6 R7 o: }2 `% a5 @: m* ^' x# u3 K ├─千锋Java教程：01...
从内部类中访问本地变量
aihuo4431的博客
06-14 801
从内部类中访问本地变量temp; 需要被声明为最终类型 class Outer{ // 定义外部类 private String info = "hello world" ; // 定义外部类的私有属性 public void fun(final int temp){ // 定义外部类的方法 class Inner{ // 在方法中定义的内 ...
千峰Java教程：067. 内部类详解①
Pro.Jexus
05-22 641
18、内部类 内部类就是在一个类的内部定义的类 成员内部类格式如下： class Outer { class Inner//成员内部类 { } } 阐述上述代码会产生两个文件： Outer.class和Outer$Inner.class 1、在外部创建内部类对象： 内部类除了可以在外部类中产生实例化对象，也可以在外部类的外部来实例化。 那么，根据内部类生成的*.cla...
Java学习（自用，不定期更新）（六）
mengxinQWQ的博客
10-17 317
接口接口接口定义格式接口的基本实现接口的多实现实现格式接口访问优先级的问题接口的多继承接口其他成员特点finalfinal使用使用final修饰类使用final修饰变量局部变量 ------ 基本类型局部变量 ------ 引用类型权限修饰符不同权限的访问能力使用建议内部类访问特点成员内部类匿名内部类使用前提与格式 接口 接口，是Java语言中一种引用类型，接口中只定义了方法，如果说类的内部封装了...
Java：从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
咸鱼想睡觉
05-15 9034
报错Case Lambda表达式对dest添加对象，后续对dest变量修改（非内容修改），报错！ List<String> dest = new ArrayList<>(); List<String> src = new ArrayList<>(Arrays.asList("01", "02", "03")); src.forEach(item -> { dest.add("dest: " + item); }); dest = nu...
Error:(343, 83) java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
霸王龙i的博客
06-28 1万+
/** * 问题代码（只是为了重现错误，请忽略代码逻辑） */ @Test public void test23(){ ArrayList<Book> list = new ArrayList<>(); list.add(new Book("魔法书","20")); list.a...
千峰Python超详细入门教程(百度云盘分享).txt
04-04
├─千锋Python教程：第01章 第一个Python程序与数据存储及数据类型（9集） │ │ .DS_Store │ │ │ ├─code │ │ 1、数据存储.txt │ │ 2、第一个python程序.py │ │ 3、注释.py │ │ 4、输出与输入.py │ ...
Java从入门到精通核心技术教程全套千峰2021新版35G
04-10
├─第01章 Java开发入门 │ 002_Java开发入门_计算机基本概念与DOS命令.mp4 │ 003_Java开发入门_发展史体系与下载.mp4 │ 005_Java开发入门_HelloWorld案例与分析.mp4 │ 006_Java开发入门_JavaDoc与跨平台...
千峰JAVA培训视频教程（2017版Java核心技术）
03-02
此资源包含Java基础教程+课程源码，有意者自取。（2017版Java核心技术）
Java核心技术全套教程：入门至精通(千峰2021新版)
资源摘要信息: "Java从入门到精通核心技术教程全套千峰2021新版35G" 本资源是一套系统性的Java编程语言学习教程，由千峰教育出品，更新至2021年的新版本，内容丰富，涵盖了从基础入门到核心技术的各个方面，适合...
为什么从内部类访问局部变量，需要被声明为最终类型？
seashine_yan的博客
03-28 2999
参考：http://www.cnblogs.com/ffxxbb/archive/2014/03/11/3594938.html 首先要明白： 一个完整的Java程序运行过程会涉及以下内存区域：         寄存器：JVM内部虚拟寄存器，存取速度非常快，程序不可控制。         栈：保存局部变量的值，包括：a.用来保存基本数据类型的值；b.保存类的实例，即堆区对象的引用(指针
java面向对象内部类中有关知识点2
zgq258的博客
01-18 153
java面向对象内部类的要点2
Lambda表达式
贪婪的君子
04-02 819
在Java SE 8中新增了一项比较有用的特性，这项特性可以是我们的代码变得更加简洁(concise)。
从内部类中访问本地变量userNameToSelect；需要被声明为最终类型——解决办法为原因解析
熊仙森滴Blog
09-12 6270
Android studio 中报错如下 一，首先了解一下什么是内部类 　　在java中，将一个类定义在另一个类里面或者是方法里面，这样的类被称为是内部类内部类。大概可以分为四类类：成员内部类、局部内部类、匿名内部类和静态内部类。 　　这四种类具体的区别可参考java内部类详解 二，为什么只能访问局部final变量？　　 　　 　　在局部内部类和匿名内部类中只能访问局部fi...
Java8增加功能--Effectively final 功能
热门推荐
西召
04-16 1万+
java8新增了很多功能，可以大大简化代码，这个系列将会一一辅助代码加以介绍。 局部内部类和匿名内部类访问的局部变量必须由final修饰，java8开始，可以不加final修饰符，由系统默认添加。java将这个功能称为：Effectively final 功能。 下面是完整掩饰代码（至少使用jdk1.8版本）：
Java笔记：内部类——简介
长不大的大灰狼
02-18 183
内部类 1）实例内部类 2）静态内部类 3）匿名内部类 4）本地内部类（定义在方法中的内部类） 1 实例内部类 （1）获取实例内部类的对象？ OuterClass.InnerClass innerClass = outerClass.new InnerClass(); 外部类类名.内部类类名 变量 = 外部类对象的引用.new ...
Day13 内部类以及常用类Object中的各种方法
m0_64350718的博客
01-20 379
内部类以及匿名内部类，常用类Object中的各种方法 拷贝
Java疯狂讲义笔记——内部类
weixin_30401605的博客
12-31 95
【定义】内部类：定义在其它类内部的类。外部类：包含内部类的类，也称 宿主类。局部内部类：定义在方法里的内部类。 【接口内部类】接口中也可以定义内部类，必须为public static修饰（自动添加），接口内部类只能时静态内部类。【接口的内部接口】接口的内部接口为接口成员，必须为public static（自动）。 【与外部类关系】1，成员内部类是类成员。 成员内部类：静态内部类、非静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值