内部类

内部类

定义：

即在一个类内部进行其它类结构的嵌套操作

程序代码

public class Outer {
    private String str = "outer str~~~";

    //定义一个内部类
    class Inner {
        private String inStr = "inner str~~~";
        //定义一个普通方法
        public void print() {
            //调用外部类的 str 属性
            System.out.println(str);
        }
    }
    //在外部类定义一个方法，负责产生内部类对象并调用 print() 方法
    public void fun() {
        //内部类对象
        Inner inner = new Inner();
        //内部类对象提供的 print
        inner.print();	//调用方法输出：outer str~~~
    }

}

tips:

优点	缺点
内部类与外部类可方便的访问彼此的私有域（包括私有方法、私有属性）	结构复杂
内部类是另外一种封装，对外部的其它类隐藏
内部类可实现单继承的局限

实例（内部类实现多继承）

class One{...}
class Two{...}

class Outer{
    private class InnerClassOne extends One{...}
    
    private class InnerClassTwo extends Two{...}
}

内部类的创建

外部类外部，创建非静态内部类

# 外部类.内部类 内部类对象 = new 外部类().new 内部类()
Outer.Inner inner = new Outer().new Inner()

外部类外部，创建静态内部类

# 外部类.内部类 内部类对象 = new 外部类().内部类()
Outer.Inner inner = new Outer().Inner()

外部类内部创建内部类

# 根普通对象创建相同
Inner inner = new Inner()

内部类的分类

成员内部类、静态内部类、方法内部类、匿名内部类

成员内部类

1、内部不允许存在任何 static 变量或方法；如成员方法中不能有任何静态属性

2、成员内部类是依附外部类的，只有创建了外部类才能创建内部类

# 错误程序
public class Outer {
    private String sex = "男";
    public static int age = 23;
    
    class Inner {
        public static int sum = 20;
        public void fun() {
            System.out.println(sex);
            System.out.println(age);
        }
    }
}

静态内部类

关键字 static 可修饰成员变量、方法、 代码块，还可修饰内部类，使用 static 修饰的内部类称为静态内部类。

静态内部类和非静态内部类区别：

非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外部类，而静态类没有；

则 静态内部类的创建无需依赖外部类可直接创建；而静态内部类不可使用任何外部的非 static 类（包含属性和方法），但可存在自己的成员变量

public class Outer {
    public String sex = "男";
    private static int age = 23;

    static class Inner {
        private String name;
        public void fun() {
            System.out.println(sex);
            System.out.println(age);
        }
    }
}

运行错误：无法从静态上下文中引用非静态变量

方法内部类

定义在方法里的类

tips:

1、方法内部类不允许使用访问权限修饰符（public、private、protected）都不运行

2、方法内部类对外部完全隐藏，除了创建此类的方法可访问以外，其它均不可访问

3、方法内部如果想要使用方法形成，该形参须使用 final 声明

public class Outer02 {
    public int sum =  20;

   public void show(final int temp) {
       //方法内部类则就是嵌套在方法里面
       class Inner {
           public void fun() {
               System.out.println(sum);
               //temp++;
               System.out.println(temp);
           }
       }
       //方法内部类在方法里创建
       new Inner().fun();
   }
}

匿名内部类

即一个没有名字的方法内部类，特点与方法内部类完全一致（参考方法内部类）

tips:

1、匿名内部类须继承一个抽象类或实现一个接口

2、匿名内部类没有类名，则没有构造方法

# 声明一个接口
interface Inner{
	void show()
}

class Outer {
    private int sum = 20;
    
    public void display(int temp) {
        //匿名内部类
        new Inner() {
            public void show() {
                System.out.println("匿名内部类~~~");
                System.out.println(temp);
            }
        }.show();
    }
}

内部类与外部类的关系

1、对于非静态内部类，内部类的创建依赖外部类，而没有外部类实例之前则是无法创建内部类

2、内部类可直接访问外部类的元素（包含私有属性），因外部类在内部类之前创建，创建内部类时会将外部类的对象传入

3、外部类可通过内部类的引用间接访问内部类元素（需创建内部类对象）

4、内部类是一个相对独立的个体，与外部类没有关系