Java内部类详解

内部类

(一) 概述

把类定义在另一个类的内部,该类就被称为内部类。

举例:把类Inner定义在类Outer中,类Inner就被称为内部类。

class Outer {
  class Inner {
  }
}

(二) 内部类的访问规则
​ A:可以直接访问外部类的成员,包括私有

​ B:外部类要想访问内部类成员,必须创建对象

(三) 内部类的分类

A:成员内部类

​ B:局部内部类

​ C:静态内部类

​ D:匿名内部类

(1) 成员内部类
成员内部类——就是位于外部类成员位置的类
特点:可以使用外部类中所有的成员变量和成员方法(包括private的)

A:格式:

class Outer {
  private int age = 20;
  //成员位置
  class Inner {
    public void show() {
      System.out.println(age);
    }
  }
}

class Test {
  public static void main(String[] ages) {
    //成员内部类是非静态的演示
    Outer.Inner oi = new Outer.new Inner();
    oi.show();
  }
}

B:创建对象时:
//成员内部类不是静态的:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

//成员内部类是静态的:
外部类名.内部类名 对象名 = new 外部类名.内部类名();   
C:成员内部类常见修饰符:
A:private

如果我们的内部类不想轻易被任何人访问,可以选择使用private修饰内部类,这样我们就无法通过创建对象的方法来访问,想要访问只需要在外部类中定义一个public修饰的方法,间接调用。这样做的好处就是,我们可以在这个public方法中增加一些判断语句,起到数据安全的作用。

class Outer {
  private class Inner {
    public void show() {
      System.out.println(“密码备份文件”);
    }
  }

  public void method() {
    if(你是管理员){
      Inner i = new Inner();
      i.show();
    }else {
      System.out.println(“你没有权限访问”);
    }
    }
}

下面我们给出一个更加规范的写法

class Outer {
  private class Inner {
    public void show() {
      System.out.println(“密码备份文件”);
    }
  }
  //使用getXxx()获取成员内部类,可以增加校验语句(文中省略)
  public void getInner() {
    return new Inner();
    }

  public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.getInner();
    inner.show();
  }
}

B:static
这种被 static 所修饰的内部类,按位置分,属于成员内部类,但也可以称作静态内部类,也常叫做嵌套内部类。具体内容我们在下面详细讲解。

D:成员内部类经典题(填空)

请在三个println 后括号中填空使得输出25,20,18

class Outer {
  public int age = 18;
  class Inner {
    public int age = 20;
    public viod showAge() {
      int age = 25;
      System.out.println(age);//空1
      System.out.println(this.age);//空2
      System.out.println(Outer.this.age);//空3
    }
  }
}

(2) 局部内部类
局部内部类——就是定义在一个方法或者一个作用域里面的类
特点:主要是作用域发生了变化,只能在自身所在方法和属性中被使用

A 格式:

class Outer {
  public void method(){
    class Inner {
    }
  }
}

B:访问时:

//在局部位置,可以创建内部类对象,通过对象调用和内部类方法
class Outer {
  private int age = 20;
  public void method() {
    final int age2 = 30;
    class Inner {
      public void show() {
          System.out.println(age);
        //从内部类中访问方法内变量age2,需要将变量声明为最终类型。
        System.out.println(age2);
      }
    }

    Inner i = new Inner();
    i.show();
  }
}

C: 为什么局部内部类访问局部变量必须加final修饰呢?

因为局部变量是随着方法的调用而调用,使用完毕就消失,而堆内存的数据并不会立即消失。

所以,堆内存还是用该变量,而该变量已经没有了。为了让该值还存在,就加final修饰。

原因是,当我们使用final修饰变量后,堆内存直接存储的是值,而不是变量名。

(即上例 age2 的位置存储着常量30 而不是 age2 这个变量名)

(3) 静态内部类

我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类.
特点:不能使用外部类的非static成员变量和成员方法

解释:非静态内部类编译后会默认的保存一个指向外部类的引用,而静态类却没有。

简单理解:

即使没有外部类对象,也可以创建静态内部类对象,而外部类的非static成员必须依赖于对象的调用,静态成员则可以直接使用类调用,不必依赖于外部类的对象,所以静态内部类只能访问静态的外部属性和方法。

class Outter {
  int age = 10;
  static age2 = 20;
  public Outter() {
  }

  static class Inner {
    public method() {
      System.out.println(age);//错误
      System.out.println(age2);//正确
    }
  }
}

public class Test {
  public static void main(String[] args) {
    Outter.Inner inner = new Outter.Inner();
    inner.method();
  }
}

(4) 匿名内部类
一个没有名字的类,是内部类的简化写法
A 格式:

new 类名或者接口名() {
    重写方法();
}
本质:其实是继承该类或者实现接口的子类匿名对象

这也就是下例中,可以直接使用 new Inner() {}.show(); 的原因 == 子类对象.show();

interface Inter {
  public abstract void show();
}

class Outer {
  public void method(){
    new Inner() {
      public void show() {
        System.out.println("HelloWorld");
      }
    }.show();
  }
}

class Test {
  public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
  }
}

如果匿名内部类中有多个方法又该如何调用呢?

Inter i = new Inner() { //多态,因为new Inner(){}代表的是接口的子类对象
  public void show() {
  System.out.println("HelloWorld");
  }
};

B:匿名内部类在开发中的使用

​我们在开发的时候,会看到抽象类,或者接口作为参数。

而这个时候,实际需要的是一个子类对象。

如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式简化。

(0)

相关推荐

  • 基于java内部类作用的深入分析

    提起Java内部类(Inner Class)可能很多人不太熟悉,实际上类似的概念在C++里也有,那就是嵌套类(Nested Class),关于这两者的区别与联系,在下文中会有对比.内部类从表面上看,就是在类中又定义了一个类(下文会看到,内部类可以在很多地方定义),而实际上并没有那么简单,乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部类身上的确是用心良苦.学会使用内部类,是掌握Java高级编程的一部分,它可以让你更优雅地

  • java中关于内部类的使用详解

    内部类访问规则 •内部类可以直接访问外部类中的成员,包括私有.访问格式:外部类名.this•外部类要访问内部类必须创建内部类对象.•内部类在成员位置上,可以被成员修饰符修饰. 复制代码 代码如下: public class InnerClassDemo1 {     public static void main(String[] args){         Outer ou =new Outer();         ou.method();// 4  3         Outer.Inn

  • Java内部类的继承(全)

    下面通过实例代码给大家分享下有关JAVA内部类的继承,具体详解如下: Java内部类的构造器必须连接到指向其外围类对象的引用(构造内部类必须给它一个外部类对象的引用,内部类依赖于外部类对象),所以在继承内部类的时候,需要在导出类的构造器中手动加入对基类构造器的调用. 因为,在导出类实例化时,并不存在一个外围类对象,以让导出类的实例去连接到它. 所以,我们需要创建一个外围类,然后用一个特定的语法来表明内部类与外围类的关系. 在下例子中,需要给导出类InheritInner一个来自内部类的外围类中的

  • java 内部类(匿名类,匿名对象,静态内部类)详解及实例

    内部类的介绍 定义在另外一个类中的类,叫内部类 成员内部类 1..new 创建成员内部类必须先创建外部类的实例,然后通过.new 创建内部类的对象 2..this 可以通过外部类的类名.this去访问外部类的所有属性和方法. public class Test1 { String name = "asnd"; public static void main(String[] args) { Test1 test1 = new Test1(); Inner mInner = test1.

  • 深入浅析Java中Static Class及静态内部类和非静态内部类的不同

    java中的类可以是static吗?答案是可以.在java中我们可以有静态实例变量.静态方法.静态块.类也可以是静态的. java允许我们在一个类里面定义静态类.比如内部类(nested class).把nested class封闭起来的类叫外部类.在java中,我们不能用static修饰顶级类(top level class).只有内部类可以为static.      静态内部类和非静态内部类之间到底有什么不同呢?下面是两者间主要的不同. (1)内部静态类不需要有指向外部类的引用.但非静态内部

  • 简单谈谈java中匿名内部类构造函数

    先看看下面的代码能不能编译通过: public static void main(String[] args) { List l1 = new ArrayList(); List l2 = new ArrayList(){}; List l3 = new ArrayList(){{}}; System.out.println(l1.getClass() == l2.getClass() ); System.out.println(l2.getClass() == l3.getClass() );

  • java匿名内部类实例简析

    匿名类是不能有名称的类,所以没办法引用它们.必须在创建时,作为new语句的一部分来声明它们.这就要采用另一种形式的new语句,如下所示: new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类,它对一个给定的类进行扩展,或者实现一个给定的接口.它还创建那个类的一个新实例,并把它作为语句的结果而返回.要扩展的类和要实现的接口是new语句的操作数,后跟匿名类的主体.如果匿名类对另一个类进行扩展,它的主体可以访问类的成员.覆盖它的方法等等,这和其他任何标准的类都是一样

  • JAVA 内部类详解及实例

    JAVA 内部类 一.什么是内部类? 一个类的定义放在另一个类的内部,这个类就叫做内部类 二.内部类有那些特性? 1.内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 . 2.内部类不能用普通的方式访问.内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 . 3.内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 . 三.内部类有哪几种? 1.成员内

  • Java内部类详解

    内部类 (一) 概述 把类定义在另一个类的内部,该类就被称为内部类. 举例:把类Inner定义在类Outer中,类Inner就被称为内部类. class Outer { class Inner { } } (二) 内部类的访问规则 ​ A:可以直接访问外部类的成员,包括私有 ​ B:外部类要想访问内部类成员,必须创建对象 (三) 内部类的分类 A:成员内部类 ​ B:局部内部类 ​ C:静态内部类 ​ D:匿名内部类 (1) 成员内部类 成员内部类--就是位于外部类成员位置的类 特点:可以使用外

  • Java 匿名内部类详解及实例代码

    Java  匿名内部类详解 匿名内部类也就是没有名字的内部类 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写 但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat someth

  • Java基础详解之内存泄漏

    一.什么是内存泄漏 内存泄漏是指你向系统申请分配内存进行使用(new/malloc),然后系统在堆内存中给这个对象申请一块内存空间,但当我们使用完了却没有归系统(delete),导致这个不使用的对象一直占据内存单元,造成系统将不能再把它分配给需要的程序. 一次内存泄漏的危害可以忽略不计,但是内存泄漏堆积则后果很严重,无论多少内存,迟早会被占完,造成内存泄漏. 二.Java内存泄漏引起的原因 1.静态集合类引起内存泄漏: 像HashMap.Vector等的使用最容易出现内存泄露,这些静态变量的生命

  • Java关键字详解之final static this super的用法

    目录 1. final 关键字: 2. static 关键字: 3. this 关键字: 4. super 关键字: final,static,this,super 关键字总结 正文开始@Assassin 1. final 关键字: final 关键字,意思是最终的.不可改变的,初始化之后就不能再次修改 ,用来修饰类.方法和变量,具有以下特点: final 修饰的类不能被继承,final类中的所有成员方法都会被隐式的指定为 final 方法: final 修饰的方法不能被重写: final 修饰

  • Java  匿名内部类详解及实例代码

    Java  匿名内部类详解 匿名内部类也就是没有名字的内部类 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写 但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat someth

  • Java BigDecimal详解_动力节点Java学院整理

    1.引言 借用<Effactive Java>这本书中的话,float和double类型的主要设计目标是为了科学计算和工程计算.他们执行二进制浮点运算,这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的.然而,它们没有提供完全精确的结果,所以不应该被用于要求精确结果的场合.但是,商业计算往往要求结果精确,例如银行存款数额,这时候BigDecimal就派上大用场啦. 2.BigDecimal简介 BigDecimal 由任意精度的整数非标度值 和32 位的整数标度 (scale) 组

  • Java递归算法详解(动力节点整理)

    递归算法是一种直接或者间接调用自身函数或者方法的算法.Java递归算法是基于Java语言实现的递归算法.递归算法的实质是把问题分解成规模缩小的同类问题的子问题,然后递归调用方法来表示问题的解.递归算法对解决一大类问题很有效,它可以使算法简洁和易于理解.    递归算法解决问题的特点: 1)递归就是方法里调用自身.  2) 在使用递增归策略时,必须有一个明确的递归结束条件,称为递归出口.  3)递归算法解题通常显得很简洁,但递归算法解题的运行效率较低.所以一般不提倡用递归算法设计程序.  4)在递

  • Java设计模式详解之门面模式(外观模式)

    门面模式(Facade Pattern)也叫外观模式,它隐藏系统的复杂性,并向客户端提供一个可以访问系统的接口.这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性,为子系统中的一组接口提供了一个统一的高层访问接口,这个接口使得子系统更容易被访问或使用.这种模式涉及到一个单一的类,该类提供了客户端请求的简化方法和对现有系统类方法的委托调用. 简而言之,就是把一堆复杂的流程封装成一个接口供给用户更简单的使用,这个设计模式里有三个角色: 1)门面角色( facade ):

  • Java Cache详解及简单实现

     Java Cache详解及简单实现 概要: 最近在做spring的项目,想做一个缓存,访问数据库,定期来做数据更新 要实现两个功能 可以通过http请求来立刻刷新缓存 缓存可以通过自己配置的时间间隔来定期刷新 通过Controller来做 因为需要通过http来刷新缓存,所以第一个想法就是把缓存做成一个Controller Controller的实现 Controller最大的优势,就是可以通过Spring的配置,注入很多依赖,比如对Service的依赖,对数据库的依赖等. 大量的访问数据库跟

随机推荐