向匿名内部类传递参数的例子，大神们看下会不会有什么问题【java吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：726,056贴子：
向匿名内部类传递参数的例子，大神们看下会不会有什么问题收藏
new Thread((new Runnable(){private Spublic void run(){System.out.println(s)；}public Runnable init(String s){this.s=s;}}).init(&Test&)).start()；
init不需要return了，直接void就行
登录百度帐号博客分类：
在很多时候，我们需要在类的内部初始化一个静态的Map或者List，然后保存一下常量值提供给类内部方法使用。
我们通常的做法是：
首先初始化一个Map的静态变量。
然后在静态块添加常量值：
private final static Map&String, String& CONSTANT =
new HashMap&String, String&();
CONSTANT.put("1", "one");
CONSTANT.put("2", "two");
其实还可以这么写：
private final static Map&String, String& CONSTANT =
new HashMap&String, String&() {
put("1", "one");
put("2", "two");
如果对于这种方式比较陌生，那先看一个熟悉的：
new Thread() {
public void run() {
System.out.println("Thread running!");
}.start();
实际上上面这段代码的意思就是，声明一个Thread的子类并重写Thread的run()方法，然后创建一个该子类的实例然后调用其start()方法。由于声明的该Thread的子类没有名字，所以叫匿名类。又由于没有名字的类只能存在于一个类或者一个方法内部，所以又称为匿名内部类。
匿名内部类的语法也可以这么写：
Thread thread = new Thread() {
public void run() {
System.out.println("Thread running!");
thread.start();
唯一的区别就是不是直接创建子类并调用其方法，而是声明一个该子类的父类引用thread，然后通过该父类引用调用子类方法。
创建完匿名类的实例后，没有立即执行start()，创建实例和执行实例的方法分开。
两者的区别相当于：
new User().setName("Boyce Zhang");
User user = new User();
user.setName("Boyce Zhang");
匿名内部类的另一个语法场景：
new Thread() {
public void run() {
System.out.println("Thread running!");
实际上这种写法就是在匿名子类的类局部代码块中调用其类方法。
局部代码块内的语句是在创建该类的实例后由类加载器隐式立即执行的。
相当于：
public class MyThread extends Thread {
public void run() {
System.out.println("Thread running!");
所以三种方式在执行的时刻上略微的差别之外，效果并没有太大的区别。
这样一来，前面初始化Map的方式就不难理解了:
private final static Map&String, String& CONSTANT = new HashMap&String, String&() {
put("1", "one");
put("2", "two");
原理就是：
声明并实例化一个HashMap的子类（子类没有重写父类HashMap的任何方法），并且在子类的类局部代码块调用父类HashMap的put()方法。
最后声明一个Map接口引用CONSTANT指向实例化的HashMap子类的实例。
根据前面的例子我们知道，类局部代码块中的put()方法调用将在HashMap的匿名子类被实例化后由类加载器隐式的执行。
其实,对于Java的任何类或接口，都可以声明一个匿名类继承或实现它。如：
//重写父类方法，局部代码块调用自己重写过的父类方法。
List&String& list = new ArrayList&String&() {
public boolean add(String e) {
System.out.println("Cannot add anything!");
//代码块的顺序在前后都无所谓，可以出现在类范围的任何位置。
add("Boyce Zhang");
//局部代码块调用父类方法。
dao.add(new User(){
setName("Boyce Zhang");
setAge(26);
//重写父类方法
ThreadLocal&User& threadLocal = new ThreadLocal&User&() {
protected String initialValue() {
return new User("Boyce Zhang", 26);
在匿名类的内部我们不但可以实现或重写其父类的方法。
而且也可以在其类的局部代码块中执行自己的方法或者其父类的方法。
这并不是匿名内部类的特殊语法，而是Java的语法，对于任何类都适用。
这种写法常常就是用在实例化一个类后立即执行某些方法做一些类实例的数据初始化什么的。
其作用和先实例化一个类，在使用其引用调用需要立即调用的方法是一样的，如：
Map&String, String& map = new HashMap&String, String&();
map.put("1", "one");
map.put("2", "two");
这种语法的优点就是简单，实例化一个类后立即做一些事情，比较方便。
效果有一点儿像Javascript里的即时函数一样。但是有本质的区别。
因为Javascript没有类的概念，或者说Javascript中function就是类，类就是function，所以即时函数是加载完后执行整个function。而Java的局部代码块是可以选择执行类的任何方法。
当然这种写法也有其缺点：
每一个内部类的实例都会隐性的持有一个指向外部类的引用（静态内部类除外），这样一方面是多余的引用浪费，另一方面当串行化这个子类实例时外部类也会被不知不觉的串行化，如果外部类没有实现serialize接口时，就会报错。
浏览 18881
另一方面当串行化这个子类实例时外部类也会被不知不觉的串行化，如果外部类没有实现serialize接口时，就会报错。这个是怎么回事？博主有例子吗
该用户名已经存在
浏览: 242219 次
来自: 上海
哪有时间给你去研究!!!大神 你时间多
引用另一方面当串行化这个子类实例时外部类也会被不知不觉的串行化 ...
不过受教了 ，不过稍稍修改 还是很好用的 。顶
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'请教java的参数式匿名内部类_百度知道
请教java的参数式匿名内部类
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
来自电脑网络类芝麻团
采纳数：189
获赞数：508
参与团队：
匿名内部类&&&&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匿名对象与匿名内部类
&更新时间：日 14:45:06 & 作者：彬菌
本篇文章给大家详细讲解了Java匿名对象与匿名内部类的相关知识点，有兴趣的读者一起学习下。
匿名对象：没有名字的对象。
非匿名对象：
ClassName c=new ClassName();
匿名对象：
new ClassName().run();
注意事项：
1、当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
2、两个匿名对象不可能是同一个对象。
3、一般不给匿名对象赋予属性值，因为永远无法获取到。
4、运行一次，直接就被回收掉了，节省内存空间。
匿名对象使用的代码例子：
public class Anony{
void run(){
System.out.println(a+b);
public static void main(String[] args){
new Anony().a=10; //匿名对象不能重新赋值，赋值仍然失效
Anony a=new Anony();
a.run(); //通过创建对象的方式去调用方法
new Anony().run(); //匿名创建对象并调用方法
运行结果：
匿名内部类：匿名内部类也就是没有名字的内部类。
ClassName object=new ClassName(){
/*代码块*/
注意事项：
1、匿名内部类必须继承一个父类或实现一个接口。
抽象类代码例子：（接口同理）
abstract class AnonyTest{
public abstract void run();
public class AnonyInner{
public static void main(String[] args){
AnonyTest a=new AnonyTest(){ //抽象匿名类
public void run() {
System.out.println(a+b);
如果不使用匿名内部类来实现抽象方法：
abstract class AnonyTest{
public abstract void run();
class AnonyDemo extends AnonyTest{
public void run() {
System.out.println(a+b);
public class AnonyInner{
public static void main(String[] args) {
AnonyTest a=new AnonyDemo(); //上转对象
运行结果：
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具15:07 提问
关于java中匿名内部类的问题
不是说抽象类不能实例化么？为啥这里它又实例化了？？
疑惑是代码中有个 person p=new person（）
按赞数排序
定义匿名内部类的格式：
new 父类构造器（参数列表）|实现接口（）
//匿名内部类的类体部分
new Person(){
//类体部分
也相当于如下代码，但是不等于，匿名内部类没有类名，无法定义构造器，但可以定义实例初始化块，通过实例初始化块来完成构造器需要完成的事情
class 子类 extends Person {
//实现父类抽象方法
而Person p 是声明一个引用变量，用于指向内部类，不是实例化；因为匿名内部类适合创建只需要使用一次的类，所以不需要新建一个子类继承父类。
（仅是小白的见解，有错见谅）
new Person()这里是一个匿名的类，这个类实现了抽象方法，所以这个匿名类是Person的子类，从而父类引用指向子类对象。
这里就存在了多态。
个人理解，有错望指正！
这不是在创建对象的时候重写了方法么
定义匿名内部类的方法是new 父类构造方法{
//重写父类中的方法
你这个其实就是创建了一个新的匿名类去继承了Person类，然后将匿名类对象向上转型为Person类。
Person p =new Person();
是不一样的，要注意区分一下，可以看通过有没有实现父类的抽象方法来判定，因为一般的类在平时是不会这样去重写父类的方法
准确详细的回答，更有利于被提问者采纳，从而获得C币。复制、灌水、广告等回答会被删除，是时候展现真正的技术了！
其他相关推荐
今天也不准备记录太多的东西，就想把一个关于匿名内部类的一个面试题分享一下。
题目如下：
按照要求，补齐代码
interface Inter {
void show();
class Outer {
//补齐代码
class OuterDemo {
public static void main(String[] args) {
答案 ：内部类之所以能获取到外部类的成员，是因为它能获取到外部类的引用，即外部类名.this
1.概述：把类定义在其他类的内部，这个类就称为内部类。
如：类B定义在类C中，B就是C的内部类。
//B为类A的内部类
2.访问特点：
（1）内部类可以直接访问外部类的成员，包括私有成员；
（2）外部类访问内部类成员，必须创建对象，通过对象访问。
//B为类A的内
Object是java中已有的一个所有类的父类----也称为根类，你可以把它理解为java中的上帝。java中的类都是直接或者间接继承自object类。该类的出现：是封装了所有对象都具备的方法。
interface Inter
void method();
}class Test
//补足代码。通过匿名内部类。}
class InnerClassTest
public static void main(String[] args)
Test.function().method();
//答案：①
在java提高篇-----详解内部类中对匿名内部类做了一个简单的介绍，但是内部类还存在很多其他细节问题，所以就衍生出这篇博客。在这篇博客中你可以了解到匿名内部类的使用、匿名内部类要注意的事项、如何初始化匿名内部类、匿名内部类使用的形参为何要为final。
一、使用匿名内部类内部类
匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：
主要讲述了JAVA中内部类和匿名内部类的相关问题。
参考文章：
java中的匿名内部类总结
Java中匿名类的两种实现方式
一、什么是匿名内部类
1：匿名内部类
匿名内部类也就是没有名字的内部类。
2：匿名内部类的作用
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
3：匿名内部类的实现
匿名内部类的两种实现方式：第一种，继承一个类，重写其方法；第二种，实现一个接口（可以是多个），实现其方法。
匿名内部类是在单一表达式内定义的嵌套类。因为这些类没有名称和构造函数，所以称为匿名类。它们只能访问最终方法变量和参数。
class Inner
public static void main(String[] args)
Bank b = new Bank();
System.out.println(b.getCustomer().getName());
&——————test1
AsyncTaskvoid,
void=&&&() {
protected Void doInBackground(Void... params) {
SystemClock.sleep(10000);