转(http://www.cnblogs.com/dolphin0520/p/3811445.html)

内部类:

在Java 1.1 中,可将一个类定义置入另一个类定义中。这就叫作“内部类”。创建内部类的过程是平淡无奇的:将类定义置入一个用于封装它的类内部

一,内部类的种类:

  1. 成员内部类

    class Circle {
    double radius = 0; public Circle(double radius) {
    this.radius = radius;
    } class Draw { //内部类
    public void drawSahpe() {
    System.out.println("drawshape");
    }
    }
    }

    这个时候Draw这个类好比于Circle类中的一个成员,Circle称为Draw的外部类,Draw为Circle的成员内部类,所以像成员方法一下无条件的访问Circle中属性和方法,包括private修辞的成员,反之不行;
    当外部类与内部类的成员属性名一致的时候,默认访问的是内部类的属性,若想访问外部类的成员:Outer.this.***;

    class Circle {
    private double radius = 0;
    public static int count =1;
    private int i=1; class Draw { //内部类
    private int i=3;
    public void drawSahpe() {
    System.out.println(radius); //外部类的private成员
    System.out.println(count); //外部类的静态成员
    System.out.println(i);//内部类的成员
    System.out.println(this.i);//内部类的成员
    System.out.println(Circle.this.i);//外部类的成员
    }
    }
    }

    虽然成员内部类可以无条件地访问外部类的成员,而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员,必须先创建一个成员内部类的对象,再通过指向这个对象的引用来访问(其实这个时候,这个内部类和普通的一个类也没什么区别了):

    class Circle {
    
        public void sysoI(){
    System.out.println(new Draw().i);
    }
    class Draw { //内部类
    public int i=3;
    }
    }

    成员内部类是依附外部类而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下:

    public class Test {
    public static void main(String[] args) {
    //第一种方式:
    Outter outter = new Outter();
    Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建 //第二种方式:
    Outter.Inner inner1 = outter.getInnerInstance();
    }
    } class Outter {
    private Inner inner = null;
    public Outter() { } public Inner getInnerInstance() {
    if(inner == null)
    inner = new Inner();
    return inner;
    } class Inner {
    public Inner() { }
    }
    }

    内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子,如果成员内部类Inner用private修饰,则只能在外部类的内部访问,如果用public修饰,则任何地方都能访问;如果用protected修饰,则只能在同一个包下或者继承外部类的情况下访问;如果是默认访问权限,则只能在同一个包下访问。这一点和外部类有一点不一样,外部类只能被public和包访问两种权限修饰。我个人是这么理解的,由于成员内部类看起来像是外部类的一个成员,所以可以像类的成员一样拥有多种权限修饰。

    class Circle {
    public class Draw1 { //内部类
    public int i=3;
    }
    protected class Draw2 { //内部类
    public int i=3;
    }
    class Draw3 { //内部类
    public int i=3;
    }
    private class Draw4 { //内部类
    public int i=3;
    } }
  2. 局部内部类
    局部内部类是定义在一个方法或者一个作用域里面的类,它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。(一定程序上可以将其看作是一个局部变量一样,比如说:局部内部类就像是方法里面的一个局部变量一样,是不能有public、protected、private以及static修饰符的。)
    class People{
    public People() { }
    } class Man{
    public Man(){ } public People getWoman(){
    class Woman extends People{ //局部内部类
    int age =0;
    }
    return new Woman();
    }
    }
  3. 匿名内部类
    匿名内部类应该是平时我们编写代码时用得最多的,在编写事件监听的代码时使用匿名内部类不但方便,而且使代码更加容易维护。
    class Demo8_7 extends JPanel{
    public static void main(String[] args) {
    JButton b=new JButton();
    b.addActionListener(new ActionListener() { @Override
    public void actionPerformed(ActionEvent e) {
    // TODO Auto-generated method stub }
    });
    }
    }

    就是匿名内部类的使用。代码中需要给按钮设置监听器对象,使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象,但是前提是这个父类或者接口必须先存在才能这样使用。同样的,匿名内部类也是不能有访问修饰符和static修饰符的。

    匿名内部类是唯一一种没有构造器的类。正因为其没有构造器,所以匿名内部类的使用范围非常有限,大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说,匿名内部类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的实现或是重写。

  4. 静态内部类
    静态内部类也是定义在另一个类里面的类,只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非static成员变量或者方法,这点很好理解,因为在没有外部类的对象的情况下,可以创建静态内部类的对象,如果允许访问外部类的非static成员就会产生矛盾,因为外部类的非static成员必须依附于具体的对象。

    关于静态内部类的初始化(笔者的jdk1.8):

    @Test
    public void test07() {
    Inner_Demo1_7 d=new Inner_Demo1_7();
    d.testa();//方法一 Outter_Demo1_7.Inner_Demo1_7 d2=new Outter_Demo1_7.Inner_Demo1_7();
    d2.testa();//方法二 } class Outter_Demo1_7 {
    public Outter_Demo1_7() { } static class Inner_Demo1_7 {
    public Inner_Demo1_7() { }
    public void testa(){
    System.out.println(111);
    }
    }
    }
  5. 补充(一):
    在java(1.8以下)中, 方法的内部类可以访问方法中的局部变量,但必须用final修饰才能访问。
    原因:
    因为生命周期的原因。方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。

    首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到了。如果定义为final,java会将这个变量复制一份作为成员变量内置于内部类中,这样的话,由于final所修饰的值始终无法改变,所以这个变量所指向的内存区域就不会变(Java采用了一种copy   local   variable(复制局部变量)的方式来实现,也就是说把定义为final的局部变量拷贝过来用,而引用的也可以拿过来用,只是不能重新赋值。从而造成了可以access   local   variable(访问局部变量)的假象,而这个时候由于不能重新赋值,所以一般不会造成不可预料的事情发生。-------使用final修饰符不仅会保持对象的引用不会改变, 而且编译器还会持续维护这个对象在回调方法中的生命周期. 所以这才是final变量和final参数的根本意义.

    但是在jdk1.8中是可以直接访问的:

        @Test
    public void test07() {
    new Circle().test(2); } class Circle {
    int a=1;
    public Circle test(int c){
    int i=2;
    class Circle_sub extends Circle{
    public Circle_sub() {
    System.out.println(c);
    System.out.println(i);
    System.out.println(a);
    }
    }
    return new Circle_sub();
    }
  6. 内部类的使用场景及好处

     为什么在Java中需要内部类?总结一下主要有以下四点:

      1.每个内部类都能独立的继承一个接口的实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多继承的解决方案变得完整,

      2.方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏。

      3.方便编写事件驱动程序

      4.方便编写线程代码

  7. 补充(二)

    最后补充一点知识:关于成员内部类的继承问题。一般来说,内部类是很少用来作为继承用的。但是当用来继承的话,要注意两点:

      1)成员内部类的引用方式必须为 Outter.Inner.

      2)构造器中必须有指向外部类对象的引用,并通过这个引用调用super()。这段代码摘自《Java编程思想》

    class WithInner {
    class Inner{ }
    }
    class InheritInner extends WithInner.Inner { // InheritInner() 是不能通过编译的,一定要加上形参
    InheritInner(WithInner wi) {
    wi.super(); //必须有这句调用
    } public static void main(String[] args) {
    WithInner wi = new WithInner();
    InheritInner obj = new InheritInner(wi);
    }
    }

重新开始学习javase_内部类的更多相关文章

  1. Java编程思想学习(八) 内部类

    可以将一个类的定义放在另一个类的定义内部,这就是内部类. 内部类的定义是简单的,但是它的语法确实很是复杂,让人不是很好理解.下面就内部类做一个小结. 一.内部类的分类 总的来讲内部类分为普通内部类,匿 ...

  2. 大数据学习--day12(内部类)

    内部类学习     定义在类的内部的类  叫做内部类     包含了内部类的类 叫做外部类 内部类的作用      内部类是为了 实现 java中 多继承而存在的      内部类 可以继承其他类   ...

  3. Java学习笔记——内部类及其调用方法

    一.static内部类的static方法 public class Test0719_Inner_Test { public static void main(String[] args) { //s ...

  4. 重新开始学习javase_对象的初始化

    一.类加载机制 类加载的时机类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载.验证.准备.解析.初始化.使用.卸载7的阶段: 加载.验证.准备.初始化和卸载这5个阶段的顺序是 ...

  5. 重新开始学习javase_控制程序流程

    @学习thinking in java 二.控制程序流程 负数使用 Java 运算符:运算符以一个或多个自变量为基础,可生成一个新值.自变量采用与原始方法调用不同的一种形式,但效果是相同的.根据以前写 ...

  6. 重新开始学习javase_一切都是对象

    @学习thinking in java 一,一切都是对象 用句柄操纵对象 每种编程语言都有自己的数据处理方式.比如说c与c++中的指针,而java中尽管将一切都“看作”对象,但操纵的标识符实际是指向一 ...

  7. JAVA学习:内部类

    一.内部类的访问规则: 1.内部类可以直接访问外部类中的成员,包括私有.格式为外部类名.this 2.外部类要访问内部类,必须建立内部类对象. 代码: class Outer { private in ...

  8. Java for Anfroid 学习之 内部类

    1.什么是内部类 所谓的内部类,就是一个类定义在另一个类的里面. 代码: class  A {        int i; class B { int  j; int func(){ int resu ...

  9. javascript 学习笔记 -内部类

        js的内部类    javascript内部有一些可以直接使用的类    javascript主要有以下     object Array Math boolean      String D ...

随机推荐

  1. java学习面向对象构造函数

    在java当中目前我们学到的一个比较特殊的函数就是main函数,他是JVM执行的入口,所以书写的格式是固定的,现在我们来介绍java中另一个比较特殊的函数: 构造函数:构造对象的时候调用的函数,作用, ...

  2. 五种I/O 模式——阻塞(默认IO模式),非阻塞(常用语管道),I/O多路复用(IO多路复用的应用场景),信号I/O,异步I/O

    五种I/O 模式——阻塞(默认IO模式),非阻塞(常用语管道),I/O多路复用(IO多路复用的应用场景),信号I/O,异步I/O 五种I/O 模式:[1]        阻塞 I/O          ...

  3. bzoj3505

    ans=C((n+1)*(m+1),3)-三点一线的情况横线竖线我们可以先去掉然后考虑斜线,由于对称性我们只要考虑斜率大于0的即可有一个很显然的结论,但两点坐标差为x,y时,这条线段上的点数为gcd( ...

  4. CMOS Sensor的调试经验分享

    转自:http://bbs.52rd.com/forum.php?mod=viewthread&tid=276351 CMOS Sensor的调试经验分享 我这里要介绍的就是CMOS摄像头的一 ...

  5. 图论:(Code Forces) Graph and String

    Graph and String time limit per test 2 seconds memory limit per test 256 megabytes input standard in ...

  6. 【树状数组】CSU 1811 Tree Intersection (2016湖南省第十二届大学生计算机程序设计竞赛)

    题目链接: http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1811 题目大意: 一棵树,N(2<=N<=105)个节点,每个节点有一种颜 ...

  7. 【扩展欧几里德】Vijos P1009 清帝之惑之康熙

    题目链接: https://vijos.org/p/1009 题目大意: 两个人,一个在坐标x,每天走m,一个在坐标y,每天走n,坐标长L,问几天后碰面. 题目思路: [扩展欧几里德] 根据同余方程的 ...

  8. Windows7 搜索功能关闭了,怎么重新打开

    你的搜索功能被关闭了,打开cmd.exe,进入windows\system32输入OptionalFeatures.exe,里面有搜索功能选项,选择他.重新启动.

  9. OSGI在Eclipse中执行-console出错的问题

    在Eclipse中安装osgi插件后,执行出现异常:

  10. openSession和getCurrentSession的比较

    在比较openSession和getCurrentSession这两个方法之前,我们先认识一下这两个方法. 在进行配置信息管理时,我们一般进行一下简单步骤: Configuration cfg = n ...