内部类（成员、局部）

一、类的基本内容

1、类的组成：

        属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类

2、内部类基础

        一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest 外部类：TestOuter

二、成员内部类（静态的、非静态的）

1、包含内容

        属性，方法，构造器等

        修饰符：private，default，protect，public，final,abstract

（1）内部类可以访问外部类的内容：

（2）静态内部类中只能访问外部类中被static修饰的内容

（3）外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用

（4）内部类和外部内类属性重名的时候，如何进行调用：

        使用this对抗就近原则

（5）创建内部类的对象

        注意：静态 非静态   两者创建方法不同

2、整体内容代码：

package com.msb.test07;


/**
 1.类的组成：属性，方法，构造器，代码块（普通块，静态类，构造块，同步块），内部类
 2.一个类TestOuter的内部的类SubTest叫内部类，内部类：SubTest  外部类：TestOuter
 3.内部类：成员内部类你 和   局部内部类（位置：方法内，块内，构造器内）
 4.成员内部类：
                里面属性，方法、构造器等
                修饰符：private,default,protect,public,final,abstract
 */
public class TestOuter {
    //成员内部类：
    public class D{
        int age = 20;
        String name;
        public void method(){
            //5.内部类可以访问外部类的内容
           /* System.out.println(age);
            a();
            */
           int age = 30;
           //8.内部类和外部内类属性重名的时候，如何进行调用：
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//10
        }
    }

    //静态成员内部类：
    static class E{
        public void method(){
            //6.静态内部类中只能访问外部类中被static修饰的内容

        }
    }
    //属性：
    int age = 10;
    //方法：
    public void a(){
        System.out.println("这是A方法");
        {
            System.out.println("这是一个普通块");
            class  b{

            }
        }
        class A{

        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d  = new D();
        System.out.println(d.name);
        d.method();
    }
    static {
        System.out.println("这是一个静态块");
    }
    {
        System.out.println("这是一个构造块");
    }
    //构造器：
    public TestOuter(){
        class C{

        }
    }

    public TestOuter(int age) {
        this.age = age;
    }
}
class Demo{
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();

        //创建内部类的对象：
        //静态成员内部类创建对象；
        TestOuter.E e = new TestOuter.E();
        //非静态的成员内部类创建对象
       //错误； TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d =  t.new D();
    }
}

三、局部成员类

1、包含内容

（1）在局部内部类中访问到的变量必须是被final修饰的

（2）如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了

（3）匿名内部类

        直接返回接口，省时高效

2、整体内容代码：

package com.msb.test08;

/**
 * @Auther: Mujy
 * @Date: 2022/09/19 - 09 - 19 - 20:46
 */
public class TestOuter {
    public void method() {
        //1.在局部内部类中访问到的变量必须是被final修饰的
         final int num = 6660;
        class A {
            public void a() {
                //num = 20;
                System.out.println(num);
            }
        }
        System.out.println(num);
    }


    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    public Comparable method2() {
        class B implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }

    public Comparable method3(){
        //3.匿名内部类
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void teat(){
       Comparable com =  new Comparable() {

            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };

        System.out.println(com.compareTo("abc"));
    }
}
class Demo{
    public static void main(String[] args) {
        TestOuter to = new TestOuter();
        to.method();
    }

}

四、类与对象结束

                希望大家都能掌握这些基础，无论考研还是参加工作，我们都有光明的未来！