Java内部类介绍 - 静态内部类和成员内部类

内部类

内部类概述

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

// 外部的People类可以理解成宿主
public class People {
    // 内部的Student类可以理解成寄生
    class Student {

    }
}

内部类的使用场景、作用

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。

内部类通常可以方便访问外部类的成员，包括私有的成员。

内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

内部类的分类

静态内部类[了解]

成员内部类（非静态内部类） [了解]

局部内部类[了解]

匿名内部类（重点）

静态内部类

介绍:

有static修饰，此内部类属于外部类本身。

它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

静态内部类格式:

public class Outer{
    // 静态成员内部类
		public static class Inner{
    }
}

静态内部类创建对象的方法:

格式: 外部类名.内部类名 对象名 = new 外部类名.内部类构造器;

例子: Outer.Inner in = new Outer.Inner();

基本代码演示:

在外部类Outer下定义静态内部类Inner

package com.chenyq.d8_innnerclass;

/**
   外部类
 */
public class Outer {
    /**
        静态内部类: 加static修饰
     */
    public static class Inner {
        
    }
}

在内部类Inner下可以和外部类一样, 可以定义变量和方法

package com.chenyq.d8_innnerclass;

/**
   外部类
 */
public class Outer {
    /**
        静态内部类: 加static修饰
     */
    public static class Inner {
        // 实例成员变量
        private String name ;
        // 静态成员变量
        public static int age;

        // 无参构造器
        public Inner() {}

        // 有参构造器
        public Inner(String name) {
            this.name = name;
        }

        // 定义实例方法
        public void show1() {
            System.out.println("内部类实例方法");
        }

        // 定义静态方法
        public static void show2() {
            System.out.println("内部类静态方法");
        }

        // getter和setter方法
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

在Test中使用Inner内部类

package com.chenyq.d8_innnerclass;

public class Test {
    public static void main(String[] args) {
        // 创建内部类实例对象
        Outer.Inner inr = new Outer.Inner("chenyq");
        Outer.Inner.age = 20;

        System.out.println(inr.getName()); //chenyq
        System.out.println(Outer.Inner.age); // 20
        inr.show1(); // 内部类实例方法
        Outer.Inner.show2(); // 内部类静态方法
    }
}

静态内部类的访问拓展:

1、静态内部类中是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

2、静态内部类中是否可以直接访问外部类的实例成员？

不可以的，外部类的实例成员必须用外部类对象访问。

静态内部类的使用场景、特点、访问总结:

如果一个类中包含了一个完整的成分，如汽车类中的发动机类。

特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。

可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。

注意：开发中实际上用的还是比较少。

成员内部类

什么是成员内部类？

无static修饰，属于外部类的对象。

JDK16之前，成员内部类中不能定义静态成员，JDK 16开始也可以定义静态成员了。

成员内部类格式:

public class Outer {
  	// 成员内部类
  	public class Inner {
  	}
}

成员内部类创建对象的方法:

成员内部类是属于外部类的实例对象的, 因此需要先new外部类(), 得到外部类实例后再外部类实例.new 内部类

格式: 外部类名.内部类名 对象名 = new 外部类构造器().new 内部类构造器();

范例: Outer.Inner in = new Outer().new Inner();

基本代码演示:

定义外部类Outer和内部类Inner

package com.chenyq.d9_innnerClass;

/**
    外部类
 */
public class Outer {
    /**
        成员内部类: 不加static修饰
     */
    public class Inner {
    }
}

定义内部类的变量和函数

注意: JDK 16开始支持在成员内部类中定义静态成员方法, JDK 16之前是不支持的

package com.chenyq.d9_innnerClass;

/**
    外部类
 */
public class Outer {
    /**
        成员内部类: 不加static修饰
     */
    public class Inner {
        // 定义实例成员变量
        private String name;
        // 定义静态成员变量
        public static int age; // JDK 16开始支持定义静态成员了(静态成员变量和静态成员方法都是JDK 16开始支持的)

        // 定义有参和无参构造器
        public  Inner() {}
        public Inner(String name) {
            this.name = name;
        }

        // 定义实例成员方法
        public void show1() {
            System.out.println("成员内部类的实例成员方法");
        }
        // 定义静态成员方法
        public static void show2() {
            System.out.println("成员内部类的静态成员方法");
        }

        // 定义setter和getter方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}

在Test类中使用成员内部类

package com.chenyq.d9_innnerClass;

public class Test {
    public static void main(String[] args) {
        // 获取Inner内部类实例对象
        Outer.Inner inr = new Outer().new Inner("chenyq");

        // 使用内部类的变量和方法
        Outer.Inner.age = 18;
        System.out.println(inr.getName());
        System.out.println(Outer.Inner.age);
        inr.show1();
        Outer.Inner.show2();
    }
}

成员内部类的访问拓展:

1、成员内部类中是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？

可以的，因为外部类的实例成员是属于外部类的实例对象的; 而创建成员内部类, 必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

总结:

1.成员内部类是什么样的、有什么特点？

无static修饰，属于外部类的对象。

可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员。

2.成员内部类如何创建对象？

外部类名.内部类名 对象名 = new 外部类构造器().new 内部类构造器();