java 内部类，匿名内部类

最新推荐文章于 2024-03-20 09:29:04 发布

木鱼-

最新推荐文章于 2024-03-20 09:29:04 发布

阅读量438

点赞数

分类专栏： java

java 专栏收录该内容

191 篇文章 2 订阅

订阅专栏

java 内部类分为4种：

1）静态内部类：static修饰的类叫做静态类，把静态类放到一个类的内部，就叫做静态内部类

特点：可以访问外界：静态方法/静态属性，不能访问实例资源

案例：

import inner.Foo.Koo;//一定要把Koo静态内部类导入进来

public class Demo9 {

public static void main(String[] args) {

Koo koo = new Koo();

koo.add();

}

}

class Foo{

int a = 12;//实例变量

static int aa=16;

public static void show(){ System.out.println("静态的方法");}

//静态内部类

static class Koo{

public void add(){

// System.out.println(a); 静态内部类不能访问实例资源（变量）

System.out.println(aa);

show();//静态内部类可以访问外界的静态属性和方法

}

}

}

2）成员内部类：在一个类的内部，直接定义了一个不用static修饰的类，当创建成员内部类对象的时候，外部类要先创建出来。

特点：成员内部类，可以访问外界的属性和方法

案例：

import inner.Foo1.Koo1;

public class Demo10 {

public static void main(String[] args) {

//Koo1 koo1 = new Koo1();要创建成员内部类，则必须要先创建外部类对象

Foo1 foo1 = new Foo1();

//记住（笔试会考）

Koo1 koo1 = foo1.new Koo1();

koo1.show();

}

}

class Foo1{

int a =12;

static int aa = 16;

class Koo1{

void show(){

System.out.println(a+" , "+aa);

}

}

}

3）局部内部类：使用非常的少，特点在一个方法内定义一个类（企业开发中及其少用）

特点：局部内部类，在引用外界的变量，该变量必须要使用final修饰

案例：

public class Demo11 {

public static void main(String[] args) {

final int a = 12;

final int b = 13;

class Foo2{

int c = 16;

public int add(){

//在局部内部类中，引用外界的变量，则变量必须用final修饰

return a+b+c;

}

}

Foo2 foo2 = new Foo2();

System.out.println(foo2.add());

}

}

4）匿名内部类:对原来的类的一个继承

特点:跟接口/抽象类结合使用

eg new 类名/接口名 {

重写方法

};

案例：

public class Demo1 {

public static void main(String[] args) {

Koo koo = new Koo(){

// 可以重写方法

   public String toString() {

    return "生成了一个Koo的对象";

   }

// 在匿名内部类里面不可以创建新的方法

//   public void show(){

//    System.out.println("liu");

//   }

};

System.out.println(koo);

// koo.show();

}

}

class Koo{

}

黑色幽默Lion
方向比努力重要,能力比知识重要,情商比智商重要!

    首页
    新闻
    新随笔
    管理

随笔- 43 文章- 0 评论- 28
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);
        }
      }
    }
}

看这段代码
public static void main(String[] args) {

theApp = new Analyzer();
SwingUtilities.invokeLater(new Runnable() { // Anonymous Runnable class
     // object
     public void run() { // Run method executed in thread
      theApp.creatGUI(); // Call static GUI creator
     }
    });
}

public static void main(String[] args) {

    theApp = new Analyzer(); // 创建一个对象
     SwingUtilities.invokeLater(new Runnable() { // Anonymous Runnable class

      // 一个匿名内部类，他实现了一个线程
       // 原本这个方法是传一个Runnable类型变参数
       // 这里可以通过这种匿名类的方式来实现

       // object
      public void run() { // Run method executed in thread
      theApp.creatGUI(); // Call static GUI creator
}
});
}