Java--面向对象->内部类

一、概念

内部类是一个类的内部进行其他类结构的嵌套的操作

简单定义：

package com.wl;

//内部类的简单定义
class Outer{
    private String msg = "Hello World!";
    //定义一个内部类
    class Inner{
        //内部类中的普通方法
        public void print(){
            System.out.println(msg);//调用msg属性
        }
    }

    public void fun(){
        Inner in = new Inner();//内部类对象
        in.print();//内部类提供的方法
    }
}

//
public class Test {
    public static void main(String[] args) {
       //内部类的简单定义
          Outer out  = new Outer();//外部类对象
          out.fun();//外部类方法

    }
}

代码运行结果：

特点：1.破坏了程序的结构

           2.内部类可以方便的操作外部类的私有访问

二、内部类存在的意义

1.内部类方法可以访问该类作用于中定义的数据，包含private修饰的私有数据；

2.内部类可以对同一包中的其他类隐藏；

3.内部类可实现Java的单继承的缺陷；

4.使用匿名内部类可以定义一个回调函数，并且所需写的代码较少。

三、内部类与外部类的区别

1. 对于非静态内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前无法创建内部类；
2. 内部类是一个相对独立的实体；
3. 内部类可直接访问外部类的元素（包含私有域）；
4. 外部类不可以直接访问内部类中的元素，可以通过内部类引用间接访问内部类元素。

举例：内部类直接访问外部类元素

package com.wl;

//内部类直接访问外部类元素
class Outter{
    private String name;
    private int age;
    //内部类
    class Inner{
        private int InnerAge;
        public Inner(){
            Outter.this.name = "张三";
            Outter.this.age = 20;
        }
        public void display(){
            System.out.println(name);
            System.out.println(age);
        }
    }
}


public class Test{
    public static void main(String[] args) {
        Outter.Inner in = new Outter().new Inner();
        in.display();

    }
}

代码运行结果：

举例：外部类通过内部类引用间接访问内部类元素

package com.wl;

//外部类通过内部类引用间接访问内部类元素
class Outter1{
    class Inner{
        public void display(){
            System.out.println("I am InnerClass");
        }
    }

    public void display(){
        //外部类访问内部类元素，需通过内部类引用间接访问
        Inner in = new Inner();
        in.display();
    }


}

public class Test {
    public static void main(String[] args) {
        //外部类通过内部类引用间接访问内部类元素
        Outter1 out = new Outter1();
        out.display();
    }
}

代码运行结果：

四、内部类分类

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

1. 成员内部类

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

2. 静态内部类

           2.1 定义：使用static修饰的内部类
           2.2 静态内部类的创建不需要依赖于外部类，可直接创建
           2.3 静态内部类不可以使用任何外部类的非static成员变量和方法，而内部类都可以

package com.wl;

//使用static创建静态内部类
class Outer1{
    private static String msg = "Hello";
    //定义的内部类
    static class Inner{
        public void print(){//此时只能使用外部类中的static 进行操作
            System.out.println(msg);//调用外部类的msg属性
        }
    }

    //外部类中定义的方法，产生内部类对象并且调用print()方法
    public void fun(){
        Inner in = new Inner();//内部类对象
        in.print();
    }

}

public class Test {
    public static void main(String[] args) {
       
        //使用static创建的静态内部类
        Outer1.Inner in = new Outer1.Inner();
        in.print();
        
    }
}

代码运行结果：

3. 方法内部类

           3.1 定义：定义在外部类的方法中，只能在该方法中被使用
           3.2 局部内部类：与成员内部类基本一致，作用域不同
                    3.2.1 局部内部类不允许使用访问权限修饰符：public  private   protected  
                    3.2.2 局部内部类对外完全隐蔽，只有创建这个类的方法可以访问
                    3.2.3 局部内部类要想使用方法形参，该形参必须使用final声明

4. 匿名内部类

            4.1 定义：一个没有名字的方法内部类
            4.2 约束
                      4.2.1 符合方法内部类的所有约束
                      4.2.2 匿名内部类没有访问修饰符
                      4.2.3 匿名内部类必须继承一个抽象类或者实现一个接口
                      4.2.4 匿名内部类中不能存在任何静态成员或方法
                      4.2.5 匿名内部类没有构造方法（因为没有类名）
                      4.2.6 匿名内部类可以引用方法形参，形参声明为final

package com.wl;

//匿名内部类
interface MyInterface{//定义接口
    void test();
}
class Outter3{
    private int num;
    public void display(int para){
        //匿名内部类实现MyInterface接口
        new MyInterface(){
            @Override
            public void test(){
                System.out.println("匿名内部类 "+para);
            }
        }.test();
    }
}

public class Test {
    public static void main(String[] args) {

        //匿名内部类：一个没有名字的方法内部类，符合方法内部类的所有约束条件
        Outter3 out = new Outter3();
        out.display(35);


    }
}

代码运行结果：