甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
Inner classes(内隐类)
创新互联自2013年创立以来，先为桃江等服务建站，桃江等地企业，进行企业商务咨询服务。为桃江企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。
inner class得以让你控制“某个class在另一个class中的可视性”。
位于methods和scopes之内的inner classes(内隐类)
你可以将inner classes置于函数之内或甚至置于任意程序范畴(scope)之内。
以下应用:
1. 定义与函数之内的class。
2. 定义于函数内某一段范畴(scope)内的class。
3. 一个匿名(anonymous)class,实现某个interface。
4. 一个匿名class,扩充某个“拥有non-default构造函数”之class。
5. 一个匿名class,执行数据成员初始化动作。
6. 一个匿名class,以实体(instance)初始化来执行构造动作。注意,匿名的inner classes不得拥有构造函数。
匿名(anonymous)inner class
当base class需要一个带有引数的构造函数时,只要将适当引数传入base class构造函数种。
如果你定义了某个匿名inner class,并且希望用到定义于匿名inner class之外的某个对象,编译器会限制该外部对象必须为final。
同时通过实体初始化(instance initialization)你可以实际完成一个匿名inner class的建构。
与外围(outer)class的连接关系
inner class天生具有对enclosing class之所有成员的访问权力。
static inner class(静态内隐类)
如果你不需要inner class对象和enclosing class对象之间的连接关系,你可以将inner class声明为static。如果你想了解这么声明的确切时机,记住,一般的inner class(也就是non-static inner class)会自动记录一个reference指向enclosing class的某个实例,而后者也就是此inner class对象的制造者。但是一旦你将inner class声明为static,上述说法就不成立。static inner class意味着:
1. 产生对象时,并不需要同时存在一个enclosing class实例。
2. 你无法在static inner class对象中访问enclosing实例成员。
一般而言,你不能将任何程序代码置于interface内,但static inner class却可以使interface的一部分。这是因为class既然被声明为static,也就不会破坏interface的规则—static inner class只不过是被置于interface的命名空间中罢了。
取用(referring)outer class的实例
在你需要产生一个reference指向outer class对象时,命名方式便是在outer class名称之后紧接一个句号,然后再接this。
如果你想直接产生inner class对象,你不能像你所想象地在new表达式中使用outer class的名称,你必须使用outer class的实例来产生inner class对象。如:
Parcell1 p = new Parcell1();
Parcell1.Contents c = p.new Contents();
因此,除非你已经拥有一个outer class对象,否则便无法产生其inner class对象。这是因为inner class对象会被暗中连接到某个outer class对象上,后者即该inner class对象的制造者。不过,如果你制作的是static inner class,那就不需要一个reference指向outer class对象了。
从多层嵌套class向外伸展触角
无论inner class被嵌套置放的层次有多深,其所有outer classes的成员都可以被它访问。
继承inner classes
由于inner class的构造函数必须连接到一个reference指向outer class对象身上,所以当你继承inner class时,事情便稍微复杂些。问题出在“指向outer class对象”的那个神秘的reference必须被初始化,但derived class之内不存有可连接的缺省对象。这个问题的答案是,使用专用语法,明确产生关联性:
class WithInner{
class Inner{}
}
public class IneritInner extends WithInner.Inner{
//!InheritInner(){} //Won’t compile
InheritInner (WithInner wi)
{
wi.super();
}
}
InheritInner继承的是inner class而非outer class。但是当编译至构造函数时,default构造函数有问题;而且你也不能够只是传入一个reference指向outer object,你还必须在构造函数中使用以下语法:
enclosingClassReference.super();
inner classes可被覆写么吗?
我们能否把inner class视为outer class的一个函数一样,覆写inner class呢?
不能的。
Inner classes的标识符
先是outer class名称,其后紧接“$”符号,然后再紧接inner class名称。如果inner class没有名称,编译器会自动产生数字,做为inner class的标识符。如果inner classes被嵌套置于其他inner classes之内,其名称就会直接附加于“$”符号与outer class标识符(可能多个)之后。
为什么需要inner classes?
关于inner classes的存在,最让人信服的理由是:
每个inner class都能够各自继承某一实现类(implementation)。因此,inner class不受限于outer class是否已继承自某一实现类。
如果少了inner class所提供的“继承自多个具象(concrete)或抽象(abstract)类”的能力,设计上和编程上的某些问题会变得十分棘手。所以,从某个角度来看inner class,你可以说它是多重继承问题的完整解决方案。interface能够解决其中一部分问题,但inner classes才能有效而实际地允许“多重实现继承(multiple implementation)”。也就是说,inner classes实际上允许你继承多个non-interface。
通过inner classes,你可以拥有下列几个额外性质:
1. inner class可以拥有多份实体(instances),每个实体都拥有专属的状态信息(state information),而这些信息和outer class对象的信息是相互独立的。
2. 在单一outer class内你可以拥有多个innner classes,每个都实现相同的interface,或以不同方式继承同一个class。
3. 产生inner class对象的时间点,不见得必须和产生outer class对象同时。
4. outer class和inner class之间不存在is-a的关系,inner class是独立个体。
Closures(终结)和Callbacks(回调)
所谓closure是一种可被调用的对象,它会记录一些信息,这些信息来自它的产生地所在的程序范畴(scope)。
让inner class提供closure功能,是完美的解决方案。比起指针来说,不仅更具有弹性,而且安全许多。
callback的价值在于其弹性—你可以在执行时期动态决定究竟要调用哪个函数。
Inner classes和control frameworks
所谓application framework,是一组“被设计用来解决特定某种问题”的classes。如果你想套用某个application framework,你得继承一个或多个classes,并覆写其中某些函数。通过被覆写的函数内的新版程序代码,便可将application framework所提供的通用解法特殊化,针对性地解决你的特定问题。
所谓control framework,其实就是一种特殊形式的application framework,用来解决“事件(events)回应”的需要。一个系统如果主要工作在于回应诸般事件,我们称为“事件驱动系统(event-driven-system)”。
Java Swing程序库便是一个control framework,优雅解决了GUI问题,并大量采用inner classes。
abstract class Animal {
public abstract void cry();
}
class TestCry {
public void testCry(Animal animal) {
animal.cry();
}
}
public class Example{
public static void main(String[] args) {
TestCry cry = new TestCry () ;
cry.testCry(new Animal (){
public void cry() {
System.out.println("Cat is crying!");
}
});
cry.testCry(new Animal (){
public void cry() {
System.out.println("Dog is crying!");
}
});
// ... 省略其他
}
}
先看段伪代码
abstract class Father(){
....
}
public class Test{
Father f1 = new Father(){ .... } //这里就是有个匿名内部类
}
一般来说，new 一个对象时小括号后应该是分号，也就是new出对象该语句就结束了。
但是出现匿名内部类就不一样，小括号后跟的是大括号，大括号中是该new 出对象的具体的实现方法。
因为我们知道，一个抽象类是不能直接new 的，必须先有实现类了我们才能new出它的实现类。
上面的伪代码就是表示new 的是Father的实现类，这个实现类是个匿名内部类。
其实拆分上面的匿名内部类可为
class SonOne extends Father{
... //这里的代码和上面匿名内部类，大括号中的代码是一样的
}
public class Test{
Father f1 = new SonOne() ;
}
分类: 电脑/网络 程序设计 其他编程语言
问题描述:
内部类的使用有什么优点，什么情况下应考虑使用它呢？
匿名类使用有什么优点，什么情况下应考虑使用它呢？
解析:
提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：
第一次见面
public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}
在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作，也即封装性。
同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：
outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题——
非静态内部类对象有着指向其外部类对象的引用
对刚才的例子稍作修改：
public class Goods {
private valueRate=2;
private class Content implements Contents {
private int i = 11*valueRate;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
修改的部分用蓝色显示了。在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：
outerClass.this
有了它，我们就不怕这种屏蔽的情况了。
静态内部类
和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
局部内部类
是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
public class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() { return label; }
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods1 g= new Goods1();
Destination d = g.dest("Beijing");
}
}
上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。
下面有一个更怪的例子：
public class Goods2{
private void internalTracking(boolean b) {
if(b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() { return id; }
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() { internalTracking(true); }
public static void main(String[] args) {
Goods2 g= new Goods2();
g.track();
}
}
你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。
匿名内部类
java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：
new interfacename(){......}; 或 new superclassname(){......};
下面接着前面继续举例子：
public class Goods3 {
public Contents cont(){
return new Contents(){
private int i = 11;
public int value() {
return i;
}
};
}
}
这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。
在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：
frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：
如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类？
java内部类有什么好处？为什么需要内部类？
首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法的不就行了吗？
的确，以此作为设计内部类的理由，实在没有说服力。
真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。
本文的目的只是向大家介绍一下内部类的概念以及使用方法，在后续文章里，将会针对本文中的内容举更多具体的例子，以及介绍如何使用内部类构建一个Applicaton Framework。
匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new 类或接口 类的主体 这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。它还创建那个类的一个新实例，并把它作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数，后跟匿名类的主体。如果匿名类对另一个类进行扩展，它的主体可以访问类的成员、覆盖它的方法等等，这和其他任何标准的类都是一样的。如果匿名类实现了一个接口，它的主体必须实现接口的方法。
java 代码
interface pr
{
void print1();
}
public class noNameClass
{
public pr dest()
{
return new pr(){
public void print1()
{
System.out.println("Hello world!!");
}
};
}
public static void main(String args[])
{
noNameClass c=new noNameClass();
pr hw=c.dest();
hw.print1();
}
}
pr也可以是一个类但是你外部调用的方法必须在你的这个类或接口中声明外部不能调用匿名类内部的方法
Java中内部匿名类用的最多的地方也许就是在Frame中加入Listner了吧。
如下：
java 代码
import java.awt.*;
import java.awt.event.*;
public class QFrame extends Frame {
public QFrame() {
this.setTitle(\"my application\");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
内部匿名类，就是建立一个内部的类，但没有给你命名，也就是没有引用实例的变量。
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
}
new 是建立一个 WindowAdapter对象 ，后面一个 {} 表示这个括号中的操作作用于这个默认的对名象，而上面的Java程序中后面是一个函数体。
这个用法的作用是：创建一个对象的实例，并且 override 它的一个函数。打开 WindowAdapter 的代码可以发现。它是一个抽象类。它是对 WindowListener 接口的一个实现。Frame.addWindowListner(); 的参数是一个 WindowListner ，而实现上是传一个从WindowAdapter 派生出的一个匿名类。
1.怎样判断一个匿名类的存在啊？看不见名字，感觉只是父类new出一个对象而已，没有匿名类的名字。
先看段伪代码
abstract class Father(){
....
}
public class Test{
Father f1 = new Father(){ .... } //这里就是有个匿名内部类
}
一般来说，new 一个对象时小括号后应该是分号，也就是new出对象该语句就结束了。
但是出现匿名内部类就不一样，小括号后跟的是大括号，大括号中是该new 出对象的具体的实现方法。
因为我们知道，一个抽象类是不能直接new 的，必须先有实现类了我们才能new出它的实现类。
上面的伪代码就是表示new 的是Father的实现类，这个实现类是个匿名内部类。
其实拆分上面的匿名内部类可为
class SonOne extends Father{
... //这里的代码和上面匿名内部类，大括号中的代码是一样的
}
public class Test{
Father f1 = new SonOne() ;
}
2.匿名内部类的注意事项
注意匿名类的声明是在编译时进行的，实例化在运行时进行。这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、方法和类。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
·内部类只能访问外部类的静态变量或静态方法。
匿名类和内部类中的中的this :
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名
3.匿名内部类的作用
Java的内部类和C++中的嵌套类有本质的不同：C++的嵌套类没有指向包装类的句柄。仅仅表达一个封装的概念；但是Java的内部类不同，它可以访问包装类的成员（这表示它拥有指向包装类的句柄）。
匿名内部类是内部类的一种简化写法：return new Wrapper {
...
};
等价于：Wrapped extends Wrapper {
...
}
return new Wrapped();
难道匿名内部类就只这一点作用吗？
考虑一下这样的case:
interface ICount {
int count();
}
class Parent {
int i = 0;
int count() {
return i++;
}
}
有一个类Child，它既想继承Parent的count()方法，又想实现ICount接口中的count方法，这个时候怎么办呢？内部类就可以大显身手了：
class Child extends Parent {
ICount getCount() {
return new ICount {
int i = 0;
int count() {
return (i *= 2);
}
}
}
}
至于你说的只有一个方法或者必须有返回值，这个倒是没有在语法上规定 ， 所以应该不存在这一说法。