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

今天药忘吃喽~ 2023-09-26 10:36 157阅读 0赞

#### 文章目录 ####

*   *  内部类
     *   *  内部类概述
         *  静态内部类
         *  成员内部类

### 内部类 ###

#### 内部类概述 ####

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

// 外部的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 内部类构造器();`