内部类

  • 虽然在类之中的基本组成就是成员属性与方法，但是在任何的语言里面结构也是允许进行嵌套的，所以在一个类的内部可以定义其他的类，这样的类就成为内部类；

内部类的基本定义

  • 如果说到内部类肯定其本身是一个独立且完善的类结构，在一个类的内部除了属性和方法外可以继续使用class定义内部类；
//内部类的基本定义
package demo;
class Outer {   //外部类
  private String msg = "www.baidu.com";    //私有成员属性
  public void fun() {   //普通方法
    Inner in = new Inner();   //实例化内部对象
    in.print();   //调用内部类方法
  }
  class Inner {   //内部类
    public void print() {
      System.out.println(Outer.this.msg);    //msg是Outer的属性
    }
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    Outer out = new Outer();    //实例化外部对象
    out.fun();    //调用外部类中的方法
  }
}
  • 从整个代码上实际发现内部类并不难理解，甚至可以说其结构与普通类一样清晰明了；
  • 从代码结构来讲，内部类的结构并不合理，所以内部类本身最大的缺陷在于破坏类程序的结构，但是破坏需要有目的的破坏，不过它一定也会有一些优势，如果想要更好的观察内部类的优势，就可以内部类拿到外面来进行观察；
//将刚才的程序分为两个类
package demo;
class Outer {   //外部类
  private String msg = "www.baidu.com";    //私有成员属性
  public void fun() {   //普通方法
//思考五：需要将当前对象Outer传递到Inner类之中
    Inner in = new Inner(this);   //实例化内部对象
    in.print();   //调用内部类方法
  }
  //思考一：如果msg要想被外部访问，须提供getter方法
  public String getMsg() {
    return this.msg;
  }
}
class Inner {   //内部类
  //思考三：Inner类实例化对象的时候要有Outer类的引用
  private Outer out;
  //思考四：应该通过Inner的构造方法获取Outer类对象
  public Inner(Outer out) {
    this.out = out;
  }
  public void print() {
    //思考二：如果想要调用外部类中的getter方法，必须有Outer类对象
    System.out.println(this.out.getMsg());    //msg是Outer的属性
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    Outer out = new Outer();    //实例化外部对象
    out.fun();    //调用外部类中的方法
  }
}
  • 可以发现，整体操作之中，折腾半天主要的目的是为了让Inner这个内部类可以访问Outer这个类中的私有属性，如果不用内部类的时候整体代码非常麻烦，所以可以得出内部类的优点：轻松的访问外部类中的私有属性；

内部类相关说明

  • 现在已经清楚的认识到了内部类的优势以及结构，那么随后需要对内部类进行一些相关的说明，现在所定义的内部类都属于普通的内部类的形式，普通的类内部往往会提供有属性和方法，需要注意的是，内部类虽然可以方便的访问外部类中的私有成员或私有方法，同理，外部类也可以轻松访问内部类重的私有成员或私有方法；
//外部类访问内部类中的私有属性
package demo;
class Outer {  
  private String msg = "www.baidu.com";  
  public void fun() {   
    Inner in = new Inner();  
    in.print(); 
    System.out.println(in.info);    //访问内部类的私有属性
  }
  class Inner { 
    private String info = "一些信息";
    public void print() {
      System.out.println(Outer.this.msg); 
    }
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    Outer out = new Outer(); 
    out.fun();    
  }
}
  • 使用了内部类之后，内部类与外部类之间的私有操作就不再需要通过setter、getter以及其他的间接方式完成类，可以直接进行处理操作；
  • 但是需要注意的是，内部类本身也属于一个类，虽然在大部分的情况下内部类往往是被外部类包裹的，但是外部依然可以产生内部类的实例化对象，而此时内部类实例化对象的格式如下：
    • 外部类.内部类 内部类对象 = new 外部类().new 内部类()；
  • 在内部类编译完成之后会自动形成一个“Outer💲Inner.class”类文件，其中“$”这个符号换到程序之中就变成类“.”，所以内部类的全称：“外部类.内部类”，内部类与外部类之间可以直接进行私有成员的访问，这样一来，内部类如果要是提供有实例化对象了，一定要先保证外部类已经实例化了；
package demo;
class Outer {  
  private String msg = "www.baidu.com";
  class Inner {
    public void print() {
      System.out.println(Outer.this.msg); 
    }
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    Outer.Inner in = new Outer(). new Inner();  
    in.print();
  }
}
  • 如果此时Inner类只允许Outer类来使用，那么就可以使用private进行私有定义；
class Outer {  
  private String msg = "www.baidu.com";
  private class Inner {
    public void print() {
      System.out.println(Outer.this.msg); 
    }
  }
}
  • 此时的Inner类无法在外部进行使用；
  • 在Java之中作为最基础的结构体实际上还有与之类似的抽象类或者是接口，抽象类与接口中都可以定义内部结构；
//定义内部接口
package demo;
interface IChannel {    //定义接口
  public abstract void send(IMessage msg);   //发送消息
  interface IMessage {
    public abstract String getContent();    //获取消息内容
  }
}
class ChannelImpl implements IChannel {
  public void send(IMessage msg) {
    System.out.println("发送消息：" + msg.getContent());
  }
  class MessageImpl implements IMessage {
    public String getContent() {
      return "www.baidu.com";
    }
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    IChannel channel = new ChannelImpl();
    channel.send(((ChannelImpl)channel).new MessageImpl());
  }
}
  • 下面继续观察一个内部的抽象类，内部抽象类可以定义在普通类、抽象类、接口内部；
//观察内部抽象类
package demo;
interface IChannel {  
  public abstract void send();  
  abstract class AbstractMessage {
    public abstract String getContent();  
  }
}
class ChannelImpl implements IChannel {
  public void send() {
    AbstractMessage msg = new Message();
    System.out.println(msg.getContent());
  }
  class Message extends AbstractMessage {
    public String getContent() {
      return "www.baidu.com";
    }
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    IChannel channel = new ChannelImpl();
    channel.send();
  }
}
  • 内部类还有一些更为有意思的结构，即：如果现在定义了一个接口，那么可以在内部利用类实现该接口，在JDK1.8之后接口追加了static方法可以不受到实例化对象的控制，现在就可以利用此特效来完成功能；
//接口内部进行接口实现
package demo;
interface IChannel {  
  public abstract void send();  
  class ChannelImpl implements IChannel {
    public void send() {
      System.out.println("www.baidu.com");
    }
  }
  public static IChannel getInstance() {
    return new ChannelImpl();
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    IChannel channel = IChannel.getInstance();
    channel.send();
  }
}

static定义内部类

  • 如果说在内部类上使用了static定义，那么这个内部类就变为了“外部类”，static定义的都是独立于类的结构，所以该类结构就相当于是一个独立的程序类,需要注意的是，static定义的不管是类还是方法只能够访问static成员，所以static定义的内部类只能够访问外部类中的static方法；
//使用static定义内部类
package demo;
class Outer {
  private static final String MSG = "www.baidu.com";
  static class Inner {
    public void print() {
      System.out.println(MSG);
    }
  }
}
  • 这个时候Inner类是一个独立的类，如果此时要想实例化Inner类对象，只需要根据“外部类.内部类”的结构实例化对象即可，格式如下：
    • 外部类.内部类 内部类对象 = new 外部类.内部类()；
//实例化static内部类对象
public class JavaDemo {
  public static void main(String [] args) {
    Outer.Inner in = new Outer.Inner();
    in.print();
  }
}
  • 在开发之中如果发现类名称上提供有“.”首先应该想到这是一个内部类的结构，如果可以直接进行实例化，则应该认识到这是一个static定义的内部类；
//使用static定义内部接口
package demo;
interface IMessageWrap {
  static interface IMessage {
    public abstract String getContent(); 
  }
  static interface IChannel {
    public abstract boolean connect();    //消息通道
  }
  public static void send(IMessage msg, IChannel channel) {   //消息发送
    if(channel.connect()) {
      System.out.println(msg.getContent());
    } else {
      System.out.println("消息无法发送");
    }
  }  
}
class DefaultMessage implements IMessageWrap.IMessage {
  public String getContent() {
    return "www.baidu.com";
  }
}
class NetChannel implements IMessageWrap.IChannel {
  public boolean connect() {
    return true;
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    IMessageWrap.send(new DefaultMessage(), new NetChannel());
  }
}
  • 之所以使用static定义内部接口，主要是因为这些操作是属于一组相关的定义，有了外部接口之后可以更加明确的描述出这些接口的主要功能；

方法中定义内部类

  • 内部类可以在任意的结构中进行定义，这就包括了：类中、方法中、代码块中，但是从开发来讲在方法中定义内部类的形式较多；
//观察在方法中定义的内部类
package demo;
class Outer {
  private String msg = "www.baidu.com";
  public void fun(long time) {
    class Inner {   //内部类
      public void print() {
        System.out.println(Outer.this.msg);
        System.out.println(time);
      }
    }
    new Inner().print();    //方法中直接实例化内部类对象
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    Outer out = new Outer();
    out.fun(12863L);
  }
}
  • 此时在fun的方法内部提供有Inner内部类的定义，并且可以发现内部类可以直接访问外部类中的私有属性也可以直接访问方法中的参数，但是对于方法中的参数直接访问是从JDK1.8开始支持的，而在JDK1.8之前，如果方法中定义的内部类要想访问方法中的参数，参数前必须追加final；
//JDK1.8之前的访问
public void fun(final long time) {
    final String info = "net";
    class Inner {   //内部类
      public void print() {
        System.out.println(Outer.this.msg);
        System.out.println(time);
        System.out.println(info);
      }
    }
    new Inner().print();    //方法中直接实例化内部类对象
  }
  • 之所以取消这样的限制，主要是为了其拓展的函数式编程准备的功能；

匿名内部类

  • 匿名内部类是一种简化的内部类的处理形式，其主要是在抽象类和接口的子类上使用的；
//观察一个基本的程序结构
package demo;
interface IMessage {
  public abstract void send(String msg);
}
class MessageImpl implements IMessage {
  public void send(String msg) {
    System.out.println(msg);
  }
}
public class JavaDemo {
  public static void main(String [] args) {
    IMessage msg = new MessageImpl();
    msg.send("这是一个消息");
  }
}
  • 如果说现在IMessage接口中的MessageImpl子类只使用唯一的一次，那么是否还有必要将其定义为单独的类，在这样的要求下，这个时候定义的子类是有些多余类，所以就可以利用匿名内部类的形式来解决此问题；
//使用匿名内部类
package demo;
interface IMessage {
  public abstract void send(String msg);
}
public class JavaDemo {
  public static void main(String [] args) {
    IMessage msg = new IMessage() {   //匿名内部类
      public void send(String msg) {
        System.out.println(msg);
      }
    };
    msg.send("这是一个消息");
  }
}
  • 有些时候为了更加方便的体现出匿名内部类的使用，往往可以利用静态方法做一个内部的匿名内部类实现；
//在接口中直接定义匿名内部类
package demo;
interface IMessage {
  public abstract void send(String msg);
  public static IMessage getInstance() {
    return new IMessage() {
      public void send(String msg) {
        System.out.println(msg);
      }
    };
  }
}
public class JavaDemo {
  public static void main(String []     args) {
    IMessage.getInstance().send("这是一个消息");
  }
}
  • 与内部类相比匿名内部类只是一个没有名字的只能够使用一次的，并且结构固定的一个子类；
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,657评论 6赞 505
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,889评论 3赞 394
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 164,057评论 0赞 354
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,509评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,562评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,443评论 1赞 302
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,251评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,129评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,561评论 1赞 314
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,779评论 3赞 335
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,902评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,621评论 5赞 345
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,220评论 3赞 328
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,838评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,971评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,025评论 2赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,843评论 2赞 354

推荐阅读更多精彩内容

  • 内部类
    一前言： 在开发中常常遇到内部类，但对一些概念不清晰．做下梳理，并添加一些实践心得．其他很多场景都会使用内部类，我...
    xwp阅读 217评论 0赞 0
  • 内部类的定义及使用
    一. 内部类基本概念 所谓的内部类指的就是一个类的内部进行其他类结构嵌套的操作语法形式。 使用语法：外部类.内部类...
    河神_6961阅读 756评论 0赞 0
  • 内部类与Android接口
    基本概念 内部类的点this和点new 要想直接创建内部类的对象，不能按照想象的方式，去引用外部类的名字dotNe...
    肱二头肌的孤单阅读 1,828评论 0赞 8
  • 13、【JavaSE】【Java 面向对象编程】内部类
    1、基本概念 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫...
    yscyber阅读 379评论 0赞 1
  • Java内部类详解
    1.Java内部类的基本概念 所谓内部类就是在一个类内部进行其他类结构的嵌套操作 1.1 内部类与外部类可以方便的...
    晴天_bcca阅读 211评论 1赞 1