Java的四种内部类详解

N种内部类

1.什么是内部类？

• 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类。
• 他一共有以下几种：

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

2.成员内部类

• 咱们先看一下定义成员内部类的方式，代码如下：

public class Outer                   //外部类
{
    private int id;
    public void out()             
    {
        System.out.println("外部类");
    }

    public class Inter               //内部类
  {
     public void in()
        {
         System.out.println("内部类");
        }
  }
}

• 然后咱们编写了主程序，来看看成员内部类是怎么输出的，既然要调用方法，就得先把他new出来

外部类：Outer outer = new Outer();

内部类：Outer.Inner inner = outer.new Inner();

然后看一下代码

public class application {
    private static Object Outer;

    public static void main(String[] args) {
        Outer outer = new Outer();               //外部类实例化
        //通过这个外部类来实例化这个内部类
        Outer.Inner inner = outer.new Inner();    //内部类实例化
        inner.in();     //调用内部类的方法
    }
}
===========================================
    最终输出结果：
    内部类

咱们是通过这个外部类来实例化这个内部类的。

• 咱们也可以通过内部类访问外部类的私有变量,代码如下

• Outer类

public class Outer
{
    private int id=10;
    public void out()
    {
        System.out.println("外部类");
    }

    public class Inner
  {
     public void in()
        {
         System.out.println("内部类");
        }
        public void getID(){
            System.out.println(id);
        }

  }
}

• 主程序

public class application {
    private static Object Outer;

    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化这个内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();                        //调用内部类的方法，来访问外部类的私有变量
    }
}
======================================
    最终输出结果：
    10

内部类可以获得外部类的私有属性。

2.静态内部类

• 静态内部类和成员内部类区别就是，在内部类的public 的后面加一个static就行，代码如下

public class Outer
{
    private int id=10;
    public void out()
    {
        System.out.println("外部类");
    }

    public static class Inner           //加一个static就行
  {
     public void in()
        {
         System.out.println("内部类");
        }
  }
}

• 内部类中无法获得外部类的私有变量了，他会报错的。因为内部类是静态的，在外部类一加载的时候，静态的就同时加载完成，此时外部类的私有变量还没有加载，若想用内部类调用外部类的私有变量，那么也需要在私有变量中加一个static即可，代码如下；

public class Outer
{
    private static int id=10;            //私有变量中加上一个static
    public void out()
    {
        System.out.println("外部类");
    }

    public static class Inner
  {
     public void in()
        {
         System.out.println("内部类");
        }
     public void getID(){                  //这样内部类可以获得外部类的静态的私有变量
         System.out.println(id);
     }

  }
}

静态的内部类只能获得外部类的静态的私有变量

• 既然内部类变成了静态的，那么在主程序对他进行调用的时候，肯定会用不同的方法进行调用。咱们只是简单了解一下这个。

public class application {
    private static Object Outer;

    public static void main(String[] args) {
        Outer outer = new Outer();

    }
}

主程序的代码只能写成这个样子，无法实例化内部类了。

3.匿名内部类

public class Outer
{
    
}
//一个Java类中可以有多个class类，但是只能有一个public class 类
class A{
    
}
class B{
    
}

内部类是在public外面的，在一个大的Java类里面，只能有一个public class 类，但可以有多个class类名字。

• 咱们平时调用底下class中的方法的时候，咱们需要new这个类，代码如下：

public class testclass {
    public static void main(String[] args) {
        Apple apple = new Apple();        //咱们平时都是这个样子去调用下面类中的方法
        apple.eat();
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

同样，咱们看看匿名内部类是怎么调用底下的方法的，代码如下：

public class testclass {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存 到变量中。
   new Apple().eat();             //匿名内部类
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

没有名字初始化类，不用将实例保存到变量中。上面就是匿名内部类，因为你不知道这个new的对象的名字，但是把他里面的方法进行调用了。

4.局部内部类

• 咱们看一下他的格式

public class Outer
{
public void run(){
    class inner {       // 这个就是局部内部类，是包含在方法里面的类。
      
    }
  }
}

同样的是，也可以在局部内部类里面写一些方法。