什么是内部类：

内部类就是定义在一个类内部的类，我们分为四种：成员内部类，静态内部类，方法内部类，匿名内部类

为什么用内部类？

内部类的好处是：每个内部类都可以独立的继承或者访问接口，与外部类完全不管

 

成员内部类：

package lei;
//成员内部类
public class ChengYuan {
    public class InnerChengYuan{
        
    }
}

成员内部类的应用：

package lei;
//成员内部类
// 成员内部类是依附外部类的，只有创建了外部类才能创建内部类
public class ChengYuan {
    //定义外部类非静态变量，想要通过内部类访问到，代码19-20行
    String Outinner="out inner";
    public static void main(String[] args) {
        // 成员内部类 ：新建内部类的对象
        ChengYuan.InnerChengYuan inner=new ChengYuan().new InnerChengYuan();
        // 成员内部类： 访问成员内部类的方法，通过新建的内部类对象.的形式来访问内部类方法
        inner.show();
        // 成员内部类：通过创建内部类对象，然后通过对象.的方式来访问内部类属性
        System.out.println(inner.name);

    }
    public class InnerChengYuan{
        String name="3";
        public void show(){
            //方法访问内部类成员变量
            System.out.println(name);
            //访问外部类成员变量，先new一个外部类对象，通过外部类对象能够访问到外部类成员变量
            ChengYuan cy=new ChengYuan();
            System.out.println(cy.Outinner);
        }
    }
}

静态内部类：

由static关键字修饰的内部类，

静态内部类不需要依靠外部类便可以创建(static关键字)，并且静态内部类不能访问外部类的非静态的属性和方法，但可以拥有自己的成员变量。

package neibulei;

public class OutStatic {
    //静态内部类
    public static class InnerStatic{
        
    }
}

静态内部类的访问方式

package neibulei;

public class OutStatic {
    //创建外部类的静态成员变量 代码18行
    static int c=3;
    //静态内部类
    public static class InnerStatic{
        //创建内部类静态对象    代码：6，10行引用
        static int a=1;
        //静态内部类非静态对象 代码13行
        int b=2;
        public  void show(){
            //静态内部类可以直接访问到内部类的静态成员变量
            System.out.println(a);
            //静态内部类方法可以直接访问到内部类非静态成员变量
            System.out.println(b);
            //静态内部类可以直接访问到非静态外部类的静态变量
            System.out.println(c);
        }
    }

    public static void main(String[] args) {
        //访问静态内部类的方法：可以直接创建内部类对象，然后对象.的形式来进行调用
        InnerStatic innerStatic =new InnerStatic();
        innerStatic.show();
        //访问静态内部类的方法：因为是static 所以可以和静态常量一样可以用类名.的方式来进行访问
        //这里OutStatic.innerStatic()；是通过外部类.的方式访问内部类 然后创建对象。
        OutStatic.InnerStatic i=new OutStatic.InnerStatic();
        i.show();
    }
}

方法内部类

方法内部类就是直接在类中的方法定义一个类，这个类伴随着方法生存，方法在，这个类就在，方法消失，这个类也就消失

package fangfaClass;

public class MethodOut {
    //外部类方法
    public void method(){
        //方法中写一个类：叫做方法内部类，这个类伴随着方法存在，方法在类就在
        class MethodInner{
            public void show(){
                System.out.println("方法内部类");
            }
        }
        //因为类存在方法中，所以只能在方法中访问
        MethodInner m=new MethodInner();
        m.show();
    }
}

匿名内部类：

匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，匿名内部类的特点：
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名，因此没有构造方法。

 

先写一个抽象类：

package ni;

public abstract class Abstract {
    abstract void show();
}

使用匿名内部类继承这个抽象类

package ni;
interface Myinterface{
    public void show();
}

public class NiClass {

    //相当于子类继承了这个抽象类，然后对抽象类的抽象方法进行重写，这种情况叫匿名内部类
    Abstract a=new Abstract() {
        @Override
        void show() {

        }
    };
    //===========================
    //想当于调用子类调用了Myinterface的接口，然后进行重写方法。
    Myinterface mi=new Myinterface() {
        @Override
        public void show() {
            
        }
    }
}