求个JAVA关于匿名类的例子.简单些10来行就可以了.
interface Person { public void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println(＂eat something＂); } }; p.eat(); } }
如何创建C#匿名方法
匿名方法复与委托一起使用，使用方法见以下代码
using System;
class Test
{
// 第一制步：声明委托bai
delegate void TestDelegate(string s);
static void Main(string[] args)
{
// 第二步du：用匿名方法实zhi例化委托
TestDelegate testDel1 = delegate(string s) { Console.WriteLine(s); };
// 第二步：或者用Lambda表达式（也是dao匿名方法）实例化委托
TestDelegate testDel2 = (x) => { Console.WriteLine(x); };
//第三步：调用
testDel1(“Hello. My name is M and I write lines.”);
testDel2(“That’s nothing. I’m anonymous method”);
}
}
java匿名内部类
interface A
{
public void fun1();
}
class B
{
int i = 10;
public void get(A a)// 声明了一个方法get,接受一个类型为A的参数
{
a.fun1();
}
public void test()
{
this.get(new A()//这里就是匿名的内部类,实现了A这个接口的类,只是是匿名的,编译的时候会自动生成一个类名为B$1的类,这一点你可以用cmd手动编译一下,就能看见B$1.class这样一个文件,相当于你有一个B$1的类实现了A这个接口,然后作为get的参数传了进去
{
public void fun1()
{
System.out.println(i);
}
});
}
}
class TestNonameDemo
{
public static void main(String args[])
{
B b = new B();
b.test();
}
}
java 匿名类
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的参数式匿名内部类
匿名内部类
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 匿名内部类 如何实现？ 举例说明
匿名内部类，就是建立一个内部的类，但没有给你命名，也就是没有引用实例的变量。
public void start() {
this.setBounds(50, 50, GAME_WIDTH, GAME_HEIGHT);
this.setBackground(Color.green);
this.setVisible(true);
/*
下面这个就是匿名内部类了
*/
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
this.addKeyListener(new TankKeyEvent());
this.setResizable(false);
new Thread(new TankThread()).start();
}
new 是建立一个 WindowAdapter对象 ，后面一个 {} 表示这个括号中的操作作用于这个默认的对名象，而上面的Java程序中后面是一个函数体。这
个用法的作用是：创建一个对象的实例，并且 override 它的一个函数。打开 WindowAdapter
的代码可以发现。它是一个抽象类。它是对 WindowListener 接口的一个实现。Frame.addWindowListner(); 的参数是一个 WindowListner ，而实现上是传一个从WindowAdapter 派生出的一个匿名类。
java中匿名数组如何创建
通过下面代码定义就是匿名数组 System.out.println(new String[]{＂a＂,＂b＂});//这里创建了一个匿名数组,并打印输出1、匿名数组是一个没有名字的数组 2、匿名数组与普通的数组的语法是一样的,如:`new [] { }`,不同的是创建完数组后不会存储在任何一个变量身上. 3、使用匿名数组的策略仅仅就是创建、初始化、应用,因为它没有任何名字因此你没法重用它.
JAVA的匿名类详细介绍
匿名类顾名思义就是没有名字的类.interface hello{ String start(); } public class ok{ public String hello(){ return new hello(){ //这个个地方就是匿名类 String start(){ return ＂hello world＂; } } } }
java 匿名内部类 的执行顺序和文字表述
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：
[java] view plaincopyprint?
new父类构造器（参数列表）|实现接口（）
{
//匿名内部类的类体部分
}
在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。
[java] view plaincopyprint?
publicabstractclassBird {
privateString name;
publicString getName() {
returnname;
}
publicvoidsetName(String name) {
this.name = name;
}
publicabstractintfly();
}
publicclassTest {
publicvoidtest(Bird bird){
System.out.println(bird.getName() + “能够飞 “+ bird.fly() + “米”);
}
publicstaticvoidmain(String[] args) {
Test test = newTest();
test.test(newBird() {
publicintfly() {
return10000;
}
publicString getName() {
return”大雁”;
}
});
}
}
——————
Output：
大雁能够飞 10000米
在Test类中，test()方法接受一个Bird类型的参数，同时我们知道一个抽象类是没有办法直接new的，我们必须要先有实现类才能new出来它的实现类实例。所以在mian方法中直接使用匿名内部类来创建一个Bird实例。
由于匿名内部类不能是抽象类，所以它必须要实现它的抽象父类或者接口里面所有的抽象方法。
对于这段匿名内部类代码其实是可以拆分为如下形式：
[java] view plaincopyprint?
publicclassWildGoose extendsBird{
publicintfly() {
return10000;
}
publicString getName() {
return”大雁”;
}
}
WildGoose wildGoose = newWildGoose();
test.test(wildGoose);
在这里系统会创建一个继承自Bird类的匿名类的对象，该对象转型为对Bird类型的引用。
对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用。对于上面的实例，如果我们需要对test()方法里面内部类进行多次使用，建议重新定义类，而不是使用匿名内部类。
java的匿名函数怎么用
Java 应用程序按值传递参数(引用类型或基本类型)，其实都是传递他们的一份拷贝.而不是数据本身.(不是像 C++ 中那样对原始值进行操作。)
例1:
Java代码
//在函数中传递基本数据类型，
public class Test {
public static void change(int i, int j) {
int temp = i;
i = j;
j = temp;
}
public static void main(String[] args) {
int a = 3;
int b = 4;
change(a, b);
System.out.println(“a=” + a);
System.out.println(“b=” + b);
}
}
结果为:
a=3
b=4
原因就是 参数中传递的是 基本类型 a 和 b 的拷贝,在函数中交换的也是那份拷贝的值 而不是数据本身;
例2:
Java代码
//传的是引用数据类型
public class Test {
public static void change(int[] counts) {
counts[0] = 6;
System.out.println(counts[0]);
}
public static void main(String[] args) {
int[] count = { 1, 2, 3, 4, 5 };
change(count);
}
}
在方法中 传递引用数据类型int数组，实际上传递的是其引用count的拷贝，他们都指向数组对象，在方法中可以改变数组对象的内容。即:对复制的引用所调用的方法更改的是同一个对象。
