本文目录
- java内部类和匿名内部类的区别是什么
- java匿名内部类具体概念是什么，在什么地方用到
- java 匿名内部类 如何实现 举例说明
- java匿名内部类
- JAVA中的匿名内部类
- java 匿名内部类
- Java匿名内部类
- Java匿名内部类怎样创建有何作用和优点创建线程怎样使用匿名内部类
- Java匿名内部类怎样创建，有何作用和优点，创建线程怎样使用匿名内部类
- 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();
}
}
java匿名内部类具体概念是什么，在什么地方用到
java匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
示例如下：
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println(“Outer.i“+i);//静态内部类只能访问外部类的静态成员
outer_f1();//包括静态变量和静态方法
}
void inner_f2(){
// System.out.println(“Outer.i“+j);//静态内部类不能访问外部类的非静态成员
// outer_f2();//包括非静态变量和非静态方法
}
}
public void outer_f3(){
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String args) {
new Outer().outer_f3();
}
}
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匿名内部类
这个类其实并没有实现两个接口的方法
匿名内部类的作用是灵活实现某个接口的方法解除依赖，你的Demo 类 implement 了 dianran,pool 两个接口，dr() 和 rs() 就是 Demo的成员方法 main 方法同级的 ；
Demo不需要实现两个接口就可以在实现两个方法如下：
interface dianran {
abstract void dr();
}
interface pool{
abstract void rs();
}
public class Demo {
public static void main(String args){
new dianran(){
@Override
public void dr() {
System.out.println(“方法 dr“);
}
}.dr();
new pool(){
@Override
public void rs() {
System.out.println(“方法 rs“);
}
}.rs();
}
}
JAVA中的匿名内部类
选B，C
A；匿名类与其说一个类，不如说他是一个表达式，因为写匿名类是在一个表达式里面写的，所以要注意写完一个匿名类后要在结尾写一个“：”
D；new Boo(String s){};这里的内部类虽然继承了Boo，但是这里实例化的类与Bar一点关系都没有（虽然他们都继承了Boo类，就像三角形和四边形继承自形状，你能说三角形是四边形吗）
E；匿名类不像普通的内部类，不要向E一样要Boo.Bar(String s){}; 这样写，这样写没有任何意义
new Bar(){} 和new Bar()的区别在于，第一个相当于继承了Bar类然后实例化Bar的子类对象（也就是说第一个是之类对象），后一个就是Bar对象
匿名类就是一个没有名字的，把继承类与实例化子类对象压缩在一个表达式里面
Boo(String s){}， Boo(){}这是统一各位类中的两个构造方法，没有什么关系，都是用来初始化对象的，一个是有参数的，一个是没有参数的，在实例化对象时，只能选择其中一个
java 匿名内部类
匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new 《类或接口》 《类的主体》 这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。它还创建那个类的一个新实例，并把它作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数，后跟匿名类的主体。如果匿名类对另一个类进行扩展，它的主体可以访问类的成员、覆盖它的方法等等，这和其他任何标准的类都是一样的。如果匿名类实现了一个接口，它的主体必须实现接口的方法。
java 代码
interface pr
{
void print1();
}
public class noNameClass
{
public pr dest()
{
return new pr(){
public void print1()
{
System.out.println(“Hello world!!“);
}
};
}
public static void main(String args)
{
noNameClass c=new noNameClass();
pr hw=c.dest();
hw.print1();
}
}
pr也可以是一个类但是你外部调用的方法必须在你的这个类或接口中声明外部不能调用匿名类内部的方法
Java中内部匿名类用的最多的地方也许就是在Frame中加入Listner了吧。
如下：
java 代码
import java.awt.*;
import java.awt.event.*;
public class QFrame extends Frame {
public QFrame() {
this.setTitle(\“my application\“);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
内部匿名类，就是建立一个内部的类，但没有给你命名，也就是没有引用实例的变量。
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
}
new 是建立一个 WindowAdapter对象 ，后面一个 {} 表示这个括号中的操作作用于这个默认的对名象，而上面的Java程序中后面是一个函数体。
这个用法的作用是：创建一个对象的实例，并且 override 它的一个函数。打开 WindowAdapter 的代码可以发现。它是一个抽象类。它是对 WindowListener 接口的一个实现。Frame.addWindowListner(); 的参数是一个 WindowListner ，而实现上是传一个从WindowAdapter 派生出的一个匿名类。
1.怎样判断一个匿名类的存在啊？看不见名字，感觉只是父类new出一个对象而已，没有匿名类的名字。
先看段伪代码
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() ;
}
2.匿名内部类的注意事项
注意匿名类的声明是在编译时进行的，实例化在运行时进行。这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、方法和类。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
·内部类只能访问外部类的静态变量或静态方法。
匿名类和内部类中的中的this :
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名
3.匿名内部类的作用
Java的内部类和C++中的嵌套类有本质的不同：C++的嵌套类没有指向包装类的句柄。仅仅表达一个封装的概念；但是Java的内部类不同，它可以访问包装类的成员（这表示它拥有指向包装类的句柄）。
匿名内部类是内部类的一种简化写法：return new Wrapper {
...
};
等价于：Wrapped extends Wrapper {
...
}
return new Wrapped();
难道匿名内部类就只这一点作用吗？
考虑一下这样的case:
interface ICount {
int count();
}
class Parent {
int i = 0;
int count() {
return i++;
}
}
有一个类Child，它既想继承Parent的count()方法，又想实现ICount接口中的count方法，这个时候怎么办呢？内部类就可以大显身手了：
class Child extends Parent {
ICount getCount() {
return new ICount {
int i = 0;
int count() {
return (i *= 2);
}
}
}
}
至于你说的只有一个方法或者必须有返回值，这个倒是没有在语法上规定 ， 所以应该不存在这一说法。
Java匿名内部类
创建一个匿名类对象作为wrapping方法的返回值，同时重写了匿名类的value方法。
return的作用是结束当前方法(C语言里叫函数)，看清楚return所在的方法。
要调用该方法才会执行里面的代码。
静态main方法是程序入口点。
Java匿名内部类怎样创建有何作用和优点创建线程怎样使用匿名内部类
1、匿名内部类就是没有名字的内部类。这是Java为了方便我们编写程序而设计的一个机制。因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适，而且也免去了给它取名字的烦恼。
2、如果满足下面的一些条件，使用匿名内部类是比较合适的：
·只用到类的一个实例。
·类在定义后马上用到。
·类非常小（SUN推荐是在4行代码以下）
·给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、方法和类。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
3、用匿名内部类创建多线程有两种方式，和创建一个线程是一样的。
第①种继承Thread：
new Thread(){
public void run(){
//do something
};
}.start();
第②种实现 Runnable接口：
new Thread(new Runnable() {
public void run() {
//do something
};
}) { }.start();
Java匿名内部类怎样创建，有何作用和优点，创建线程怎样使用匿名内部类
1、匿名内部类就是没有名字的内部类。这是Java为了方便我们编写程序而设计的一个机制。因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适，而且也免去了给它取名字的烦恼。
2、如果满足下面的一些条件，使用匿名内部类是比较合适的：
·只用到类的一个实例。
·类在定义后马上用到。
·类非常小（SUN推荐是在4行代码以下）
·给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、方法和类。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
3、用匿名内部类创建多线程有两种方式，和创建一个线程是一样的。
第①种继承Thread：
new
Thread(){
public
void
run(){
//do
something
};
}.start();
第②种实现
Runnable接口：
new
Thread(new
Runnable()
{
public
void
run()
{
//do
something
};
})
{
}.start();
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。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
