展开全部
匿名类是一种特殊的内部类，它是在一个表达式内部包含一个完整的32313133353236313431303231363533e58685e5aeb931333337616531类定义。
内部类是在一个类的内部嵌套定义的类，它可以是其它类的成员，也可以在一个语句块的内部定义，还可以在表达式内部匿名定义。
匿名类与其他类的不同就在于匿名，也就是没有名称。
Java中允许创建子类对象时，除了使用父类的构造方法外，还可以用类体。 匿名类就是一个没有类申明的类体，因为没有名称，所有匿名类不可以申明对象，但却可以创建对象。   例如：
A是一个子类，那么下面的代码就是A的一个子类(匿名类)创建对象。
new A(){
匿名类的类体
};
由于匿名类是一个子类，所以和有一般子类的特征。可以继承父类的方法，同样也可以重写父类的方法。值得提醒的是，在使用匿名类时，一定是在某个类中直接用匿名类创建对象，因此匿名类必定是内部类，所以和其他匿名类一样可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以什么。
static成员变量和static方法。
尽管匿名类没有申明的步骤，但可以在创建匿名对象时返回一个引用赋值给匹配参数。   匿名类的常用方式是向方法的参数传值。
具体方法如下：abstract class Speak{
public abstract void speakHello();
}
class Student{
void f(Speak sp){
sp.speakHello();
}
}
public class AnonymousClassDemo {
public static void main(String[] args) {
Speak speak = new Speak(){
public void speakHello(){
System.out.println("大家好，祝工作愉快!");
}
};
speak.speakHello();
Student st = new Student();
st.f(new Speak(){
public void speakHello(){
System.out.println("I am a student, how are you");
}
});
}
}
上面代码的抽象类改成接口同样适用。

java匿名内部类
什么是匿名内部类？
匿名内部类的使用场景？
匿名内部类如何创建？
匿名内部类的实现和使用
例1(实现接口)
例2(继承类)

什么是匿名内部类？
匿名内部类，顾名思义，就是不知道这个类到底是什么名字，也就是不知道类名。
匿名内部类的使用场景？
匿名内部类适合创建那种只需要使用一次的类，也就是说创建一个匿名内部类，只需要用一次即可。
匿名内部类如何创建？
new 类名(参数) | 实现接口()
{
// 匿名内部类的类体部分
}
从上面的定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或者实现一个接口。
两个规则：
	匿名内部类不能是抽象类。
	匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。

匿名内部类的实现和使用
例1(实现接口)
首先，定义一个匿名类要实现的接口，代码如下
public interface Product{
 double getPrice();
 double getName();

然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的接口对象，到时候会传入一个匿名类对象，这个匿名类实现了上述创建的接口，代码如下
public class Anony{
	public void test(Product product){
	System.out.println("购买了一个"+product.getName()+"，花掉了"+product.getPrice());
	}
}

最后测试运行：
pubic class Test{
	public static void main(String[] args){
		Anony anony=new anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Product(){
			@Override
			public double getPrice(){
					return 578.6;
				}
			@Override
			public String getName(){
					return "联想笔记本";
				}
			}
		);
	}
}

输出：
购买了一个联想笔记本，花掉了578.6

总结：此处匿名内部类的作用就是实现了一个接口，创建了一个实现了该接口的类的对象，然后重写了这个接口中的方法。
例2(继承类)
首先，定义一个匿名类需要实现的抽象类，代码如下：
public abstract class Device{
	private String name;
	public abstract double  getPrice();
	public String getName(){
	 	return name;
	}
	public Device(){}
	public Device(String name){
		this.name=name;
	}
} 

然后，定义一个实体类，实体类定义一个方法，方法的参数为上述的抽象类对象，到时候会传入一个匿名类对象，这个匿名类继承了上述创建的抽象类，代码如下
public class Device{
	public void test(Device device){
		System.out.println("购买了一个"+device.getName()+"花费了"+device.getPrice());
	}
}


最后测试运行：
pubic class Test{
	public static void main(String[] args){
		Anony anony=new anony();
		// 注意，此处要传入一个匿名类对象
		anony.test(new Device("海尔电视机"){
			@Override
			public double getPrice(){
					return 578.6;
				}
		);
		Device device=new Device(){
			@Override
			public double getPrice(){
				return 556.56;
			}
			@Override
			public String getName(){
				return "美的电视机";
			}
		};
		annoy.test(device);
	}
}

输出：
购买了一个海尔电视机，花掉了578.6
购买了一个美的电视机，花掉了556.56

总结：对象匿名类中继承抽象类，对于抽象类里面的抽象方法，必须要重写，对象抽象类里面的非抽象方法，可重写也可以不重写。

Java基础之匿名内部类，匿名内部类是什么?为什么要用匿名内部类，匿名内部类详解。
什么是匿名内部类？
顾名思义 匿名 就是没有名字，一个没有名字的内部类，称为匿名内部类。

下面先看一个例子，比如说你想和你的女朋友去看春节档的《唐人街探案三》
这个时候我们要先定义一个接口，去看唐探3的接口
public interface MyInterface {
    // 看电影的抽象方法
    void watchFilm();
}

OK！现在我们有了一个接口，接口里面有一个看电影的抽象方法。而现在你要去看电影了，你要实现接口里面的方法，但是接口不能直接 new 出来，所以你就要先定义一个实现类去实现这个接口，代码如下：
public class MyInterfaceImpl implements MyInterface{

    public void watchFilm() {
        System.out.println("实现方法里带着女朋友去看电影！");
    }
}

现在我们实现了这个接口，也可以去看电影了，我们现在要写一个主方法；
public class GoWatchFilm {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.watchFilm();
    }
}

而这个时候，我们要先 new 一个看电影的实现类，然后调用里面看电影的方法，如图：



现在你和你心爱的女朋友成功的看到了电影…

因为我们已经知道多态，我们还可以使用多态的方式，" = " 的左边时接口，右边是实现类也是没毛病的，



到这里！那么问题来了，这个电影你就看了一次，只有在 new 的时候才看了一次，没有再看第二次。所以这个时候我们就可以使用 匿名内部类 了。
如果接口的实现类（或者父类的子类）只需要使用唯一一次，那么这种情况下我们就可以省略掉对该类的定义，而改为使用匿名内部类。
匿名内部类的定义格式：

上面我们有说到接口不能直接 new ,如果直接new就会报错，而这次，我们就直接new接口，但是这里的new和new对象又有一点小差别，格式如下：
接口名称 对象名 = new 接口名称(){
	 // 覆盖重写所有抽象方法
}

那我们就代码实现一下：



如上图，我们new了一个接口，而接口下面的 { } 里面就是一个匿名内部类，所以现在我们使用匿名内部类就可以带着女朋友把电影看玩了，而之前我们定义的一个实现类就可以不用了，虽然说这样写法有点怪异，但是我们是想带着女朋友看电影，并且这个电影只需要看一次就行了，往后就不看了，却还要写一个实现类去实现它，使用匿名内部类就可以省掉一个类的单独定义，看到这想必小伙伴已经对匿名内部类了解的差不多了，不过匿名内部类也有一些注意事项，我们接着往下看。
匿名内部类的注意事项:
首先对格式 “new 接口名称 () {…}” 进行解析:
1.new 代表创建对象的动作；
2.接口名称就是匿名内部类需要实现哪个接口；
3. {…} 这才是匿名内部类的内容；  PS：没有class，没有名称
另外还要注意以下几点问题：

如果现在你的女朋友还想要看完电影去吃个海底捞，那么我们现在在接口里再写一个方法。并且第二天的时候你美丽的女朋友还要重复昨天做的事情，看电影，吃火锅，开始撸代码：
public interface MyInterface {
    // 看电影的抽象方法
    void watchFilm();
    // 吃海底捞的抽象方法
    void eatHotPot();
}

public class GoWatchFilm {
    public static void main(String[] args) {
       /* MyInterface myInterface = new MyInterfaceImpl();
        myInterface.watchFilm();*/
        MyInterface day01 = new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第一天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第一天看完电影我们去吃一个火锅吧！！！！");
            }
        };
        day01.watchFilm();
        day01.eatHotPot();
        // 来一条分割线
        System.out.println("-------------------------------------------------------------------------------------------");
        new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第二天看完电影我们去吃一个火锅吧！！！！");
            }
        }.watchFilm();
        new MyInterface() {
            @Override
            public void watchFilm() {
                System.out.println("第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！");
            }
            @Override
            public void eatHotPot() {
                System.out.println("第二天看完电影我们去吃一个火锅吧！！！！");
            }
        }.eatHotPot();

    }
}

输出内容：
第一天在匿名内部类里面实现了带女朋友看电影了！！！！！！
第一天看完电影我们去吃一个火锅吧！！！！
-------------------------------------------------------------------------------------------
第二天在匿名内部类里面实现了带女朋友看电影了！！！！！！
第二天看完电影我们去吃一个火锅吧！！！！

可以看到，当我们第一天的时候，看完电影再吃火锅时是用的匿名内部类，是有对象名称的，可以直接用对象名称调用吃火锅和看电影的方法，而当第二天想再次调用的时候如果我们是用到了匿名对象，是直接new接口没有对象名称就要new两次，然后分别调用看电影和吃火锅，并且每次都要重写接口里的所有方法。
1、匿名内部类，在创建对象的时候只能使用一次，如果希望多次创建对象，而且内容一样的话，那么此时我们就要使用单独定义的实现类了。

2、匿名对象，在调用方法的时候，只能调用唯一一次，如果希望同一个对象调用多次方法，就必须给对象起一个名字。

3、匿名内部类是省略了“实现类/子类名称”，但是匿名对象是省略了“对象名称”
到这里小伙伴们差不多已经知道匿名内部类的含义了吧，并且我们什么时候能用到匿名内部类，什么时候要定义一个实现类去实现接口里的方法了吧！！！！

目录

 

匿名类型

匿名类型说明

匿名类示例

匿名方法

匿名方法说明

匿名方法示例

匿名类型

 

匿名类型说明

匿名类型是没有名称的类，这一种方便的方法，可用将一组只读属性封装到单个对象中，而无需首先显式定义一个类型，类型名由编译器生成，并且不能在源代码级使用

也就是，匿名类实际上就是没有类型名称，其他地方与类是一样使用的。

 

匿名类示例

先看一个普通的类，具有三个变量和一个实例化函数，打印输出预先定义好的值

class student
    {
        public int Sub;
        int Age;
        int Cls;
        public student()
        {
            Console.WriteLine("Student A:{0}{1}{2}",Sub,Age,Cls);
        }
    }

在主函数中实例化

static void Main(string[] args)
        {
            student st = new student();
            
        }

运行得到的结果：



那么如果用一个类似的匿名类来写，就是这样

 

 static void Main(string[] args)
        {
            student st = new student();
            var annoystudent = new
            {
                aSub = "DatAnalyse",
                aAge = 12,
                aCls = "Middle 4"
            };
            Console.WriteLine("Data: {0}{1}{2}", annoystudent.aAge, annoystudent.aSub, annoystudent.aCls); 
        }

为方便比较将两个写到一个程序中，全部代码如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace DelegateTest
{
    internal delegate void NumberChanger(int n);
    class student
    {
        public string Sub = "DatAnalyse";
        private int Age = 12;
        private int Cls = 4;
        public student()
        {
            Console.WriteLine("Stand Student A:{0},{1},{2}",Sub,Age,Cls);
            Console.ReadKey();
        }
    }
   
    class Program
    {
        static void Main(string[] args)
        {
            student st = new student();
            var annoystudent = new
            {
                aSub = "DatAnalyse",
                aAge = 12,
                aCls = "Middle 4"
            };
            Console.WriteLine("Annoy Student Data: {0},{1},{2}", annoystudent.aAge, annoystudent.aSub, annoystudent.aCls);
            Console.ReadKey();
        }
    }
   
}


编译运行，可以看到最终的结果与非匿名类是一样的



匿名类不能赋值，它的所有数值都是只读的

 

 

匿名方法

 

匿名方法说明

创建匿名方法实际上是一种将代码块作为委托参数传递的方式，使用这一种方法如果建立新的线程可以减少内存的消耗，匿名方法不声明返回值类型，但是匿名方法的返回值类型必须和委托返回值一样。

 

匿名方法示例

先定义一个普通的函数

 static void TheMulti(int b)
        {
            var num = b * b;
            System.Console.WriteLine("{0}x{1} = {2}", b, b, b * b);

        }

之后定义一个delegate匿名函数的声明，其中参数类型与普通函数的是一致的，这一句我定义到了类的外面，因此增加一个internal声明

 internal delegate void AutoCounter(int n);

                                                                                                                                                                                                          主函数是这样的：

            

AutoCounter ac ; //实例化匿名方法AutoCounter
            ac = TheMulti; //赋予函数名称
            ac(12); //调用
            System.Console.ReadKey();

程序的运行结果与通常调用函数是一致的

                      

 

另外直接声明匿名方法块也是可以的，

ac = delegate (int c)//声明
            {
                var num = c + c;
                System.Console.WriteLine("{0}+{1} = {2}", c, c, (c + c));
            };
            ac(33);//调用

  最终的函数如下：

   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace DelegateTest
{
    internal delegate void AutoCounter(int n);
   
    class Program
    {
        static void Main(string[] args)
        {
            AutoCounter ac ;
            ac = TheMulti;
            ac(12);
            ac = delegate (int c)
            {
                var num = c + c;
                System.Console.WriteLine("{0}+{1} = {2}", c, c, (c + c));
            };
            ac(33);
            System.Console.ReadKey();
        }
        static void TheMulti(int b)
        {
            var num = b * b;
            System.Console.WriteLine("{0}x{1} = {2}", b, b, (b * b));

        }
    } 
   
}


   运行结果