java内部类和匿名内部类的区别_百度知道
java内部类和匿名内部类的区别
向大家请教
我有更好的答案
//匿名内部类甚至没有类名,(实际上有).所以匿名内部类,只有一个实例,而且没有引用.如下面那个Thread类的匿名子类,你不能重复使用.内部类,内部类有名字,但是他在类的内部.他能访问外部类的所有数据,包括private的.甚至如果一个内部类,是在一个方法内的话,方法的局部变量,内部类也可以使用.总体来说匿名内部类,和内部类效果差别不大.在事件监听和线程应用中经常使用.//匿名内部类public class T1 { public static void main(String[] args) {
new Thread() {
public void run() {
System.out.println(&runing&);
}.start(); }}//内部嵌套类public class T1 { private static final class Thread1 extends Thread {
public void run() {
System.out.println(&runing&);
} } public static void main(String[] args) {
new Thread1().start(); }}
采纳率：73%
这个和普通内部类一样内部类可以是static的或者非static的，也容易读懂，多次使用所有可以用匿名内部类的地方都可以用内部类替换，但是用匿名内部类编码非常简洁，只能访问外部类的静态元素，内部类可以实例化，static内部类只能包含静态方法和静态类变量。匿名内部类如果是继承某个类的话是可以重写那个类的方法的，必须是类变量或者实例变量，就是必须是类定义的变量，或者final的局部变量匿名内部类只能使用一次，不区分static和非static。如果用到外部类的变量的话
为您推荐：
其他类似问题
您可能关注的内容
java的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(5542)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'java 匿名内部类获取外部类引用',
blogAbstract:'匿名内部类可以直接使用this，但这个this 是指这各匿名内部类本身，而这个this提示出来的方法包含其外部类的所有方法和变量，无论是public 还是 private 。这就出现了虽不在外部类的继承体系中，但任然拥有该体系的方法和变量。如果要获得外部类的引用，可以这样获取：[outerClass].this&&&&& outerClass 为外部类的类名。',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:0,
publishTime:7,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:3,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'0',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}四种内部类详细解释和代码示例_Java教程_动态网站制作指南
四种内部类详细解释和代码示例
来源：人气：723
//成员内部类成员变量 : &&& 成员内部类 : (详情:请看成员内部类文件夹,有代码示例)&& &&& &//成员内部类&& &&& &//可以用访问控制权限的修饰符修饰,如:ivate 私有的。&& &&&& //public,protected,private,缺省(默认,default)&&&&&&& //在成员内部类的内部可以随意访问外部类的成员方法和成员变量&&&&&&& //不能在成员内部类里面声明静态方法和静态变量&&&&&&& //先编译一个外部类的类文件然后摘编译一个内部类的类文件&&&&&&& //内部类的类名:_01_OuterClass$InnerClass&&&&&&&&&&& 可以等同看做成员变量,可以随意访问外部类的任意变量和任意方法,并且,不能在成员内部类中声明静态变量和静态方法
　　/*&&& 变量:&&&&&&& 成员变量 -- 普通内部类&&&&&&& 静态变量 -- 静态内部类&&&&&&& 局部变量 -- 局部内部类&&&&&&& //形参变量&&&&&&& 实参变量 -- 匿名内部类&&& 变量声明:&&&&&&& 数据类型& 变量名& 赋值&&&&&&& 类&&&&&&& String s1; String.---&String.class--&String&&&&&&& String.java&& &关于成员内部类&& &&& &&& &1.成员内部类可以等同看做成员变量&& &&& &&& &&& &2.成员内部类中不能有静态声明.&& &&& &&& &&& &3.成员内部类可以访问外部类所有的数据.*/public class _01_OuterClass{&& &&& &//静态变量&& &private static String s1 = "A";&& &&& &//成员变量&& &private String s2 = "B";&& &&& &//静态方法&& &private static void m1(){&& &&& &System.out.println("static's m1 method execute!");&& &}&& &&& &//成员方法&& &private void m2(){&& &&& &System.out.println("m2 method execute!");&& &}&& &&& &//成员内部类&& &//可以用访问控制权限的修饰符修饰。&& &//public,protected,private,缺省&&& //在成员内部类的内部可以随意访问外部类的成员方法和成员变量&&& //不能在成员内部类里面声明静态方法和静态变量&&& //先编译一个外部类的类文件然后摘编译一个内部类的类文件&&& //内部类的类名:_01_OuterClass$InnerClass&&& //成员内部类&& &class InnerClass{&& &&& &&&&&&&& //静态变量&&&&&&& //static int i = 9999;&& &&& &//静态方法&& &&& &//public static void m3(){}&& &&& &&& &&& &//成员方法&& &&& &public void m4(){&& &&& &&& &System.out.println(s1);&& &&& &&& &m1();&& &&& &&& &&& &&& &&& &System.out.println(s2);&& &&& &&& &m2();&& &&& &}&& &}&&& //相当于: InnerClass ...&& &&& &//入口&& &public static void main(String[] args){&& &&& &&& &&& &//创建外部类对象&& &&& &_01_OuterClass oc = new _01_OuterClass();&&&&&&& //怎么访问一个成员内部类&&&&&&& //外部类对象的引用名.new 内部对象&& &&& &&& &&& &InnerClass inner = oc.new InnerClass();&& &&& &&& &&& &inner.m4();&& &}&& &}　　　　　　//静态内部类静态变量 : &&& 静态内部类 : (详情:请看静态内部类文件夹,有代码示例)&& &&& &//静态内部类&& &&& &//可以用访问控制权限的修饰符修饰,如:private 私有的。&& &&&& //public,protected,private,缺省(默认,default)&&&&&&& //内部可以声明静态变量和成员变量,静态方法和成员方法&&&&&&& //可以访问外部的静态变量和静态方法,不能直接访问成员变量和成员方法(需要有对象引用)&&&&&&& //成员内部类和静态内部类命名没区别&&&&&&&&&&& 可以等同看做静态变量,可以访问外部类的静态变量和静态方法,但是不能直接访问外部类的成员变量和成员方法(要有对象引用,如同main(),也是静态的,有引用,就什么都能调用),并且,能声明任意变量和任意方法
　　/*&& &关于静态内部类&& &&& &1.静态内部类可以等同看做静态变量&& &&& &&& &&& &内部类重要的作用：可以访问外部类中私有的数据。&& &&& &&& &&& &2.静态内部类可以直接访问外部类的静态数据,无法直接访问成员。*/public class _02_OuterClass{&& &&& &//静态变量&& &private static String s1 = "A";&& &&& &//成员变量&& &private String s2 = "B-------";&& &&& &//静态方法&& &private static void m1(){&& &&& &System.out.println("static's m1 method execute!");&& &}&& &&& &//成员方法&& &private void m2(){&& &&& &System.out.println("m2 method execute!");&& &}&& &&& &//静态内部类&& &//可以用访问控制权限的修饰符修饰。&& &//public,protected,private,缺省&&& //内部可以声明静态变量和成员变量,静态方法和成员方法&&& //可以访问外部的静态变量和静态方法,不能访问成员变量和成员方法&&& //成员内部类和静态内部类命名没区别&& &&&& //静态内部类&& &static class InnerClass{&& &&& &&& &&& &//静态方法&& &&& &public static void m3(){&& &&& &&& &System.out.println(s1);&& &&& &&& &m1();&& &&& &&& &&&&&&&&&&&& //也有外部静态类,性质一样&&&&&&&&&&& //成员变量和成员方法:无法从静态上下文中引用非静态 变量 s2&&&&&&&&&&& _02_OuterClass a = new _02_OuterClass();&& &&& &&& &System.out.println(a.s2+"kkkkkkkkkkkkk");//调用成员属性,有对象引用就行&& &&& &&& &//m2();&& &&& &}&& &&& &&& &&& &//成员方法&& &&& &public void m4(){&& &&& &&& &System.out.println(s1);&& &&& &&& &m1();&& &&& &&& &&& &&& &&& &//System.out.println(s2);&& &&& &&& &//m2();&& &&& &}&& &}&& &&& &&& &//入口&& &public static void main(String[] args){&& &&& &&& &&& &//执行m3&& &&& &_02_OuterClass.InnerClass.m3();&& &&& &&& &&& &//执行m4&& &&& &InnerClass inner = new _02_OuterClass.InnerClass();&& &&& &inner.m4();&& &}&& &}
//局部内部类局部变量(方法中写的类) : &&& 局部内部类 : (详情:请看局部内部类文件夹,有代码示例)&&&&&&&&&&& //局部内部类不能用访问控制权限修饰符修饰。&&&&&&&&&&& //但是能访问外部方法的局部变量,但是局部变量必须用final修饰 , java8以后,可以不写final修饰&&&&&&&&&&& 局部内部类中,不能声明静态变量和静态方法,只能声明成员变量和成员方法&&&&&&&&&&& 1 如果外部方法是静态方法,那内部类中就不能访问外部类的成员变量和成员方法&&&&&&&&&&& 2 如果外部方法是成员方法,那内部类中就能访问外部类的成员变量和成员方法
　　/*&& &局部内部类等同于局部变量&& &&& &重点：局部内部类在访问外部类的局部变量的时候，局部变量必须使用final修饰。&&& 在成员方法中能声明一个局部静态内部类吗?不能&&& 在静态方法中能声明一个局部静态内部类吗? 自己试一下 不能*/public class _03_OuterClass{&& &&&&&&&&& int i1 = 222;&&&&&&& static int i2 = 255;&& &//方法//---------------------------------------成员方法里面的内部类测试-------------------------&& &public& void m1(){//成员方法&& &&& &&& &&& &//局部变量&& &&& &final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰&& &&& &&& &&& &//局部内部类;&& &&& &//局部内部类不能用访问控制权限修饰符修饰。&&&&&&& //局部内部类&& &&& &class InnerClass{&& &&& &&& &&& &&& &&& &//局部内部类不能有静态声明&& &&& &&& &//public static void m1(){}&& &&& &&& &&& &&& &&& &//成员方法&& &&& &&& &public void m2(){&& &&& &&& &&& &System.out.println(i); // 10& 访问局部变量&&&&&&&&&&&&&&& System.out.println( i1 );//访问外类的成员变量&&&&&&&&&&&&&&& System.out.println( i2 );//访问外类的静态变量&& &&& &&& &}&& &&& &&& &&& &&& &&& &}&& &&& &&& &&& &//调用m2&& &&& &InnerClass inner = new InnerClass();&& &&& &inner.m2();&& &&& &&& &}//---------------------------------------静态方法里面的内部类测试-------------------------&&& public static void m11(){//静态方法&&&&&& &&& &//局部变量&& &&& &final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰&& &&& &&& &&& &//局部内部类;&& &&& &//局部内部类不能用访问控制权限修饰符修饰。&&&&&&& //局部内部类&& &&& &class InnerClass{&& &&& &&& &&& &&& &&& &//局部内部类不能有静态声明&& &&& &&& &//public static void m1(){}&& &&& &&& &&& &&& &&& &//成员方法&& &&& &&& &public void m22(){&& &&& &&& &&& &System.out.println(i); // 10& 访问局部变量&&&&&&&&&&&&&& // System.out.println( i1 );//访问外类的成员变量&&&&&&&&&&&&&&& System.out.println( i2 );//访问外类的静态变量&& &&& &&& &}&& &&& &&& &&& &&& &&& &}&& &&& &&& &&& &//调用m2&& &&& &InnerClass inner = new InnerClass();&& &&& &inner.m22();&&& }&& &&& &&& &//入口&& &public static void main(String[] args){&& &&& &_03_OuterClass oc = new _03_OuterClass();&& &&& &oc.m1();&&&&&&& oc.m11();&& &&& &&& &}&& &}
//匿名内部类局部变量(调用方法传参) :&&& 匿名内部类 : (详情:请看匿名内部类文件夹,有代码示例)&&&&&&& /*匿名内部类：指在方法调用时,方法的效用需要传入某个类对应的对象实参&&&&&&& 但是也可以直接new一个某个类型的一个对象,这个对象没有名字&&&&&&& 如果反方定义形参,一般是个接口,那么调用的时候,要用其实现类传入&&&&&&& 但是我可以不实现这个实现类,而是直接new这个接口的对象,也也可以&&&&&&& 相当于:省下了,书写实现类和实例化实现类对象的代码&&&&&&& 也可以这么说,直接实例化了一个类,只不过这个类和接口名相同&&&&&&& */&&& //优点 : 少定义一个雷&&& //缺点 : 只能用一次,无法重复使用&&&&&&& 匿名内部类几个原则 : &&&&&&&&&&& // 1 没有构造方法(因为匿名内部类是没有类名的)&&&&&&&&&&& // 2 不能定义任何变量(静态,成员),不能定义任何方法(静态,成员),不能定义任何类&&&&&&&&&&& // 3 不能使抽象类(因为在创建匿名内部类的时候，会立即创建匿名内部类的对象。从而也可知匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法)&&&&&&&&&&& // 4 匿名内部类不能使public ,protected,private,static&&&&&&&&&&& // 5 只能创建匿名内部类的一个实例&&&&&&&&&&& // 6 匿名类和内部类中的中的this : 有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。&&&&&&&&&&& 匿名内部类能访问外部的静态变量和静态方法,私有的也能,但是不能访问成员变量和成员方法,除非在实现类中,也要用外部类的引用去调用访问&&&&&&&&&& &
/*&& &匿名内部类：指在方法调用时,方法的效用需要传入某个类对应的对象实参&&& 但是也可以直接new一个某个类型的一个对象,这个对象没有名字&&& 如果反方定义形参,一般是个接口,那么调用的时候,要用其实现类传入&&& 但是我可以不实现这个实现类,而是直接new这个接口的对象,也也可以&&& 相当于:省下了,书写实现类和实例化实现类对象的代码&&& 也可以这么说,直接实例化了一个类,只不过这个类和接口名相同*/public class _04_OuterClass{&& &&& &//静态方法&& &public static void t(CustomerService cs){&& &&& &cs.logout();&& &}&& &&& &//入口&& &public static void main(String[] args){&& &&& &&& &&& &//调用t方法&& &&& &//t(new CustomerServiceImpl()); //匿名内部类 2 对应下面的类&& &&& &&& &&& &//使用匿名内部类的方式执行t方法&& &&& &//整个这个"new CustomerService(){}"就是个匿名内部类&& &&& &t(new CustomerService(){//匿名内部类 1 && &&& &&& &public void logout(){&& &&& &&& &&& &System.out.println("exit!");&& &&& &&& &}&& &&& &});&& &&& &&& &&& &//匿名内部类的优点：少定义一个类.&& &&& &//缺点：无法重复使用!&& &}&& &}//接口interface CustomerService{&& &&& &//退出系统&& &public void logout();&& &}//编写一个类实现CustomerService接口/*class CustomerServiceImpl implements CustomerService{ //匿名内部类 2 && &public void logout(){&& &&& &System.out.println("系统已经安全退出！");&& &}}*/
优质网站模板提起java内裤类（innerClass）很多人不太熟悉，实际上类似的概念在c++里面也有，那就是嵌套类（Nested Class），关于这俩者的区别，在下文中会有对比。内部类从表面上看，就是在类中定义了一个类（下文可以看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，他的用处可能对于初学者来说并不是那么显著,但是随着对他的深入了解，你会发现java的设计者在内裤类上面的确是用心良苦。学会使用内部类，是掌握java高级编程的一部分，他可以让你更优雅的设计你的程序结构。下面从以下几个方面来介绍：
第一次见面： &&
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Contents content = good.dest();
System.out.println(content.value());
Destination destination = good.cont("BeiJing");
System.out.println(destination.readLabel());
interface Contents{
int value();
interface Destination{
String readLabel();
class Goods{
private class Content implements Contents{
private int i = 11;
public int value(){
protected class GDestination implements Destination{
private GDestination(String whereTo){
label = whereTo;
public String readLabel(){
public Content dest(){
return new Content();
public GDestination cont(String s){
return new GDestination(s);
在这个例子里，类Content和GDestination被定义在了Goods类内部，并且分别有着private和protected修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。在后面的main（）方法里面，直接用Contents content 和Destination destination进行操作，你甚至连这俩个内部类的名字都没有见过，这样，内部类的好处就体现出来了，隐藏你不想让别人知道的操作，即封装性。
同时，我们也发现了外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中dest()和cont()方法就是这么做的。那么，还有没有别的方法呢？当然有，其语法格式如下：
OuterClass outerObject = new OuterClass(Constructor parameters);
OuterClass .InnerClass innerObject =&outerObject.new InnerClass(Constructor parameters); & //当然这时候要把内部类的构造行数改为public,不能是private了
注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们的下一个话题 非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Contents content = good.dest();
System.out.println(content.value());
interface Contents{
int value();
interface Destination{
String readLabel();
class Goods{
private int valueRate = 2;
private class Content implements Contents{
private int i = 11 * valueR
public int value(){
protected class GDestination implements Destination{
public GDestination(String whereTo){
label = whereTo;
public String readLabel(){
public Content dest(){
return new Content();
public GDestination cont(String s){
return new GDestination(s);
在这里我们给Goods添加了一个新的private 成员变量 valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把他乘上。我们发现，value（）可以访问valueRate,这也是内部类的第二个好处，一个内部类对象可以访问创建他的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路跟捷径。要想实现这个功能，内部类对象必须有指向外部类对象的引用。
java编译器在创建内部类对象时，隐式的把其他外部类的对象也传了进来并一直保存着。这样就使得内部类的对象始终可以访问其外部类的对象。同时这也是为什么在外部类作用范围之外想要创建内部类对象必须创建起外部类对象的原因。
有人会问，如果一个外部类的成员变量与内部类的成员变量同名，也即外部类的成员变量被屏蔽了，怎么办？没事，java里面有如下格式表达外部类的引用：
outerClass.this
有了它，我们就不怕这种屏蔽的情况了。
静态内部类
和普通类一样，内部类也可以由静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部类的引用。这实际上和c++中的嵌套类很相像了。java内部类与c++嵌套类最大的不同就是在于是否有指向外部类引用这一点上，当然从设计的细节及其他的一些角度来讲还有一些区别。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不只一层）。不过静态内部类中可以拥有者一切。这也算俩者的第二个区别吧。
局部内部类：
是的，java内部类可以定义在一个方法里面甚至一个代码块之内。
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Destination destination = good.dest("beijing");
System.out.println(destination.readLabel());
interface Destination{
String readLabel();
class Goods{
public Destination dest(String s){
class GDestination implements Destination{
public GDestination(String whereTo){
label = whereTo;
public String readLabel(){
return new GDestination(s);
上面就是这样一个例子。在方法dest（）中我们定义了一个内部类，最后由这个方法返回这个内部类。如果我们在创建一个对象的时候仅需要创建一个对象并且创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。
下面有一个更怪的例子：
public class TestInnerClass{
private void into(boolean b){
class GDestination {
public GDestination(String whereTo){
label = whereTo;
public String readLabel(){
GDestination destination = new GDestination("beijing");
System.out.println(destination.readLabel());
public void dest(boolean b){
public static void main(String args[]){
TestInnerClass inner = new TestInnerClass();
inner.dest(true);
你不能再if()语句之外创建这个内部类的对象，应为这已经超出了他的作用域。不过在编译的时候，内部类GDestination和其他类一样同时被编译，不过他有他自己的作用域。超出了这个范围就无效，除此之外和其他的内部类并没有区别。
匿名内部类
java的匿名内部类看上去有些古怪，不过如同匿名数组一样，单你只需要创建一个类的对象而用不上他的名字的时候，使用内部类看上去可以使代码更简洁清楚。他的语法规则是这样的：
new interfaceName(){...................};或：new superClassName(){................................};
下面接着前面继续举例子：
public class TestInnerClass{
public Contents cont(){
return new Contents(){
private int i = 11;
public int value(){
public static void main (String args[]){
TestInnerClass test = new TestInnerClass();
Contents content = test.cont();
System.out.println(content.value());
interface Contents{
public int value();
这里的cont()使用匿名内部类直接返回了一个实现了接口Contents的类对象，看上去的确十分简洁。
在java的事件处理机制的匿名适配器中，匿名内部类被大量使用。例如在关闭窗口时附加上这样一段代码：
frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
有一点需要注意的是，匿名内部类由于没有名字，所以他没有构造函数（但是如果这个匿名内部类继承了一个只含有带参构造函数的父类，创建他的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想初始化他的成员变量，有下面几种方法：
如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须声明为final 。
将匿名内部类改造成有名字的局部内部类，这样他就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类？
java内部类有什么好处？为什么需要内部类？
首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以创建一个内部类实现这个接口。由于内部类对于外部类的所有内容都是可以访问的，所以这样做可以完成你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法不就可以了吗？
的确，以此作为设计内部类的理由，没有说服力。
真正的原因是这样的，java中的内部类和接口加在一起，可以解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上，c++的多继承设计起来很复杂，而java通过内部类+接口，可以很好的实现多继承的效果。
阅读(...) 评论()