`
ljl_ss
  • 浏览: 54830 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

jav内部类

Blog 
阅读更多
1.  普通内部类
•普通内部类的一个最简单的例子：
view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    // 内部类  
    public class InnerClass {  
        private int i = 0;  
        public int getInt(){  
            return i;  
        }  
    }  
    public void proc(){  
        InnerClass inClass = new InnerClass();  
        System.out.println(inClass.getInt());  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
        outClass.proc();  
    }  
} 
// 外部类
class OutterClass {
    // 内部类
    public class InnerClass {
        private int i = 0;
        public int getInt(){
            return i;
        }
    }
    public void proc(){
        InnerClass inClass = new InnerClass();
        System.out.println(inClass.getInt());
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
        outClass.proc();
    }
}
•外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：
view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    private int mOut = 10;  
    // 内部类  
    public class InnerClass {  
        private int mIn = 0;  
        public void printOutPrivate(){  
            // 直接打印外部类的成员  
            System.out.println(mOut);  
        }  
    }  
    public void printInPrivate(){  
        InnerClass inClass = new InnerClass();  
        // 直接打印内部类的私有成员  
        System.out.println(inClass.mIn);  
    }  
    public void printOutPrivate(){  
        InnerClass inClass = new InnerClass();  
        inClass.printOutPrivate();  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
        outClass.printInPrivate();  
        outClass.printOutPrivate();  
    }  
} 
// 外部类
class OutterClass {
    private int mOut = 10;
    // 内部类
    public class InnerClass {
        private int mIn = 0;
        public void printOutPrivate(){
            // 直接打印外部类的成员
            System.out.println(mOut);
        }
    }
    public void printInPrivate(){
        InnerClass inClass = new InnerClass();
        // 直接打印内部类的私有成员
        System.out.println(inClass.mIn);
    }
    public void printOutPrivate(){
        InnerClass inClass = new InnerClass();
        inClass.printOutPrivate();
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
        outClass.printInPrivate();
        outClass.printOutPrivate();
    }
}
•如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：
view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    private int mMem = 10;  
    // 内部类  
    public class InnerClass {  
        private int mMem = 0;  
        public void printOutPrivate(){  
            // 直接打印外部类的成员  
            System.out.println(OutterClass.this.mMem);  
        }  
    }  
} 
// 外部类
class OutterClass {
    private int mMem = 10;
    // 内部类
    public class InnerClass {
        private int mMem = 0;
        public void printOutPrivate(){
            // 直接打印外部类的成员
            System.out.println(OutterClass.this.mMem);
        }
    }
}
•要创建普通内部类，必须先创建相应的外部类：
view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    private int mMem = 10;  
    // 内部类  
    public class InnerClass {  
        private int mMem = 0;  
        public void printOutPrivate(){  
            // 直接打印外部类的成员  
            System.out.println(OutterClass.this.mMem);  
        }  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
       OutterClass.InnerClass inClass = outClass.new InnerClass();  
        inClass.printOutPrivate();  
    }  
} 
// 外部类
class OutterClass {
    private int mMem = 10;
    // 内部类
    public class InnerClass {
        private int mMem = 0;
        public void printOutPrivate(){
            // 直接打印外部类的成员
            System.out.println(OutterClass.this.mMem);
        }
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
       OutterClass.InnerClass inClass = outClass.new InnerClass();
        inClass.printOutPrivate();
    }
}
也可以用下面的方式：


view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    private int mMem = 10;  
    // 内部类  
    public class InnerClass {  
        private int mMem = 0;  
        public void printOutPrivate(){  
            // 直接打印外部类的成员  
            System.out.println(OutterClass.this.mMem);  
        }  
    }  
    public InnerClass newInnerClass() {  
        return new InnerClass();  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
       OutterClass.InnerClass inClass = outClass.newInnerClass();  
        inClass.printOutPrivate();  
    }  
} 
// 外部类
class OutterClass {
    private int mMem = 10;
    // 内部类
    public class InnerClass {
        private int mMem = 0;
        public void printOutPrivate(){
            // 直接打印外部类的成员
            System.out.println(OutterClass.this.mMem);
        }
    }
    public InnerClass newInnerClass() {
        return new InnerClass();
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
       OutterClass.InnerClass inClass = outClass.newInnerClass();
        inClass.printOutPrivate();
    }
}
2.  静态内部类
普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：
•静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。
•普通内部类不能有静态成员，静态方法，或另一个静态内部类；而静态内部类可以有这一切。
•静态内部类可以直接创建，不必先创建外部类：
view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    private int mMem = 0;  
    // 静态内部类  
    static public class InnerClass {  
        private int mMem = 0;  
        public void printOutPrivate(){  
            // 这是错误的  
            // System.out.println(OutterClass.this.mMem);  
        }  
    }  
    public void printInPrivate() {  
        InnerClass inClass = new InnerClass();  
        // 可以直接访问静态内部类的成员  
        System.out.println(inClass.mMem);  
    }  
}  
public class Main {      
    public static void main(String[] args) {  
        // 直接创建静态内部类  
        OutterClass.InnerClass inClass = new OutterClass.InnerClass();  
        inClass.printOutPrivate();  
    }  
} 
// 外部类
class OutterClass {
    private int mMem = 0;
    // 静态内部类
    static public class InnerClass {
        private int mMem = 0;
        public void printOutPrivate(){
            // 这是错误的
            // System.out.println(OutterClass.this.mMem);
        }
    }
    public void printInPrivate() {
        InnerClass inClass = new InnerClass();
        // 可以直接访问静态内部类的成员
        System.out.println(inClass.mMem);
    }
}
public class Main {   
    public static void main(String[] args) {
        // 直接创建静态内部类
        OutterClass.InnerClass inClass = new OutterClass.InnerClass();
        inClass.printOutPrivate();
    }
}
从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。
3.  局部内部类
Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：

view plaincopy to clipboardprint?
// 外部类  
class OutterClass {  
    public void testLocalInner() {  
        if (true)  
        {  
            class LocalInner {  
                public void proc() {  
                    System.out.println("hello");  
                }  
            }  
            // 可以创建使用  
            LocalInner localInner = new LocalInner();  
            localInner.proc();  
        }  
        // 错误：超出类定义的作用域  
        LocalInner localInner = new LocalInner();  
        localInner.proc();  
    }  
} 
// 外部类
class OutterClass {
    public void testLocalInner() {
        if (true)
        {
            class LocalInner {
                public void proc() {
                    System.out.println("hello");
                }
            }
            // 可以创建使用
            LocalInner localInner = new LocalInner();
            localInner.proc();
        }
        // 错误：超出类定义的作用域
        LocalInner localInner = new LocalInner();
        localInner.proc();
    }
}
局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：

view plaincopy to clipboardprint?
// 接口  
interface Talker {  
    public void Talk();  
}  
   
// 外部类  
class OutterClass {  
    public Talker getTalker() {  
        // 现实该接口的局部内部类  
        class SomeTalker implements Talker {  
            public void Talk() {  
                System.out.println("hello");  
            }  
        }  
        // 创建类实例并作为Talker返回  
        SomeTalker talker = new SomeTalker();  
        return talker;  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
        Talker talker = outClass.getTalker();  
        talker.Talk();  
    }  
} 
// 接口
interface Talker {
    public void Talk();
}

// 外部类
class OutterClass {
    public Talker getTalker() {
        // 现实该接口的局部内部类
        class SomeTalker implements Talker {
            public void Talk() {
                System.out.println("hello");
            }
        }
        // 创建类实例并作为Talker返回
        SomeTalker talker = new SomeTalker();
        return talker;
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
        Talker talker = outClass.getTalker();
        talker.Talk();
    }
}
4.  匿名内部类
匿名内部类的语法如下：

view plaincopy to clipboardprint?
new InterfaceName(){......}; 或 new SuperclassName(){......};  
new InterfaceName(){......}; 或 new SuperclassName(){......}; 

它被认为是InterfaceName的实现者，或是SuperclassName的继承类，匿名内部类没有构建函数，如果SuperclassName有带参数的构造函数，必须在创建匿名内部类时带上这些参数，下面是匿名内部类最常见的使用场合：

view plaincopy to clipboardprint?
// 接口  
interface Talker {  
    public void Talk();  
}  
   
// 外部类  
class OutterClass {  
    public void Talk(Talker talker) {  
        talker.Talk();  
    }  
}  
   
public class Main {      
    public static void main(String[] args) {  
        OutterClass outClass = new OutterClass();  
        // 直接生成一个匿名内部类  
        outClass.Talk(new Talker(){  
            public void Talk() {  
                System.out.println("hello");  
            }  
        });  
    }  
} 
// 接口
interface Talker {
    public void Talk();
}

// 外部类
class OutterClass {
    public void Talk(Talker talker) {
        talker.Talk();
    }
}

public class Main {   
    public static void main(String[] args) {
        OutterClass outClass = new OutterClass();
        // 直接生成一个匿名内部类
        outClass.Talk(new Talker(){
            public void Talk() {
                System.out.println("hello");
            }
        });
    }
}


本文来自CSDN博客：http://blog.csdn.net/linzhengqun/archive/2011/03/24/6275586.aspx
分享到：
| [转]在java中使用mongodb
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java中的内部类应用举例

    ### Java中的内部类应用举例 #### 一、Java内部类概览 在Java编程语言中，内部类（Inner Classes）是一种独特的概念，它允许开发者在类的内部定义另一个类。这种设计模式增强了代码的封装性和模块化，同时也提供了...

    JAV的简易计算机

    - 直接输出结果：根据描述，该计算器能够直接计算输入的表达式并输出结果，这就意味着项目内部实现了一套解析和计算表达式的逻辑。 ### 三、核心代码解析 #### 3.1 类定义与继承 ```java public class Expression ...

    java中的内部类内部接口详解

    文章目录简介内部类静态内部类非静态内部类静态方法内部类非静态方法的内部类匿名类内部接口总结 简介 一般来说，我们创建类和接口的时候都是一个类一个文件，一个接口一个文件，但有时候为了方便或者某些特殊的原因...

    类加载器文件

    1. **Bootstrap ClassLoader**: 这是由JVM内部实现的类加载器，主要用于加载核心Java类库（即所有以`java.*`开头的类）。它是用本地代码实现的，并不继承自`java.lang.ClassLoader`。 2. **Extension ClassLoader**...

    正儿八经的详细讲java内部类

    1.成员内部类： (1).定义在类的内部，成员位置上的非静态类 例子： package untl1; public class outer { private static int a = 1; private int b = 2; class inner { public int c=3; pu

    计算机_高级编程语言JAV_

    2. 面向对象编程：类的创建与实例化、构造函数、访问修饰符、抽象类与接口、继承、多态、内部类等。 3. 异常处理：try-catch-finally语句块、异常类的层次结构、自定义异常。 4. 数组和集合框架：一维和多维数组、...

    spark-core_2.11-2.0.2.jav

    这个JAR文件包含了运行Spark程序所必需的基本类和功能。 Spark Core主要负责以下几个关键领域的功能： 1. **分布式任务调度**：Spark Core使用了一个名为DAG（有向无环图）的任务调度系统，它将用户提交的作业拆分...

    Java编程思第四版习题答案

    Java支持内部类，包括成员内部类、局部内部类、匿名内部类和静态内部类。内部类可以访问外部类的私有变量，提供更灵活的封装和抽象，常用于事件处理、设计模式如策略模式等场景。 3. **初始化（initialization）**...

    JAVA_algorithm_and_codetableAscII.rar_jav latest_latest jav_late

    “home.txt”虽然未提供具体信息，但通常这类文本文件可能包含一些示例代码、笔记或简介等内容，可能与Java算法或ASCII码的应用有关，为学习者提供额外的帮助。 总之，这个压缩包为Java开发者提供了一个综合的学习...

    跟我学JAVA

    第10章 接口与内部类.ppt 第11章 线程.ppt 第12章 异常处理.ppt 第13章 图形界面编程.ppt 第14章 Java IO系统.ppt 第15章 集合.ppt 第16章 Java与数据库.ppt 第17章 Java Web应用.PPT 第18章 KTV管理系统.ppt

    子网掩码计算器

    这些地址不直接面向互联网，而是用于企业内部网络的通信。 自动计算器功能使得子网掩码计算器更加便捷，用户只需输入IP地址和所需子网的数量，计算器会自动计算出相应的子网掩码、网络地址、广播地址以及可用的主机...

    java(1.8)字节码读例(匿名内部类)

    源代码 public class ThreadDemo { public static void main(String[] args) { for(int i = 0;i<10;i++){ final int j = i; new Thread(new Runnable() { @Override public void run() { ...

    Cavaj Java Decompiler JAV反编译器

    Cavaj Java Decompiler是一款强大的JAVA反编译工具，它能够将Java字节码（.class文件）转换回源代码，使开发者可以查看并理解已编译的Java程序的内部结构。这一过程对于逆向工程、软件调试、学习库功能或者在没有源...

    Java英文单词汇总编程资料java应届毕业生笔试题编程资料

    静态内部类只能访问外部类的静态成员，而非静态内部类可以访问外部类的所有成员。 - 其他选项：B正确，非静态内部类可以访问其外部类的静态属性；C和D也都正确。 4. **异常处理规则** - 正确答案是B：...

    JDBC事务管理及SavePoint示例Java开发Jav

    通过设置SavePoint，我们可以创建一个事务内部的状态点，如果后续操作出现问题，可以将事务回滚到这个状态点，而不是回滚整个事务。使用`Connection`对象的`setSavepoint(String savepointName)`方法可以设置...

    Java中文参考文档（API）.zip

    java.awt.datatransfer 提供在应用程序之间和在应用程序内部传输数据的接口和类。 java.awt.dnd Drag 和 Drop 是一种直接操作动作，在许多图形用户界面系统中都会遇到它，它提供了一种机制，能够在两个与 GUI 中...

    基于Java的实例开发源码-Jav动画图标源码（显示GIF图像）.zip

    值得注意的是，`javax.swing.ImageIcon`会自动处理GIF动画，因为它内部使用了`javax.swing.ImageIcon.UpdateListener`来更新图像。这意味着，只要将GIF图标添加到可见的组件，动画就会自动播放。 在标签和描述中...

    java基础之文件搜索器

    除了`FileFilter`，还可以使用匿名内部类或Lambda表达式简化代码，如下所示： ```java File[] textFiles = directory.listFiles(file -> file.isFile() && file.getName().endsWith(".txt")); Arrays.stream(text...

    java8学习笔记

    Java SE API的源码通常是用Java语言编写的，通过查看源码，开发者能够更深入地理解每个类和方法的内部工作机制，这有助于开发者在遇到问题时可以更高效地解决，并在需要时进行扩展或优化。 为了更好地学习Java 8，...

    Java安全教程-创建SSL连接和证书Java开发Jav

    此外，对于自签名证书或内部CA签发的证书，可能需要添加到用户的TrustStore，否则连接可能会失败。 在实际应用中，开发者还应关注SSL/TLS的性能和安全性。选择合适的加密套件，避免使用已知有安全问题的协议版本，...

Magicbox
Global site tag (gtag.js) - Google Analytics