【java提升】(18)---静态内部类和非静态内部类

<center> java提升](18)—静态内部类和非静态内部类 </center>

定义 放在一个类的内部的类咱们就叫内部类。

本身从开发到如今其实用到内部类主要在两个地方会考虑用内部类:

一、使用静态内部类的单例模式

二、将Json字符串转为Bean实体的时候，也考虑建立内部类

其它好比网上说的经过内部类实现多继承，我尚未用过。这篇博客主要将静态内部类和非静态内部类中的成员内部类，至于局部内部类和匿名内部类这边就不阐述了。

<font color=#FFD700> 1、概念</font>

咱们能够简单把内部类当成外部类的一个成员,若是你是static内部类,那么外部类不须要建立对象就能够访问你,

若是你是非静态类部类，那你就属于外部类的对象的，因此必定要先建立外部对象才能来访问你。

一、非静态内部类

成员内部类也是最普通的内部类,它是外围类的一个成员,因此它能够访问外围类的全部成员属性和方法。一样外围类也能够访问内部类的成员属性和方法。

它的主要特色是：

一、成员内部类中不能存在任何static的变量和方法

二、成员内部类是依附于外围类的对象，因此只有先建立了外围类对象才可以建立内部类对象

补充：对于成员内部内并非彻底不能出现static字段的，若是你是使用final和static同时修饰一个属性字段，而且这个字段是基本类型或者String

类型的，那么是能够编译经过的。至于缘由须要了解class文件，我以前写过一篇相关博客能够参考：【JVM虚拟机】(7)---深刻理解Class中-属性集合

二、静态内部类

使用static修饰的内部类咱们称之为静态内部类，咱们要知道只要是static修饰的类那它必定是内部类，不多是外部类。

静态内部类与非静态内部类之间存在一个最大的区别，咱们知道非静态内部类在编译完成以后会隐含地保存着一个引用，该引用是指向建立它的外围类

的对象，可是静态内部类却没有。没有这个引用就意味着：

一、它的建立是不须要依赖于外围类的对象

二、它不能使用任何外围类的非static成员变量和方法

<br>

##<font color=#FFD700> 2、示例</font>

有关静态内部类和非静态内部类这里作一个完整的代码演示

一、代码演示

/**
 * 外部类 OutClass
 */
public class OutClass {
    /**
     * 外部类静态属性
     */
    private static String name = "小小";
    /**
     * 外部类非静态属性
     */
    private Integer age = 3;

    /**
     * @Description: 非静态内部类
     */
    private class InnerClass {
        // TODO 非静态内部类不能声明或定义静态成员
        // private static String sex = "女";
        /**
         * 这里定义静态常量是不会报错的哦
         */
        public static final String sex = "女";
        /**
         * 能够定义 普通属性
         */
        private int flag = 0;

        /**
         * 构造函数
         */
        public InnerClass() {
            // 非静态内部类的非静态成员能够访问外部类的非静态变量和静态变量
            System.out.println("非静态类访问外部对象的name" + name);
            System.out.println("外部对象的age " + age);
        }
    }
    /**
     * @Description: 静态内部类
     */
    private static class InnerStaticClass {
        /**
         * 静态内部类能够有静态成员和非静态成员
         */
        private static String sex = "女";
        private int flag = 0;

        public InnerStaticClass() {
            System.out.println("静态类访问外部对象的name" + name);
            //静态类只能访问外部的静态成员，不能访问非静态成员
            //System.out.println("外部对象的age " + age);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("==========非静态内部类调用==========");
        //new一个外部类
        OutClass outClass = new OutClass();
        // 经过外部类的对象new一个非静态的内部类
        OutClass.InnerClass innerClass = outClass.new InnerClass();
        System.out.println("==========静态内部类调用==========");
        //获取静态内部类的静态属性
        String sex = OutClass.InnerStaticClass.sex;
        //获取静态内部类的非静态属性
        OutClass.InnerStaticClass inner = new OutClass.InnerStaticClass();
        System.out.println(inner.flag);

    }
}

二、总结

这里在针对上面代码作一个总结

1.静态内部类能够有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
  2.静态内部类只可以访问外部类的静态成员,而非静态内部类则能够访问外部类的全部成员(方法，属性)。
  3.实例化一个非静态的内部类的方法：
         a.先生成一个外部类对象实例
         OutClass outClass=new OutClass();
         b.经过外部类的对象实例生成内部类对象
         OutClass.InnerClass inner=outClass.new InnerClass(); 
  4.实例化一个静态内部类的方法：
         a.不依赖于外部类的实例,直接实例化内部类对象
         OutClass.InnerStaticClass inner=new OutClass.InnerStaticClass();
         b.调用内部静态类的方法或静态变量,经过类名直接调用
         OutClass.InnerStaticClass.static_sex

<br>

<font color=#FFD700> 补充</font>

####一、内部类的做用

我我的以为主要有如下三点吧

一、内部类可以提供更好的隐蔽性。由于咱们的内部类是能够用private和protected修饰的，因此在必要的时候咱们能够保证在其它类里是

没法建立当前内部类对象的。就比如咱们经常使用的静态内部类的单例模式。

二、经过内部类能够实现多继承。

三、代码能够更加整洁。由于咱们在建立实体类的时候,可能类中还包含其它类，若是这个类只会被当前类使用，那咱们只需建立一个内部类就能够了。

####二、展现一个静态类部类的单例模式

/**
 * 外部类
 */
public class StaticInnerSingleton {
    /**
     * 私有的静态内部类
     */
    private static class SingletonClassInstance{
        private static final StaticInnerSingleton instance = new StaticInnerSingleton();
    }
    /**
     * 获取单例
     */
    public static  StaticInnerSingleton getInstance() {
        return SingletonClassInstance.instance;
    }
}

<br> <br>

我相信，不管从此的道路多么坎坷，只要抓住今天，早晚会在奋斗中尝到人生的甘甜。抓住人生中的一分一秒，赛过虚度中的一月一年！(4）

原文出处：https://www.cnblogs.com/qdhxhz/p/11368870.html