Java内部类深入讲解

我就是我 2021-12-04 08:05 349阅读 0赞

### 文章目录 ###

*  内部类
 *   *  一、定义
     *  二、优缺点
     *  三、内部类与外部类的关系
     *  四、创建内部类的语法（在外部类中）
     *   *  1.创建非静态内部类
         *  2.创建静态内部类
     *  五、内部类的分类
     *   *  1.成员内部类
         *  2.静态内部类
         *  3.方法内部类
         *  4.匿名内部类

# 内部类 #

## 一、定义 ##

在一个类中进行其它类结构的嵌套。

## 二、优缺点 ##

> **优点**  
> 1）内部类与外部类可以互相访问彼此的私有域；  
> 2）内部类可以实现Java的单继承局限；  
> 3）内部类可以对同一包中的其他类隐藏起来，仅供外部类使用。  
> **缺点**  
> 结构复杂

## 三、内部类与外部类的关系 ##

> 1.对于非静态内部类而言，内部类的创建需要依赖外部类的实例化对象，在没有外部类对象之前是无法创建内部类对象的；  
> 2.内部类是一个相对独立的个体，与外部类不是继承关系；  
> 3.内部类可以直接访问外部类的元素（包括私有域），但是外部类不可以直接访问内部类的元素，要通过内部类的引用间接访问。

## 四、创建内部类的语法（在外部类中） ##

### 1.创建非静态内部类 ###

Outter.Inner in = new Outter().new Inner();

### 2.创建静态内部类 ###

Outter.Inner in = new Outter.Inner();

## 五、内部类的分类 ##

### 1.成员内部类 ###

> 1）成员内部类中不能存在任何static变量或方法，可以访问外部类的静态域；  
> 2）成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类；  
> 3）成员内部类内部类可以使用private封装，表示私有内部类，该内部类仅供外部类使用。（HashMap中的Entry内部类，ArrayList中的Node内部类）

### 2.静态内部类 ###

> 1）静态内部类的创建不需要外部类，可以直接创建；  
> 2）静态内部类不可以访问外部类的任何非static域；

class Outer{                                  //外部类
        private static String msg = "hello";
        static class Inner{                       //静态内部类
            public void print() { 
                System.out.println(msg);
            }
        }
    }
    public class test{ 
    public static void main(String[]args){ 
        Outer.Inner inner = new Outer.Inner();    //创建静态内部类
        inner.print();
        }
    }

### 3.方法内部类 ###

> 1）方法内部类不能使用任何访问权限修饰符；  
> 2）方法内部类对外（方法外）完全隐藏，除了该方法可以访问它之外，其余地方均不能访问；  
> 3）方法内部类要想使用方法形参，该形参必须使用final声明（JDK8变为隐式final声明）。

class Outer{ 
        private int num ;
        public void display(int test){ 
            class Inner{ 
                public void fun(){ 
                    num++;
                    System.out.println(num);
                    System.out.println(test);
                }
            }
            Inner in = new Inner();
            in.fun();
        }
    }
    public class test{ 
    public static void main(String[]args){ 
        Outer outer = new Outer();
        outer.display(20);
        }
    }

### 4.匿名内部类 ###

> 1）匿名内部类必须继承一个抽象类或实现一个接口；  
> 2）匿名内部类没有构造方法，因为它没有类名；  
> 3）匿名内部类是没有访问修饰符的；  
> 4）匿名内部类中不能存在任何静态成员或方法；  
> 5） 与方法内部类相同匿名内部类也可以引用方法形参，此形参也必须声明为 final。

interface IInterface{ 
        void fun();
    }
    class Outer{ 
        private int num;
        public void display(int para) { 
            new IInterface(){ 
                @Override
                public void fun() { 
                    System.out.println("para = " + para);
                }
            }.fun();
        }
    }
    public class test{ 
    public static void main(String[]args){ 
        Outer outer = new Outer();
        outer.display(20);
        }
    }

--------------------

**注意**  
四种内部类都不能拥有static变量或方法  
成员内部类可以访问外部类的静态域  
静态内部类不可访问外部类的任何非static域  
方法内部类和匿名内部类都不能使用任何访问权限修饰符