匿名内部类java内部类和匿名内部类的区别

内部类和匿名内部类的用法

简单的说就是在一个类中，定义一个新的类， class base{ void run(){ System.out.println("i am runing..........."); } class inner{ void draw (){ System.out.println("i am drawing.............."); } } }

匿名内部类，内部类，静态内部类的区别和联系

Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。

内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。

1、静态内部类定义 静态内部类，定义在类中，任何方法外，用static定义；静态内部类只能访问外部类的静态成员。

生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。

静态内部类的对象可以直接生成：Outer.Inner in=new Outer.Inner()；而不需要通过生成外部类对象来生成。

这样实际上使静态内部类成为了一个顶级类。

可以定义私有静态内部类。

2、java实现静态内部类注意事项 将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。

不过其细节方面仍然有很大的不同。

具体来说，主要有如下几个地方要引起注意。

1）一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。

也就是说，在非静态内部类中不可以声明静态成员 2）一般非静态外部类可以随意访问其外部类的成员变量以及方法（包括声明为private的方法），但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。

静态内部类不能访问其外部类的非静态成员变量和方法 3）在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。

然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。

即在创建静态类内部对象时，不需要其外部类的对象 3、静态内部类示例 java在实现LinkedList时使用了如下内部类： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { ........ private static class Entry<E> { E element; Entry<E> next; Entry<E> previous; Entry(E element, Entry<E> next, Entry<E> previous) { this.element = element; this.next = next; this.previous = previous; } } private Entry<E> addBefore(E e, Entry<E> entry) { Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); newEntry.previous.next = newEntry; newEntry.next.previous = newEntry; size++; modCount++; return newEntry; } ........ } 这里即静态内部类的典型用法

匿名内部类是什么？

匿名内部类可以减少你命名一个类的烦脑(^^) 其有很多优点 比如可以访问外部类的私有方法 new YourClass{ ... } 这个例子是一个多线程的小程序，这里面就应用到了匿名内部类，实现了Runnable接口。

匿名内部类的一般好处是：是代码更加简洁，紧凑，但带来的是易读性下降。

他一般用在GUI编程中 实现事件处理等等。

希望大家一起讨论 public class RunnableTest{ public static void main(String[] args){ MyThread1 mt1 = new MyThread1(); MyThread2 mt2 = new MyThread2(); MyThread3 mt3 = new MyThread3(); mt2.th.start(); mt1.th.start(); mt3.th.start(); } } class MyThread1 implements Runnable{ Thread th = new Thread(this); public void run(){ for (int i = 0; i < 10; i++){ System.out.println("BMW" + i); } } } class MyThread2{ Thread th = new Thread(){ public void run(){ for (int i = 0; i < 10; i++){ System.out.println(i); } } }; } class MyThread3{ Runnable ra = new Runnable(){ public void run(){ for (char ch = 65; ch < 70; ch++){ System.out.println(ch); } } }; Thread th = new Thread(ra); } 匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到 实现方式： SuperType aa = new SuperType(construction parameters){methods and data} 或 InterfaceType aa = new InterfaceType(){methods and data} 具体实现时需要把SuperType 和InterfaceType 换成具体的超类和接口。

匿名内部类可以访问外部类的私有成员，其他的方式实现接口和继承类做不到 内部类应该都可以的。

我觉得匿名的应该是隐藏实现，而且用完就out的那种。

成员内部类，匿名内部类是什么东西？

成员内部类就是在一个类中定义的类，就可以作为这个类的成员了，匿名内部类，也是，不过它是没有确切名字的。

定义的时候是某个类的子类。

比如： object obj=new object(){ public void print1() { System.out.println("Hello world!!"); } }；，这里就有一个匿名内部类，没有名字，继承自object

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(); } }