内部类

1.了解什么是内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类就是外部类了

2.成员内部类

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );如创建Inner的内部类对象：要先创建外部类对象：Outer o = new outer(); 创建内部类：Inner i = o.new Inner();访问Inner中的test()方法：i.in();

第一种写法

package com.company;

import java.sql.SQLOutput;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

public class Main{

    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.new Inner();
        inner.In();
        inner.getId();
    }
}
class Out{
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法！！！");
    }
    class Inner{
        public void In(){
            System.out.println("这是内部类的方法！！！");
        }
        //获得外部类私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

第二种写法

package com.company;

import java.sql.SQLOutput;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

public class Main{
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法！！！");
    }
    class Inner{
        int id=100;
        public void In(){
            System.out.println("这是内部类的方法！！！");
            System.out.println("外部类id为："+Main.this.id);
            System.out.println("内部类id为："+id);
        }
        //获得外部类私有属性
        public void getId(){
            System.out.println(id);
        }
    }
    public static void main(String[] args) {
        Main m = new Main();
        Main.Inner inner = m.new Inner();
        inner.In();
        inner.getId();
    }
}

3.静态内部类

静态内部类就是用static修饰的内部类，这种内部类的特点是：

1、静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员的方式访问；

2、如果外部类的静态成员与内部类的静态成员相同， 可以通过"类名.静态成员"来访问外部类的静态成员；如果不同，可以直接调用外部类的静态成员名。

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建；

如果1的代码中内部类写成public static class Inner是错误的，因为先实例化Inner，id还没实例化，可以把id设置成static

package com.company;

import java.sql.SQLOutput;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

public class Main{
    private static int id=10;
    String name="cc";
    public void out(){
        System.out.println("这是外部类的方法！！！");
    }
    public static class Inner{
        public void In(){
            System.out.println("这是内部类的方法！！！");
            //1.
            System.out.println(new Main().name);
            //2
            System.out.println(Main.id);
        }
        public void getId(){
            System.out.println(id);
        }

    }
    public static void main(String[] args) {
        //3.
        Inner in=new Inner();
        in.In();
        in.getId();

    }
}

4.局部/方法内部类

什么是局部内部类？

定义在方法中的内部类，方法内部类只在该方法内可以用，由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

注意：

1、内部类不能被public、private、static修饰；

2、在外部类中不能创建内部类的实例，因为局部内部类是定义在方法中的，而方法是需要所在类的对象去调用。

3、创建内部类的实例只能在包含他的方法中；

4、内部类访问包含他的方法中的变量必须有final修饰；

5、外部类不能访问局部内部类，只能在方法体中访问局部内部类，且访问必须在内部类定义之后。

在局部变量中声明为final就好了，这个原因是由于method方法调用完毕之后就从栈中弹出了，但是这个时候由于局部内部类中使用了这个方法中的局部变量，而这个类还是不会立即回收的，所以只能将局部变量声明为final，表示常量。

package com.company;

import java.sql.SQLOutput;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

public class Main{
    public void method(){
        //局部内部类
        final int age=20;
        class Inner{
            public void in(){
                System.out.println("内部类！！！");
                System.out.println("年龄="+age);
            }
        }
        new Inner().in();
    }
    public static void main(String[] args) {
        Main main = new Main();
        main.method();
    }
}

5.匿名内部类

package com.company;

import java.sql.SQLOutput;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.net.URL;
import java.util.concurrent.*;

public class Main{

    public static void main(String[] args) {
        
        //没有名字的初始化类，不用将实例保存到变量中
      new A().eat();
      new B(){
          @Override
          public void eat() {
              System.out.println("b");
          }
      }.eat();

    }
}
class A{
    public void eat(){
        System.out.println("1");
    }
}
interface B{
    public void eat();
}