java的内部类和外部类用法讲解

目录
  • 一、为何使用内部类
  • 二、内部类与外部类的联系
    • 2.1 内部类是一个相对独立的实体,与外部类不是is-a关系
    • 2.2 内部类可以直接访问外部类的元素,但是外部类不可以直接访问内部类的元素
    • 2.3 外部类可以通过内部类引用间接访问内部类元素
  • 三、创建内部类
    • 3.1 在外部类外面(或外部类main方法)创建内部了对象
    • 3.2 在外部类里面创建内部类
  • 四、内部类的种类:
    • 4.1 成员内部类
    • 4.2 方法内部类
    • 4.3 匿名内部类
    • 4.4 静态内部类

一、为何使用内部类

  • 内部类提供了更好的封装,只有外部类能访问内部类
  • 内部类可以独立继承一个接口,不受外部类是否继承接口影响
  • 内部类中的属性和方法即使是外部类也不能直接访问,相反内部类可以直接访问外部类的属性和方法,即使private
  • 利于回调函数的编写

一个内部类的例子:

public class OuterClass {
    private String outerName;
    private int outerAge;
    public class InnerClass{
        private String innerName;
        private int innerAge;
    }
}

二、内部类与外部类的联系

2.1 内部类是一个相对独立的实体,与外部类不是is-a关系

内部类是一个编译时概念,编译后外部类及其内部类会生成两个独立的class文件: OuterClass.class和OuterClass$InnerClass.class,我用javac编译器对上面的OuterClass进行编译:

 D:\>javac OuterClass.class

编译后的结果:

2.2 内部类可以直接访问外部类的元素,但是外部类不可以直接访问内部类的元素

public class OuterClass {

    private String outerName;
    private int outerAge;

    public class InnerClass{
        private int innerName;
        InnerClass(){
            //内部类可以访问外部类的元素
            outerName="I am outer class";
            outerAge=23;
        }
        public void display(){
            System.out.println(outerName+" and my age is "+outerAge);
        }
    }
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}

在上面例子中我们可以看到,内部类可以直接访问外部类属性,尽管外部类属性是用private修饰的。这是因为在创建外部类时,内部类会自动捕获一个外部类的引用,所以内部类访问外部类元素,实际上是通过他所持有外部类引用访问的。在java中,我们可以通过OuterClass.this来获得外部类的引用,请看下面例子:

public class OuterClass {
    public void display(){
        System.out.println("this is OuterClass...");
    }
    public class InnerClass{
        //获取外部类的引用
        public OuterClass getOuterClass(){
            return OuterClass.this;
        }
        public void innerDisplay(){
            //内部类也可以通过外部类的引用访问外部元素
            getOuterClass().display();
        }
    }
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.innerDisplay();
    }
}

2.3 外部类可以通过内部类引用间接访问内部类元素

public class OuterClass {
    public void display(){
        //外部类访问内部类元素,需要通过内部类引用访问
        InnerClass innerClass=new InnerClass();
        innerClass.innerDisplay();
    }
    public class InnerClass{
        public void innerDisplay(){
            System.out.println("I am inner class");
        }
    }
    public static void main(String[] args) {
        OuterClass outerClass=new OuterClass();
        outerClass.display();
    }
}

三、创建内部类

3.1 在外部类外面(或外部类main方法)创建内部了对象

其实上面2.2例子中我们已经看到了如何创建内部类。如果要创建一个内部类对象,必须利用outerClass.new来创建:

1 OuterClass outerClass = new OuterClass();

2 OuterClass.InnerClass innerClass = outerClass.new InnerClass();  

其实我们还可以一步到位: OuterClass.InnerClass innerClass=new OuterClass().new InnerClass(); 

内部类创建方法示例:

public static void main(String[] args) {
    //先创建外部类对象,再创建内部类对象
    OuterClass outerClass = new OuterClass();
    OuterClass.InnerClass innerClass1 = outerClass.new InnerClass();
    innerClass1.innerDisplay();
    //一步到位创建
    OuterClass.InnerClass innerClass2=new OuterClass().new InnerClass();
    innerClass2.innerDisplay();
}

3.2 在外部类里面创建内部类

正如2.3代码中display()方法那样,在外部类里面创建内部类,就像创建普通对象一样直接创建:

InnerClass innerClass=new InnerClass()

四、内部类的种类:

在Java中内部类主要分为成员内部类、方法内部类、匿名内部类、静态内部类。

4.1 成员内部类

成员内部类也是最普通的内部类,它是外部类的一个成员,所以他是可以无限制的访问外围类的所有成员属性和方法,尽管是private的,但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点:

  • 成员内部类中不能存在任何static的变量和方法
  • 成员内部类是依附于外围类的,所以只有先创建了外围类才能够创建内部类

4.2 方法内部类

方法内部类定义在外部类的方法中,局部内部类和成员内部类基本一致,只是它们的作用域不同,方法内部类只能在该方法中被使用,出了该方法就会失效。 对于这个类的使用主要是应用与解决比较复杂的问题,想创建一个类来辅助我们的解决方案,到那时又不希望这个类是公共可用的,所以就产生了局部内部类。

4.3 匿名内部类

匿名内部类其实就是一个没有名字的方法内部类,所以它符合方法内部类的所有约束,初次之外,还有一些地方需要注意:

  1. 匿名内部类是没有访问修饰符的。
  2. 匿名内部类必须继承一个抽象类或者实现一个接口
  3. 匿名内部类中不能存在任何静态成员或方法
  4. 匿名内部类是没有构造方法的,因为它没有类名。

一般使用匿名内部类的场景是,要继承或实现的接口只有一个抽象方法,比如添加一个监听器:

public class Button {
    public void click(){
        //匿名内部类,实现的是ActionListener接口
        new ActionListener(){
            public void onAction(){
                System.out.println("click action...");
            }
        }.onAction();
    }
    //匿名内部类必须继承或实现一个已有的接口
    public interface ActionListener{
        public void onAction();
    }

    public static void main(String[] args) {
        Button button=new Button();
        button.click();
    }
}

4.4 静态内部类

关键字static可以修饰成员变量、方法、代码块,其实它还可以修饰内部类,使用static修饰的内部类我们称之为静态内部类。静态内部类与非静态内部类之间存在一个最大的区别,我们知道非静态内部类在编译完成之后会隐含地保存着一个引用,该引用是指向创建它的外围内,但是静态内部类却没有。没有这个引用就意味着:

  • 静态内部类的创建是不需要依赖于外围类,可以直接创建
  • 静态内部类不可以使用任何外围类的非static成员变量和方法,而内部类则都可以
public class OuterClass {
    private static String outerName;
    public  int age;

    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String _innerName = "static variable";
        public void display(){
            /*
             * 静态内部类只能访问外部类的静态成员变量和方法
             * 不能访问外部类的非静态成员变量和方法
             */
            System.out.println("OutClass name :" + outerName);
        }
    }
    class InnerClass2{
        /* 非静态内部类中不能存在静态成员 */
        public String _innerName = "no static variable";
        /* 非静态内部类中可以调用外部类的任何成员,不管是静态的还是非静态的 */
        public void display(){
            System.out.println("OuterClass name:" + outerName);
            System.out.println("OuterClass age:" + age);
        }
    }
    public void display(){
        /* 外部类能直接访问静态内部类静态元素 */
        System.out.println(InnerClass1._innerName);
        /* 静态内部类可以直接创建实例不需要依赖于外部类 */
        new InnerClass1().display();
        /* 非静态内部的创建需要依赖于外部类 */
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /* 非静态内部类的成员需要使用非静态内部类的实例访问 */
        System.out.println(inner2._innerName);
        inner2.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}
(0)

相关推荐

  • java外部类与内部类简介

     一.内部类 内部类就是将一个类A定义在类B里边,里边的那个类A称为内部类,外边的类B称为外部类 成员内部类定义格式: class 外部类{ class 内部类{ } } class A{ class B{ } } 在描述一个事物是,事物的里边还有另外一个事物就可以用到内部类 访问特点: 1.内部类可以直接访问外部类的成员,包括私有成员. 2.外部类要访问内部类的成员,必须要建立内部类的对象. 创建内部类格式: 外部类.内部类 对象名=new 外部类型().new 内部类型(); 二.匿名内部类

  • java外部类与内部类的关系详解

     private,public,protected,default的访问权限区别 在学习外部类与内部类之前我们首先要弄明白private,public,protected,default在访问权限上有什么不同,这对我们之后的理解会有一定的帮助. 1.private:访问权限最低的访问控制符,被它修饰的变量只能访问本类的对象. 2.public:访问权限最高,不仅是本类,子类,本包,其他的包,都可以去访问它修饰的对象. 3.default:访问权限限制在本类以及本包内. 4.protected:访

  • java的内部类和外部类用法讲解

    目录 一.为何使用内部类 二.内部类与外部类的联系 2.1 内部类是一个相对独立的实体,与外部类不是is-a关系 2.2 内部类可以直接访问外部类的元素,但是外部类不可以直接访问内部类的元素 2.3 外部类可以通过内部类引用间接访问内部类元素 三.创建内部类 3.1 在外部类外面(或外部类main方法)创建内部了对象 3.2 在外部类里面创建内部类 四.内部类的种类: 4.1 成员内部类 4.2 方法内部类 4.3 匿名内部类 4.4 静态内部类 一.为何使用内部类 内部类提供了更好的封装,只有

  • Java内部类持有外部类导致内存泄露的原因与解决方案详解

    目录 简介 为什么要持有外部类 实例:持有外部类 实例:不持有外部类 实例:内存泄露 不会内存泄露的方案 简介 说明 本文介绍Java内部类持有外部类导致内存泄露的原因以及其解决方案. 为什么内部类持有外部类会导致内存泄露? 非静态内部类会持有外部类,如果有地方引用了这个非静态内部类,会导致外部类也被引用,垃圾回收时无法回收这个外部类(即使外部类已经没有其他地方在使用了). 解决方案 1.不要让其他的地方持有这个非静态内部类的引用,直接在这个非静态内部类执行业务. 2.将非静态内部类改为静态内部

  • Java Ribbon与openfeign区别和用法讲解

    目录 Ribbon 本地负载均衡器 本地负载均衡与Nginx 的区别 基本使用 原理分析 openfeign 基本使用 Ribbon 本地负载均衡器 在SpringCloud第一代中使用Ribbon.SpringCloud第二代中直接采用自研发 loadbalancer 即可,默认使用的Ribbon. 本地负载均衡与Nginx 的区别 本地负载均衡器基本的概念:我们的消费者服务从我们的注册中心获取到集群地址列表,缓存到本地,让后本地采用负载均衡策略(轮训.随机.权重.hash一致性等),获取接口

  • Java面向对象之内部类案例讲解

    1. 内部类 很多时候我们创建类的对象的时候并不需要使用很多次,每次只使用一次,这个时候我们就可以使用内部类了 1.1 内部类概述 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了. 内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类. 我可以把外边的类称为外部类,在其内部编写的类称为内部类. 内部类分为四种: 成员内部类 静态内部类 局部内部类 匿名内部类 1.2 成员内部类(

  • Java内部类和匿名内部类的用法说明

    一.内部类: (1)内部类的同名方法 内部类可以调用外部类的方法,如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用(其中OuterClass与MethodName换成实际外部类名及其方法:this为关键字,表示对外部类的引用):若内部类无同名方法可以直接调用外部类的方法. 但外围类无法直接调用内部类的private方法,外部类同样无法直接调用其它类的private方法.注意:内部类直接使用外部类的方法与该方法的权限与是否static无关,

  • Java中内部类的概念与分类详解

    目录 内部类概念 内部类的分类: 成员内部类 普通内部类 静态内部类 局部内部类 总结 只能使用修饰限定符:public 和 默认 来修饰类 内部类概念 在 Java 中,将一个类定义在另一个类的内部,称为内部类 就是在一个类内部进行其他类结构的嵌套操作 内部类也是封装的一种体现 举例: //外部类 public class OutClass { //内部类 class InnerClass{ } } 注意:内部类和外部类共享一个 java源文件,但是经过编译之后,会形成各自单独的字节码文件 内

  • java 中内部类的实例详解

    java 中内部类的实例详解 一:内部类可直接访问外部类的成员变量,包括外部类私有的成员变量 二:外部类要访问内部类的成员变量,需要建立内部类的对象 class Outer{ int x=110; public void show(){ System.out.println("外部类的x="+x); } public void showInner(){ Inner inner=new Inner(); inner.show(); System.out.println(inner.x);

  • 新手初学Java的内部类

    目录 Java的内部类 成员内部类 静态内部类 局部内部类 总结 Java的内部类 概念: 内部类就是在一个类的内部定义一个类,比如,A类中定义一个B类,那么B类相对于A类来说就是称为内部类,而A类相对于B类来说就是外部类. 成员内部类 静态内部类 局部内部类 匿名内部类 特点: 内部类编译之后可以生成独立的字节码文件. 内部类可以直接访问外部类的私有成员,而不破坏封装. 内部类可为外部类提供必要的内部功能组件. 外部类要访问内部类的成员,必须要建立内部类的对象 成员内部类 在内的内部定义,与实

  • Java的内部类总结

    目录 前言 一,成员内部类 1,成员内部类的特点 2,成员内部类的实现 3,内部类和外部类的关系 二,静态内部类 1,静态内部类的特点 2,比较成员内部类和静态内部类 3,静态内部类的实现 三,方法内部类 1,方法内部类的特点 2,方法内部类的实现 四, 匿名内部类 1,匿名内部类的特点 2,匿名内部类的实现 总结 前言 最近看了内部类后,总结一下,首先内部类嵌套在其他内部的类,根据出现的位置和关键字,可以分为以下四种类:成员内部类,静态内部类,方法内部类,匿名内部类,接下来就介绍下这四种类,记

随机推荐