内部什么 什么内部 内什么类

这回不放点代码不成了！

先说说啥是内部类

class A{ //外部类
    class B{  //内部类，只为A服务
    }
}

特点：

1.内部类可以直接访问外部类的成员，包括私有成员

2.外部类要访问内部类的成员，必须要建立内部类的对象

3.内部类不为同⼀包的其他类所⻅，具有很好的封装性

4.内部类有效实现了“多重继承”，优化 java 单继承的缺陷

5.在成员位置的内部类是成员内部类

6.局部位置的就是局部内部类

内部类入门

/**
 * @author czy
 * @date 2021/11/03
 **/
public class Test {
    public static void main(String[] args) {
        //3.创建内部类对象，使用内部类的资源
        /*外部类名.内部类名 对象名=外部类对象.内部类对象*/
        A.B ab=new A().new B();
        ab.delete();
        System.out.println(ab.sum);
        //4.调用外部类的方法--创建一个外部类的匿名对象，只使用一次
        new A().find();
    }
}
//1.创建外部类
class A{
    //1.1创建外部类的成员变量
    String name;
    private int age;
    //1.2创建外部类的成员方法
    public void find(){
        System.out.println("A...find()");
    }
    //创建内部类
    class B{
        //2.1定义内部类的成员变量
        int sum=10;
        //2.2定义内部类的成员方法
        public void delete(){
            System.out.println("B...delete()");
            //5.测试内部类是否可以使用外部类的资源
            /*结论：内部类可以直接使用外部类的资源，私有资源也可以*/
            System.out.println(name);
            System.out.println(age);
            /*注意：此处测试完毕需要注释掉，否则来回调用
             * 会抛出异常StackOverFlowException栈溢出异常*/
            //find();
        }
    }
}

得到结果：

B...delete()
null
0
10
A...find()

 成员内部类

1.当成员内部类被private修饰后无法被外界直接使用，咋整？那就间接访问呗

public class Test2 {
    public static void main(String[] args) {
        //创建外部类对象，间接访问私有内部类资源
        new C().getD();
    }
}
class C{
    public void getD(){
        D d=new D();   //外部类可以访问内部类的私有资源
        d.dede();
    }
    //创建成员内部类，位置：类里方法外
    /*被private修饰私有化后无法被外界访问*/
    private class D{
        public void dede(){
            System.out.println("D你个dede");
        }
    }
}

2.当内部类被static修饰时，不需要创建对象，可以通过类名直接访问。访问类中的静态资源可以通过"..."链式加载

静态内部类可以访问外部类所有的静态变量，⽽不可访问外部类的⾮静态变量

public class Test3 {
    public static void main(String[] args) {
        //通过外部类的类名创建内部类对象
        C.D cd=new C.D();
        cd.dede();
        //匿名的内部类对象调用dede
        new C.D().dede();
        //访问静态内部类中的静态资源--链式加载
        C.D.byby();
    }
}
class C{
    //创建成员内部类，位置：类里方法外
    /*被static修饰--并不常用，浪费内存*/
    static class D{
        //普通方法
        public void dede(){
            System.out.println("D你个dede");
        }
        //静态成员方法
        static public void byby(){
            System.out.println("D你个大byby");
        }
    }
}

局部内部类

public class Test4 {
    public static void main(String[] args) {
        //当在外部类方法中创建局部内部类对象并且进行功能调用后，内部类的功能才能被调用
        new C().moyu();
    }
}
class C{
    public void moyu(){
        //创建局部内部类--不太常用  位置：方法里
        class D{
            String name;
            int age;
            public void maopao(){
                System.out.println("我在局部内部类maopao（）");
            }
        }
        //在方法里创建内部类对象
        D d=new D();
        d.maopao();
        System.out.println(d.name);
        System.out.println(d.age);
    }
}

匿名内部类

特点：

1.匿名内部类也就是没有名字的内部类，无class关键字，直接使用new来生成一个对象的引用正因为没有名字，所以匿名内部类只能使用一次

2.匿名内部类必须继承一个父类（抽象类，普通类）或实现一个接口(两者不可兼得，并且只能是一个)，它相当于一个具体类（只是没有名字），所以可以使用new

3.匿名内部类不能定义任何静态成员和静态⽅法

4.当所在的⽅法的形参需要被匿名内部类使⽤时，必须声明为 final，为了拷贝引用避免引用值发生改变

5.匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接⼝的所有抽象⽅法

/*匿名对象没有名字，通常与匿名对象结合在一起使用*/
public class Test5 {
    public static void main(String[] args) {
        //传统方式：创建接口的实现类+实现类实现接口中的抽象方法+创建实现类对象+通过对象调用方法
        //3.创建接口--对应的匿名对象与匿名内部类，并调用实现的方法eat()
        new A(){
            @Override
            public void eat() {
                System.out.println("真香");
            }
            @Override
            public void sleep() {
                System.out.println("回笼觉");
            }
        }.eat();
        //5.创建抽象类对应的匿名对象与匿名内部类
        new B(){
            @Override
            public void play() {
                super.play();
                System.out.println("dede");
            }
            @Override
            public void drink() {
                System.out.println("怕上火，喝那啥");
            }
        }.play();
        //7.创建匿名对象直接调用普通类的功能
        new C().dama();
        new C().dama();//new2次就是两个匿名对象
        /*如果想要多次使用实现后的功能，还是要创建普通的对象
         * 匿名对象只能使用一次，一次只能调用一个功能
         * 匿名内部类其实就充当了实现类的角色，去实现未实现的抽象方法，只是没有名字而已*/
        C c = new C();
        c.study();
        c.study();
        c.study();
        c.dama();
        c.dama();
    }
}
//1.创建接口
interface A{
    //2.定义接口中的抽象方法
    void eat();
    void sleep();
}
//4.创建抽象类
abstract class B{
    public void play(){
        System.out.println("就是玩儿");
    }
    abstract public void drink();
}
//6.创建普通类
class C{
    public void study(){
        System.out.println("热爱学习");
    }
    public void dama(){
        System.out.println("我爱敲代码");
    }
}

得出结果：

真香
就是玩儿
dede
我爱敲代码
我爱敲代码
热爱学习
热爱学习
热爱学习
我爱敲代码
我爱敲代码

今天  你类了吗？