浅谈java内部类

毫无疑问,居然是内部类,定义在类里面的类就是内部类。

public class Room {  
    class Student{//内部类   
    }  
}

内部类可以分为静态内部类(static修饰的类)和普通内部类。下面先讨论普通内部类:

(注意,以下所说的内部类都是指普通内部类)

1.内部类与外部类的关系:
对于普通内部类,实际上该类就类似于外部类的一个特殊成员,该内部类的创建必须依附于外部类,也就是说,必须先有外部类对象,才能创建内部类对象。这是因为内部类对象会隐式地连接到创建它的外部类对象上。并且内部类可以访问外部类的所有元素。创建时通过 .new来创建

public class Room {  
    private String book = "数据结构";  
    class Student{//内部类  
        public String getBook(){  
            return book;  
        }  
    }  
    public static void main(String[] args) {  
        Room r = new Room();  
        Student s = r.new Student();//不能有 Student s = new Student()来创建  
        System.out.println(s.getBook());  
    }  
}

注:如果要在内部类通过this关键字来引用外部类对象,则需要在这样引用 Room.this 。如果只是用this的话,引用的是内部类对象。

2.在方法和作用域内的内部类

(1).定义在方法内的内部类,我们称之为局部内部类:

public void get(){//只贴方法内的代码,其他代码省略  
    class Book{ //定义在方法内的内部类  
        String name = book;//book变量是外部类的成员属性  
    }  
}

显然,Book内只是方法get()的一部分,而不是外部类的一部分,所以,get()方法之外都不能访问Book。

(2).下面展示任何在任意作用域内嵌入一个内部类

public void get2(boolean b){  
    if(b){//在if语句作用域内定义内部类  
        class Book2{  
            String name = book;  
        }  
    }  
}

(3).内部类不能定义静态变量和静态方法

原因:类在初始化的过程中,是先初始化静态变量等的。也就是说,在编译是只要是定义为静态变量了,系统就会自动分配内存给它,但是内部类是依附与外部类的存在而存在的,也就是说只有外部类存在了,内部类才能存在,这就和编译时为静态变量分配内存产生了冲突。

3.匿名内部类

看下面一个程序

public class Animal {  
    public void run(){  
        System.out.println("我是一只不知名的动物");  
    }  
    public Animal getAnimal(){  
        return new Animal(){//返回匿名内部类  
            public void run(){  
                System.out.println("我是一只小猫");  
            }  
        };  
    }  
    public static void main(String[] args) {  
        Animal a = new Animal();  
        Animal a1 = a.getAnimal();  
        a1.run();  
    }  
}

打印结果:我是一只小猫

在getAnimal()方法里,将返回值的生成与表示这个返回值的类定义结合在一起。另外,这个类是匿名的,没有名字。对于这种用法,看起来似乎你正要创建一个Animal的对象,实际上,创建的却是一个继承了Animal类的匿名对象,run()方法 是对父类方法的重写。

对于这种匿名内部类,使用的是默认构造器来生成Animal的,如果你的基类(也就是父类)需要一个有参数的构造器,该怎么办:
只需要把参数传递给基类的构造器即可。

public Animal getAnimal2(String name){  
    return new Animal(name){//直接把参数给它就行  
        public void run(){  
            System.out.println("我是一只" + name);  
        }  
    };  
}

以下来讨论静态内部类:

对于静态内部类,它与普通内部类不同。普通的内部类对象会隐式地保存了一个引用,指向创建它的外部类对象。然而,对于静态类来说,就不是这样了:

(1).要创建静态内部类,它并不需要其外部类的对象

public class Book {   
    static class Math{  }  
    public static void main(String[] args) {  
        Math m = new Math();//静态内部类的创建  
    }  
}

(2).静态内部类不能访问非静态的外部类对象

public class Book {  
    int B_price = 10;  
    static String B_name = "好书";  
      
    static class Math{  
        //int M_price = B_price;//不能访问  
        String M_name = B_name;  
    }  
}

对于为何不能访问非静态变量我是这样理解的:非静态量是属于类对象成员,而不是类成员,它的存在是依附于对象而不是类。静态内部类访问这个外部类成员的时候,这个成员还不存在,因为外部对象还没有被创建。故不能访问非静态成员。(当然,也可以从类加载的顺序等分析)。

(3).静态内部类还可以作为接口的一部分。

正常情况下,是不能在接口内部放置任何代码的,但是静态内部类可以作为接口的一部分。你放到接口中的任何类都自动地是public和static的。因为类是static的,只是将静态内部类置于接口的命名空间内,这并不会违反接口的规则:

public interface AA {  
    void get();  
    class BB implements AA{  
        @Override  
        public void get() {  
            System.out.println("哈哈");     
        }     
    }  
}

二、为啥需要内部类?

1.对于抽象类,我们都知道只能被单继承,如果一个类想要继承多个抽象类,那只能使用内部类才能实现多重继承(即定义几个内部类,每个内部类分担继承一个)。

2.内部类的使用,对一个类来说,提供了更好的封装。例如要生产一辆车,我们可以假设老板是外部类,负责组装车部件的团队是内部类。那么你想要修改车里面的部件时,不仅仅是通过老板就可以直接做出修改了,还得通过负责装车部件的团队。也就是说,外部类的有些属性成员,只要通过内部类才能修改,这样子设计,会更具合理性。

3.内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外部类对象的信息相互独立。

4.在单个外部类中,可以让多个内部类以不同的方式实现同一个接口,或继承同一个类。

原文 

https://juejin.im/post/5afac2d06fb9a07aab2a028f

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 浅谈java内部类

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址