JAVA认证：java的内部类与匿名内部类

会计考友 · 发表于 2012-8-4 12:44:44

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”）;
}

}

会计考友 · 发表于 2012-8-4 12:44:45

</p>在这个例子里类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（）;

}

会计考友 · 发表于 2012-8-4 12:44:46

</p>}
public void track（） { internalTracking（true）; }
public static void main（String［］ args） {
Goods2 g= new Goods2（）;
g.track（）;
}
}
你不能在if之外建树这个内部类的对象，因为这已经超出了它的浸染域。不外在编译的时辰，内部类TrackingSlip和其他类一样同时被编译，只不外它由它自己的浸染域，超出了这个规模就无效，除此之外它和其他内部类并没有区别。
匿名内部类
java的匿名内部类的语犯罪则看上去有些怪僻，不外如同匿名数组一样，当你只需要建树一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去精练清嚣张。它的语犯罪则是这样的：
// 有点js中 return function（）{。..。..};的意思
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经由过程内部类加上接口，可以很好的实现多担任的效不美观。

会计考友 · 发表于 2012-8-4 12:44:47

</p>

若何优化？
知道了在那儿那里优化，但若何进行优化呢？我们知道大部门的运算时刻被花在了绘图函数上，J2ME已经为我们供给了这些函数，我们没有法子对这些函数的内部进行优化，可是我们仍然有选择权。下面我们来对J2ME供给给我们的绘图函数作一测试。
在Canvas类里添加测试代码如下：
protected void paint（Graphics g） {
TestPaint（g）;
}
void TestPaint（Graphics g） {
setClip（g）;
setColor（g）;
m_font = getFont（）;
setFont（g）;
drawString（g）;
drawRect（g）;
fillRect（g）;
drawImage（g）;
drawRegion（g）;
drawArc（g）;
drawChar（g）;
drawLine（g）;
drawRoundRect（g）;
fillArc（g）;
fillRoundRect（g）;
}
void setColor（Graphics g） {
g.setColor（0）;
}
void drawArc（Graphics g） {
g.drawArc（0， 0， 100， 100， 4， 4）;
}
void drawChar（Graphics g） {
g.drawChar（‘你’， 0， 0， GE.TOPLEFT）;
}
void drawRoundRect（Graphics g） {
g.drawRoundRect（0， 0， 100， 100， 4， 4）;
}
void fillRoundRect（Graphics g） {
g.fillRoundRect（0， 0， 100， 100， 4， 4）;
}
void fillArc（Graphics g） {
g.fillArc（0， 0， 100， 100， 4， 4）;
}
void drawLine（Graphics g） {
g.drawLine（0， 0， 100， 100）;
}
Font getFont（） {
return Font.getFont（Font.FACE_SYSTEM， Font.STYLE_PLAIN， Font.SIZE_SMALL）;
}

void setFont（Graphics g） {
g.setFont（m_font）;
}
void drawString（Graphics g） {
g.drawString（“你好”， 0， 0， GE.TOPLEFT）;
}
void drawRect（Graphics g） {
g.drawRect（0， 0， 100， 100）;
}
void setClip（Graphics g） {
g.setClip（0， 0， 300， 300）;
}
void fillRect（Graphics g） {
g.fillRect（100， 0， 100， 100）;
}
void drawImage（Graphics g） {
g.drawImage（GE.m_images［GRes.PNG_MAP］， 0， 100， GE.TOPLEFT）;
}
void drawRegion（Graphics g） {
g.drawRegion（GE.m_images［GRes.PNG_MAP］， 0， 0， 100， 100， Sprite.TRANS_MIRROR，100， 100， GE.TOPLEFT）;

}

会计考友 · 发表于 2012-8-4 12:44:48

</p>该轨范各函数分袂绘制100*100的图形，经由一段侍旧笋后，退出应用轨范
按照Profiler窗口所显示的数据，我们发现drawString最耗时。其次是drawRegion，所以我们应尽量避免使用drawString函数。
经由过程Profiler对各类函数及轨范的测试，我总结如下结论：
◆仅当你需要的时辰才去优化代码！
◆仅优化那些最耗时的代码！
◆使用Profiler去查找哪里需要优化！
◆记住Profiler不代表真机上的优化结不美观，使用System Timer来在真机上做最后的测试！
◆在做初级优化之前，老是要先思虑算法是否是最优！
◆绘图是很占用时刻的，所以尽可能的削减Graphics函数的挪用！
◆尽可能的使用SetClip（）来削减绘图区域，相对于SetClip（），drawImage（）所花的时刻会更可不美观！
◆尽可能的将变量界耸ё仝轮回以外！
◆尽最大可能的进行对需要的数据进行预先计较并将结不美观保留在缓冲里！
◆String类很轻易发生垃圾内存，尽可能的使用StringBuffer庖代String或用final static来界说之！
◆假设是不被接管的，一切要以真机为据！
◆尽量使用static final润色函数，而避免synchronized润色符！
◆对于频仍挪用的函数要使用尽可能少的参数！
◆尽可能的不使用函数挪用！
◆尽可能的使用《《和》》来庖代*和/！
◆使用位操作来庖代%运算！
◆与0斗劲比与其他数值斗劲快！
◆数组存取比C说话慢，尽可能不在轮回中存取数组！
◆局部变量比其他类型的变量运算要快！
◆在switch（）中尽量使用持续的小数值判定

		自动登录	找回密码
密码			立即注册

[专业语言] JAVA认证：java的内部类与匿名内部类