Java静态内部类和非内部类的区别

本文详细介绍了Java中的内部类概念,包括静态嵌套类、非静态嵌套类的不同类型及其使用场景,并通过具体示例展示了如何在类内部及方法内部定义内部类。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 一. 什么是嵌套类及内部类?
可以在一个类的内部定义另一个类, 这种类称为嵌套类(nested classes),它有两种类型:
静态嵌套类和非静态嵌套类.静态嵌套类使用很少, 最重要的是非静态嵌套类, 也即是被称作为
内部类(inner).嵌套类从JDK1.1开始引入.其中inner类又可分为三种:
(1) 在一个类(外部类)中直接定义的内部类;
(2) 在一个方法(外部类的方法)中定义的内部类;
(3) 匿名内部类.
下面, 我将说明这几种嵌套类的使用及注意事项.

二. 静态嵌套类
如下所示代码为定义一个静态嵌套类

            
package inner; /** * @author: Joho Woo * @email: kongbowoo@163.com * @version: 1.0 * @time: 2007-11-12 下午07:52:29 * @description: */ public class StaticTest {    private static String name = "woobo";    private String num = "X001";    static class Person    {      private String address = "China";      public String mail = "kongbowoo@yahoo.com.cn";//内部类公有成员      public void display()      {        //System.out.println(num);//不能直接访问外部类的非静态成员        System.out.println(name);//只能直接访问外部类的静态成员        System.out.println("Inner " + address);//访问本内部类成员。      }    }    public void printInfo()    {      Person person = new Person();      person.display();      //System.out.println(mail);//不可访问      //System.out.println(address);//不可访问      System.out.println(person.address);//可以访问内部类的私有成员      System.out.println(person.mail);//可以访问内部类的公有成员    }    public static void main(String[] args)    {      StaticTest staticTest = new StaticTest();      staticTest.printInfo();    } }

在静态嵌套类内部, 不能访问外部类的非静态成员, 这是由Java语法中"静态方法不能直接访问非静态成员"所限定.若想访问外部类的变量, 必须通过其它方法解决, 由于这个原因, 静态嵌套类使用很少.注意, 外部类访问内部类的的成员有些特别, 不能直接访问, 但可以通过内部类实例来访问, 这是因为静态嵌套内的所有成员和方法默认为静态的了.同时注意, 内部静态类Person只在类StaticTest 范围内可见, 若在其它类中引用或初始化, 均是错误的.

三. 在外部类中定义内部类
如下所示代码为在外部类中定义两个内部类及它们的调用关系:

            
class Outer {    int outer_x = 100;    private class InnerOne    {      // 私有的内部类      public int inner_y = 10;      private int inner_z = 9;      int inner_m = 5;      public void display()      {        System.out.println("display outer_x:" + outer_x);      }      private void display2()      {        System.out.println("display outer_x:" + outer_x);      }    }    public InnerOne getInnerOne()    {      // 即使是对外公开的方法,外部类也无法调用      return new InnerOne();    }       class InnerTwo    {      InnerOne innerx = getInnerOne();// 可以访问      public void show()      {        // System.out.println(inner_y); // 不可访问Innter的y成员        // System.out.println(Inner.inner_y);   // 不可直接访问Inner的任何成员和方法        innerx.display();// 可以访问        innerx.display2();// 可以访问        System.out.println(innerx.inner_y);// 可以访问        System.out.println(innerx.inner_z);// 可以访问        System.out.println(innerx.inner_m);// 可以访问      }    }       void test()    {      InnerOne inner = new InnerOne();// 可以访问      inner.display();      inner.display2();      // System.out.println("Inner y:" + inner_y); // 不能访问内部内变量      System.out.println("Inner y:" + inner.inner_y);// 可以访问      System.out.println("Inner z:" + inner.inner_z);// 可以访问      System.out.println("Inner m:" + inner.inner_m);// 可以访问           InnerTwo innerTwo = new InnerTwo();      innerTwo.show();    } } public class Test {    public static void main(String args[])    {      Outer outer = new Outer();      // Outer.Inner a=outer.getInner();      // Inner类是私有的,外部类不能访问, 如果Inner类是public ,则可以.      outer.test();    } }


内部类Inner及InnterTwo只在类Outer的作用域内是可知的, 如果类Outer外的任何代码尝试初始化类Inner或使用它, 编译就不会通过.同时, 内部类的变量成员只在内部内内部可见, 若外部类或同层次的内部类需要访问, 需采用示例程序
中的方法, 不可直接访问内部类的变量.

四. 在方法中定义内部类
如下所示代码为在方法内部定义一个内部类:

            
package inner; /** * @author: Joho Woo * @email: kongbowoo@163.com * @version: 1.0 * @time: 2007-11-12 下午08:25:33 * @description: */ public class FunOuter {    int out_x = 100;    public void test()    {      class Inner      {        String inner_x = "x";        void display()        {          System.out.println(out_x);        }      }      Inner inner = new Inner();      inner.display();    }    public void showStr(String str)    {      // public String str1 = "test Inner";      // 不可定义, 只允许final修饰      // static String str4 = "static Str";      // 不可定义, 只允许final修饰      String str2 = "test Inner";      final String str3 = "final Str";      class InnerTwo      {        public void testPrint()        {          System.out.println(out_x);          // 可直接访问外部类的变量          // System.out.println(str); // 不可访问本方法内部的非final变量          // System.out.println(str2); // 不可访问本方法内部的非final变量          System.out.println(str3); // 只可访问本方法的final型变量成员        }      }      InnerTwo innerTwo = new InnerTwo();      innerTwo.testPrint();    }    public void use()    {      // Inner innerObj = new Inner();//此时Inner己不可见了      // System.out.println(Inner.x);//此时Inner己不可见了    }    public static void main(String[] args)    {      FunOuter outer = new FunOuter();      outer.test();    } }


从上面的例程我们可以看出定义在方法内部的内部类的可见性更小, 它只在方法内部
可见, 在外部类(及外部类的其它方法中)中都不可见了.同时, 它有一个特点, 就是方法内的内部类连本方法的成员变量都不可访问, 它只能访问本方法的final型成员.同时另一个需引起注意的是方法内部定义成员, 只允许final修饰或不加修饰符, 其它像static等均不可用.

五. 匿名内部类
如下所示代码为定义一个匿名内部类:匿名内部类通常用在Java的事件处理上

            
package inner; /** * @author: Joho Woo * @email: kongbowoo@163.com * @version: 1.0 * @time: 2007-11-12 下午09:01:05 * @description: */ import java.applet.*; import java.awt.event.*; public class AnonymousInnerClassDemo extends Applet {    public void init()    {      addMouseListener(new MouseAdapter()      {        public void mousePressed(MouseEvent me)        {          showStatus("Mouse Pressed!");        }      });    }    public void showStatus(String str)    {      System.out.println(str);    } }

在上面的例子中, 方法addMouseListener接受一个对象型的参数表达式, 于是, 在参数里, 我们定义了一个匿名内部类,这个类是一个MouseAdapter类型的类, 同时在这个类中定义了一个继承的方法mousePressed, 整个类做为一个参数.这个类没有名称, 但是当执行这个表达式时它被自动实例化.同时因为, 这个匿名内部类是定义在AnonymousInnerClassDemo
类内部的, 所以它可以访问它的方法showStatus.这同前面的内部类是一致的.

六. 内部类使用的其它的问题
通过以上, 我们可以清楚地看出内部类的一些使用方法, 同时, 在许多时候, 内部类是在如Java的事件处理. 或做为值对象来使用的.同时, 我们需注意最后一个问题, 那就是, 内部类同其它类一样被定义, 同样它也可以继承外部其它包的类和实现外部其它地方的接口.同样它也可以继承同一层次的其它的内部类,甚至可以继承外部类本身.下面我们给出最后一个例子做为结束:

            
public class Layer {    // Layer类的成员变量    private String testStr = "testStr";    // Person类, 基类    class Person    {      String name;      Email email;      public void setName(String nameStr)      {        this.name = nameStr;      }      public String getName()      {        return this.name;      }      public void setEmail(Email emailObj)      {        this.email = emailObj;      }      public String getEmail()      {        return this.email.getMailStr();      }      // 内部类的内部类, 多层内部类      class Email      {        String mailID;        String mailNetAddress;        Email(String mailId, String mailNetAddress)        {          this.mailID = mailId;          this.mailNetAddress = mailNetAddress;        }        String getMailStr()        {          return this.mailID + "@" + this.mailNetAddress;        }      }    }    // 另一个内部类继承外部类本身    class ChildLayer extends Layer    {      void print()      {        System.out.println(super.testStr);// 访问父类的成员变量      }    }    // 另个内部类继承内部类Person    class OfficePerson extends Person    {      void show()      {        System.out.println(name);        System.out.println(getEmail());      }    }    // 外部类的测试方法    public void testFunction()    {      // 测试第一个内部类      ChildLayer childLayer = new ChildLayer();      childLayer.print(); // 测试第二个内部类      OfficePerson officePerson = new OfficePerson();      officePerson.setName("abner chai");      // 注意此处, 必须用对象.new 出来对象的子类对象      // 而不是Person.new Email(...)      // 也不是new Person.Email(...)      officePerson          .setEmail(officePerson.new Email("josserchai", "yahoo.com"));      officePerson.show();    }    public static void main(String[] args)    {      Layer layer = new Layer();      layer.testFunction();    } }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值