第十章 内部类 内部类的作用、闭包、内部类继承、覆盖重写内部类、局部内部类、内部类标识符

最新推荐文章于 2021-03-04 18:08:28 发布
最新推荐文章于 2021-03-04 18:08:28 发布
阅读量2k 收藏 2
点赞数
分类专栏： Thinking in java 的学习总结 文章标签： java 基础

1.为什么需要内部类

  • 内部类继承自某个类或者实现某个接口，内部类可以访问创建它的外部类的对象或参数资源。
  • 内部类能独立的实现某个接口，无论外围类是否实现了这个接口。
  • 内部类使多重继承的解决方案变得更加完善。
    下面的代码体现内部类实现多重继承，实现多个接口

    interface A{}
interface B{}

//实现两个接口的单一类
class X implements A,B{}
//实现两个接口的存在内部类的类
class Y implements A{
        //在内部类实现另一个B接口
	B makeB(){
		//返回一个内部类
		return new B() {};
	}
}

public class MultiInterfaces {

	static void takesA(A a){}
	static void takesB(B b){}
	public static void main(String[] args) {
		//声明外部类
		X x = new X();
		Y y = new Y();
		/**
		 * 下面可以看到x和y都可以实现传入takes.()方法中，而这是两个接口
		 */
		takesA(x);
		takesA(y);
		takesB(x);
		//获取内部类并传入takesB()
		takesB(y.makeB());
	}
}
    从实现的观点来看，上面的外部类实现多重继承和内部类实现多重继承并没有什么区别
  • 上面是接口，所以实现多重继承没有问题，但如果要对抽象类或实际类实现多重继承，就需要使用内部类来实现

    class D{}
abstract class E{}
//一个外部类继承了D就不能再继承其他的类了
class Z extends D{
	//内部类实现多重继承
	E makeE(){return new E(){};}
}
public class MultiImplementation {
	static void takesD(D d){}
	static void takesE(E e){}
	public static void main(String[] args) {
		Z z = new Z();
		takesD(z);
		//获取Z中的E内部类对象
		takesE(z.makeE());
	}
  1. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与外围类相互独立。
  2. 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口（多个内部类的实现）。
  3. 创建内部类的时刻并不依赖于外围类对象的创建。【这句好像与前面矛盾，楼主也不解】
  4. 内部类没有“is-a”关系，它就是一个实体。

2.闭包

  • 闭包是指可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。闭包包含的自由变量来自于定义闭包的环境。
  • java中的闭包是一个对象,它记录了一些信息，这些信息来自于创建它的作用域。
  • 通过闭包实现java中的回调
    interface Incrementable{
	void increment();
}
//外围类实现一个接口
class Callee1 implements Incrementable{
	private int i = 0;
	//回调方法
	@Override
	public void increment() {
		i++;
		System.out.println(i);
	}
}
class MyIncrement{
	//一个同上面接口中的方法相同的方法
	public void increment(){System.out.println("Other operation");}
	static void f(MyIncrement mi){mi.increment();}
}

//继承自上面的MyIncrement,因为MyIncrement中的方法与Incrementable接口中方法相同，实现回调接口的功能就不可以用普通的方式实现了
class Callee2 extends MyIncrement{
	private int i = 0;
	public void increment() {
		super.increment();
		i++;
		System.out.println(i);
	}
	//一个内部类，实现了一个回调接口，这是一个<span style="color:#FF0000;">闭包</span>，信息来自于创建它的作用域
	private class Closure implements Incrementable{
		//回调方法，也叫钩子
		@Override
		public void increment() {
			/**
			 * 执行外部类的方法，这样只要其他的对象获取到这个内部类接口，就可以调用这个回调方法，回调方法里面调用外部类的private参数，
			 * 实现与外界的相通
			 */
			Callee2.this.increment();
			//使用一个private
			i ++;
		}
	}
	//返回一个回调接口，与外界相联系
	Incrementable getCallbackReference(){
		return new Closure();
	}
}
class Caller{
	private Incrementable callbackReference;
	public Caller(Incrementable cbh) {callbackReference = cbh;}
	void go(){callbackReference.increment();}
	
}
public class Callbacks {
	public static void main(String[] args) {
		Callee1 c1 = new Callee1();
		Callee2 c2 = new Callee2();
		MyIncrement.f(c2);
		//传入一个实现了回调接口的对象
		Caller caller1 = new Caller(c1);
		//得到Callee2内部类声明的回调接口，并传入Caller对象，供Caller对象回调接口中的方法
		Caller caller2 = new Caller(c2.getCallbackReference());
		//执行回调
		caller1.go();
		caller1.go();
		caller2.go();
	}
}
    在Android中，闭包回调多用于Activity和其Fragment之间的传参，当然adapter有时也会与Activity传参使用回调接口的方法。
  • 回调的价值在于它的灵活性，可以在程序运行时动态的决定调用什么方法。

3.内部类与继承

  • 集成过程中的问题在于：内部类的构造器必须链接到只想外围类对象的引用，而到导出类（子类）不存在可连接的默认对象引用。
    要解决这个问题，必须使用特殊的语法
    class WithInner{
	class Inner{}
}
//继承一个内部类
public class InneritInner extends WithInner.Inner{
	public InneritInner(WithInner wi) {
		/**
		 * 构造期内必须引用所继承的外围类对象
		 * 编译器才不会报错
		 */
		wi.super();
	}
	public static void main(String[] args) {
		//调用的时候，总之内部类必须与其外围类链接才能使用，即使继承
		WithInner wi = new WithInner();
		InneritInner ii = new InneritInner(wi);
	}
}

4.覆盖（重写）内部类，像重写方法一样

  • 子类可不可以覆盖父类中的内部类呢
    class Egg{
	private Yolk y;
	protected class Yolk{
		public Yolk() {System.out.println("Egg.Yolk()");}
	}
	public Egg() {
		System.out.println("New Egg()");
		//声明一个内部类对象
		y = new Yolk();
	}
}
public class BigEgg extends Egg{
	//由于父类中也有这个类，所以气不气到覆盖作用呢
	public class Yolk{
		public Yolk() {System.out.println("BigEgg.Yolk()");}
	}
	public static void main(String[] args) {
		new BigEgg();
	}
}
/**
 *输出：未达到想要的情况，未出现覆盖情况
 *New Egg()
 *Egg.Yolk()
 */
  • 当继承某个外围类的时候，内部类并没有发生特别的变化。这两个内部类是完全独立的两个实体，在各自的命名空间内。
  • 明确的继承某个内部类，子类内部类继承父类的内部类，构造器的执行过程是先执行外围类的，再执行相关内部类的
    class Egg2{
	protected class Yolk{
		public Yolk(){System.out.println("Egg2.Yolk()");}
		public void f(){System.out.println("Egg2.Yolk.f()");}
	}
	private Yolk y = new Yolk();
	public Egg2(){System.out.println("New Egg2()");}
	public void insertYolk(Yolk yy){y = yy;}
	public void g(){y.f();}
}
public class BigEgg2 extends Egg2{
	public class Yolk extends Egg2.Yolk{
		public Yolk(){System.out.println("BigEgg2.Yolk()");}
		public void f(){System.out.println("BigEgg2.Yolk.f()");}
	}
	public BigEgg2() {insertYolk(new Yolk());}
	public static void main(String[] args) {
		Egg2 e2 = new BigEgg2();
		e2.g();
	}
}
/**
 * Egg2.Yolk() //这儿很奇怪，其实是先初始化最终父类的class域内的变量，这个是Egg2中的private Yolk y = new Yolk();
 * New Egg2() 
 * Egg2.Yolk() 
 * BigEgg2.Yolk() 
 * BigEgg2.Yolk.f()
 * 
 */

5.局部内部类

  • 在代码块里创建的内部类，比如在一个方法体内创建一个内部类
  1. 局部内部类不能有访问修饰词（private 等），因为它不是外围类的一部分。
  2. 可以访问当前代码块内的常量，以及此外围类的所有成员。
  3. interface Counter{
	int next();
}

public class LocalInnerClass {
	private int count = 0;
	Counter getCounter(final String name){
		//局部内部类
		class LocalCounter implements Counter{
                        //重写构造器
			public LocalCounter() {
				System.out.println("LocalCounter");
			}
			@Override
			public int next() {
				System.out.println(name);
				return count ++;
			}
		}
		//返回此局部内部类
		return new LocalCounter();
	}
	Counter getCounter2(final String name){
		//匿名内部类
		return new Counter() {
			//匿名内部类的高仿构造器
			{System.out.println("Counter");}
			@Override
			public int next() {
				System.out.println(name);
				return count ++;
			}
		};
	}
	public static void main(String[] args) {
		LocalInnerClass lic = new LocalInnerClass();
		Counter 
			c1 = lic.getCounter("Loc inner"),
			c2 = lic.getCounter2("Anonymous inner");
		for (int i = 0; i < 5; i++) 
			System.out.println(c1.next());
		for (int i = 0; i < 5; i++) 
			System.out.println(c2.next());
	}
}
    局部内部类的名字在方法外是不可见的，和匿名内部类没有名字是一样的，那为什么要用局部内部类？？
    唯一的理由是内部类需要一个已命名的构造器或者重写构造器，而匿名内部类并不能实现构造器，它只能用于实例初始化。

    另一个理由是需要不止一个该内部类的对象。

6.内部类标识符

  • 每个类都会产生一个.class文件，其中包含了如何创建该类的对象的全部信息。
  • 内部类也必须生成一个.class文件已包含他们的Class对象信息。
  • 类文件的命名有严格的规则。
    外围类的名字，加上$，在加上内部类的名字。例如LocallnnerClass生成的.class文件包括：
    Counter.class
    LocalInnerClass$1.class
    LocalInnerClass$1LocalCounter.class
    LocalInnerClass.class
  • 如果内部类是匿名的，编译器会简单的产生一个数字作为其标识符。
    如果内部类是嵌套在别的内部类之中，只需直接将它们的名字简单加在其外围类标识符与$的后面

7.应用程序框架

  • 应用程序框架——解决特定的问题的框架。
  • 应用程序框架就是被设计用以解决某类特定问题的一个类或一组类。
  • 要运用某个应用程序框架，通常是继承一个或多个类，并覆盖某些方法。
    在覆盖的方法中编写代码定制应用程序提供的通用解决方案，以解决特定问题。——模板方法设计模式。

    设计模式总是将变化的事物和不变的事物分离开来。其中模板方法是保持不变的事物，可覆盖的方法就是变化的事物。

8.内部类和控制框架

  • 控制框架是一类特殊的应用程序框架，用来解决响应事件的需求。
  • 驱动系统：用来响应事件的系统。
    public abstract class Event {
	private long eventTime;
	protected final long delayTime;
	public Event(long delayTimg){
		this.delayTime = delayTimg;
		start();
	}
	/**
	 * 启动计时器的方法，调用此方法可以重新启动计时器，也能够重复使用Event对象。
	 * 重复一个事件，就在action中调用start()方法
	 */
	public void start(){
		 eventTime = System.nanoTime() + delayTime;
	}
	//何时可运行action()方法。覆盖此方法，实现Event除基于事件以外的其他因素出发action方法
	public boolean ready(){
		return System.nanoTime() >= eventTime;
	}
	//动作执行方法
	public abstract void action();
}
    public class GreenHouseControls extends Controller{

	private boolean light = false;
	//一个内部类 继承Event事件类控制开灯
	public class LightOn extends Event{
		public LightOn(long delayTimg) {super(delayTimg);}
		@Override
		public void action() {
			light = true;
		}
		public String toString(){return "Light is on";}
	}
	//一个内部类 继承Event事件类控制开灯
	public class LightOff extends Event{
		public LightOff(long delayTimg) {super(delayTimg);}
		@Override
		public void action() {
			light = false;
		}
		public String toString(){return "Light is off";}
	}
}
    public class GreenhouseController {

	public static void main(String[] args) {
		GreenHouseControls gc = new GreenHouseControls();
		//添加一个事件 1秒后执行
		gc.addEvent(gc.new LightOff(1000));
	}
}

总结：

  • 内部类使得多重继承更加的完善。



起晚贪黑
关注
专栏目录
java 静态内部类初始化_Java中内部类的使用总结
weixin_35724999的博客
02-25 1606
1、非静态内部类定义内部类很简单，只要把一个类放在另一个类内部定义即可。public class OuterClass{//此处可以定义内部类}注意：同一个java源文件定义了多个类，它们之间是相互独立的，那种情况不是内部类。内部类做为其外部类的成员，因此可以使用任意访问控制符如private、protected和public修饰。外部类的上一级程序单元是包，所以它只有2个作用域:同一个包和任何位...
内部类和闭包
wojiushimogui的博客
10-27 4491
内部类和闭包今天在某java群中看到了这样一个内部类问题，代码如下： InnerDemo01中有一个内部类Bar，InnerDemo01中的method方法中有一个继承Bar的局部子类InnerClass。InnerClass类中调用了method方法中定义的一个局部变量。而我们一般都知道，方法中的局部变量会在执行结束后就会被释放，但是内部类访问此变量就形成了闭包。package com.wrh.
Java内部类的继承（全）
09-03
主要介绍了Java内部类的继承，大家都知道JAVA内部类的构造器必须连接指向其外围类对象的引用，所以在继承内部类的时候，需要在导出类的构造器中手动加入对基类构造器的调用,需要的朋友可以参考下
内部类的继承
weixin_33943836的博客
04-25 66
因为内部类的构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候，情况会变得有些复杂。问题在于，那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不在存在可连接的默认对象。要解决这个问题，必须使用特殊的语法来说清它们之间的关联。 1 //外部类 2 class Outer{ 3 //内部类 4 public Outer(){ 5 ...
内部类标识符
weixin_30911809的博客
09-06 249
由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息。 内部类也必须生成一个.class文件以包含它们的Class对象信息。这些类文件的命名有严格要求：外围类的名字，加上“$”，再加上内部类的名字，如果内部类是匿名的，编译器会简单的产生一个数字。 转载于:https://www.cnblogs.com/xiezhanghua/p/5845582.html...
如何继承一个内部类
weixin_33842328的博客
07-09 539
定义一个内部类时，这个内部类会有一个隐式引用(implicit reference)指向外部类的实例。比如以下的代码： class WithInner { class Inner {} } 事实上。内部类Inner默认会有一个带參数的构造函数，我们通过反射来看一下。 import java.lang.reflect.Constructor; import java.lang...
内部类继承
程序緣的专栏
10-30 305
 定义一个内部类时，这个内部类会有一个隐式引用(implicit reference)指向外部类的实例。例如下面的代码： [java] view plaincopyprint? class WithInner {      class Inner {}  }   class WithInner { class Inner {} } 其实，内部类Inner
Java内部类之间的闭包和回调详解
09-01
成员内部类、局部内部类、嵌套内部类和匿名内部类都是实现闭包的方式。例如，成员内部类可以直接访问外部类的私有变量，而匿名内部类常用于事件监听器，如上述示例中的`setOnClickListener`，它创建了一个实现了`...
JavaScript 高级篇之闭包、模拟类,继承（五）
10-28
闭包的形成通常涉及到内部函数的引用被返回或存储，使得内部函数能够保持对外部作用域的访问，从而形成一个持久化的上下文。 1. **函数作用域**： 在JavaScript中，每个函数都有自己的作用域，这意味着函数内的...
JAVA 内部类 PPT
05-16
2. **内部类继承** - 内部类可以继承其他类或实现接口，这为实现复杂的继承结构提供了可能。 3. **子类与父类的内部类同名** - 如果子类和父类都有内部类同名的情况，子类的内部类会覆盖父类的内部类，访问时需...
内部类：内部类的继承
Me
08-14 275
一、父类和子类在同一个外部类中 package org.lgy.study.innerclass; public class InnerClassInheritance{ //如果父类是静态的，则子类既可以是静态的也可以是非静态的； //如果父类是非静态的，则子类只能是非静态的。 public static class InBase{ public InBase...
java 继承 重写内部类_Java中的重载，重写，继承，封装，抽象类，接口，内部类，线程和进程...
weixin_42098104的博客
02-16 342
Java中的重载，重写，继承，封装，抽象类，接口，内部类，线程和进程重载，重写**方法相同，参数类型或个数不同的方法即使重载1.重载Overload是一个类中多态性的一种表现2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准重写 总结：1.发生在父类与子类之间2.方法名，参数列表，返回类型(除过...
内部类的作用
weixin_34378045的博客
05-08 69
内部类，计算机面向对象程序设计概念。向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。...
内部类的继承问题
Allence的博客
03-04 2648
成员内部类可以继承其他的类，也可以被其它类继承，本文主要说明其它类继承成员内部类的问题。 本文要点如下： 1).成员内部类的子类可以是内部类，也可以不是内部类； 2).当成员内部类的子类不是内部类或子类虽是内部类但与其父类不在同一个外部类时，子类的构造方法第一句要显式添加如下的语句： 外部类对象引用.super(参数); 这里的外部类指父类所在的外部类； 3).编译器默认给成员内部类的构造方法传入一个参数，该参数是内部类所依附...
Java中类的继承和重写
柚子茶的博客
09-18 764
父类 package 面向对象练习扩展; //建立一个汽车Auto类，包括汽车颜色，车身重量、速度等成员变量。 //汽车拥有加速，减速，停车的功能。再定义一个小汽车类Car（子类），继承Auto， //并添加空调、CD成员变量，覆盖加速，减速的方法。 public class Auto { String color; double weight; double speed; public
java炒冷饭系列14 内部类标识符
weixin_36210698的博客
06-21 968
前言由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息产生一个”meta-class”，叫做Class对象），你可能猜到了，内部类也必须生成一个.class文件以包含它们的Class对象信息。这些类文件的命名有严格的规则：外围类的名字，加上“$”,再加上内部类的名字。举列如下面的Out.java文件经过编译后 会得到Out.class Out$Inner1.c
Java之内部类可以被覆盖吗详解（附源码）
mufeng_慕枫学习笔记
08-04 1693
前言        如果创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被覆盖吗？这看起来似乎是个很有用的思想，但是“覆盖”内部类就好像它是外围类的一个方法，其实并不起什么作用： 示例源码1 package com.mufeng.thetenthchapter; class Egg { private Yolk y; publ
java成员内部类的继承和实现
qq_42938846的博客
01-20 1187
  在介绍成员类的继承和实现之前，这里先来介绍一下成员内部类的使用方式和基本规则： 成员内部类基础   成员内部类（member inner class），是最普通的内部类，其可以被priavate、public、protected等访问修饰符修饰但是不可以被static修饰的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有成员属性和方法，尽管是private的，但是外围类要访问...
Java内部类详解：成员与局部内部类解析
"Java内部类相关的知识，包括成员内部类和局部内部类的介绍与使用" Java内部类是Java编程语言中的一个重要特性，允许在另一个类的定义内部定义类。这种设计模式使得代码更加模块化，并且可以实现一些高级功能，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值