zoukankan      html  css  js  c++  java
  • Java内部类总结

    内部类是一种编译器现象,与虚拟机无关。编译器将会把内部类翻译成用美元符号$分隔外部类名与内部类名的常规类文件,而虚拟机对此一无所知。编译器为了引用外部类,生成了一个附加的实例域this$0

    为什么要用内部类?

    • 内部类可以访问所在类域中的数据(包括私有);
    • 内部类可以在同一包中被隐藏;
    • 匿名内部类在实现回调时非常方便;

    特殊语法

    • OuterClass.this表示外部类对象引用,比如Employee.this.id;
    • OuterObject.new InnerClass()显式调用内部对象的构造函数,例如this.new Payroll(10000);
    • OuterClass.InnerClass其它类访问内部类;
    • OuterClass$InnerClass编译器翻译成JVM能够识别的类,内部类对JVM是透明的.

    内部类表现形式

    • 简单内部类
    • 局部的内部类
    • 匿名内部类
    • 静态内部类

    简单内部类

    每个内部类对象都有一个指向外部对象的隐式引用outer;每次外部类对象初始化一个内部类对象时都会把自己的this引用传给内部类对象的隐式的构造函数,以下是模拟的过程:

    public class Outer{
        //隐式会把this传给内部类对象的构造函数,实际这个过程看不到也不用去写.
        public void function(){
            Inner inner = new Inner(this);
            ....
        }
    
        public class Inner{
        //内部类有个隐式的构造函数生成外部类对象的引用,实际这个过程看不到也不用去显示调用
            private Outer outer;
            public Inner(Outer outer){
                this.outer = outer;
            }
        }
    }

    实例如下

    public class Employee {
    
        // 实例化对象时,在调用构造函数之前前初始化字段;
        private int id; // 实例化对象时初始化为0
        private String name; // 实例化对象时初始化为null
        public Employee(int id, String name) {
            this.id = id;
            this.name = name;
    
        }
    
        public void start(){
            //局部的内部类
            class Computer{
                private int seq;
                public Computer(int seq){
                    this.seq = seq;
    
            public void run(){
                    System.out.println(seq + " computer is run");
                }
            }
    
            Computer c = new Computer(2015);    
            c.run();
        }
    
        //简单内部类
        public class Payroll {
            private int pay;
            //以下是模拟生成外部类对象的引用
            // private Employee outer;
            // public Payroll(Employee e) {
            // this.outer = e;
            // }
    
            public Payroll(int pay) {
                this.pay = pay;
            }
    
            // 每个内部类对象都有一个指向外部对象的隐式引用outer,可以把id和name想象成outer.id和outer.name
            public void printPay() {
                //if (id == 1) {
                    if(Employee.this.id ==1){
                    System.out.println("name is " + name);
                    System.out.println("pay is: " + pay);
                    System.out.println("----------------------------");
                } else {
                    System.out.println("you can not print pay");
                }
            }
        }
    
        public void printPayroll() {
            //Payroll p = new Payroll(10000);
            Payroll p = this.new Payroll(10000);
            p.printPay();
        }
    
        public static void main(String[] args) {
            Employee e1 = new Employee(1, "a");
            Employee e2 = new Employee(2, "b");
            e1.printPayroll();
            e2.printPayroll();
            e1.start();
        }
    }

    局部的内部类

    在外部类方法中定义的内部类称为局部内部类,局部内部类不能用修饰符(public or private)定义.只能访问局部方法作用域的final变量.

        public void start(){
            final int num = 2015;
            class Computer{
                private int seq;
                public Computer(int seq){
                    this.seq = seq;
                }   
    
                public void run(){
                    System.out.println("seq is: " + seq + ", num is: " + num);
                }
            }   
    
            Computer c = new Computer(2015);
            c.run();
        }

    匿名内部类

    语法如下,SuperType可是接口也可以是类.匿名内部类不能有构造函数.匿名内部类隐式地继承了一个父类或者实现了一个接口。

    new SuperType(construction parameters)
    {

    inner class method and data
    

    }

    或者是
    new InterfaceType()
    {

    inner class method and data
    

    }

    实例

    new Thread() {
                //匿名内部类
                @Override
                public void run() {
                    System.out.println("----------------------------");
                    System.out.println("this is a anonymous class run");
                }
    }.start();

    静态内部类

    静态内部类与其它内部类相似,不同之处在于静态内部类没有指向外部类的引用.当不需要访问外部对象时,可以考虑使用静态内部类.被编译成一个完全独立的.class文件,名称为OuterClass$InnerClass.class的形式。只可以访问外部类的静态成员和静态方法,包括了私有的静态成员和方法。 注意,声明在接口中的内部类自动成为public和static。
    实例

    public class StaticInner {
        private static int a = 4;
    
        // 静态内部类
        public static class Inner {
            public void test() {
                // 静态内部类可以访问外部类的静态成员
                // 并且它只能访问静态的
                System.out.println(a);
            }
        }
    
        public static void main(String[] args) {
            StaticInner.Inner inner = new StaticInner.Inner();
            inner.test();
        }
    }
  • 相关阅读:
    JS收集<3>:限制URL
    TSQL小收集<1>:为已经存在的表添加唯一约束
    第一个NHibernate实例 yangan
    用Javascript获取select的值 yangan
    获取页面名称语句 yangan
    asp.net中当服务器出错时显示指定的错误页面,同时把错误信息写入系统日志文件 yangan
    Log4Net使用指南 yangan
    明确自己的首要责任
    《大数据时代》摘录
    2013年3月阅读链接
  • 原文地址:https://www.cnblogs.com/csu_xajy/p/4304443.html
Copyright © 2011-2022 走看看