IDEA入门实录——内部类

1.类的组成：属性，方法，构造器，代码块（普通块，构造块，静态块，同步块），内部类

2.内部类：成员内部类（静态的和非静态的）和局部内部类（位置：方法内，块内，构造器内）

3.一个类Outer的内部的类SubTest叫内部类 内部类：SubTest 外部类：Outer

4.成员内部类，

里面属性，方法，构造器等

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

5.内部类可以访问外部类的内容

6.静态内部类中只能访问外部类中被static修饰的内容

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

8.内部类和外部类属性重名的时候如何进行调用

创建内部类对象

class Demo {
public static void main(String[] args) {
//创建外部类的对象
TestOuter t = new TestOuter();
t.a();
//创建内部类的对象
//静态内部类创建对象
TestOuter.E e = new TestOuter.E();
//非静态的内部类创建对象
TestOuter t1 = new TestOuter();
TestOuter.D d = t1.new D();
}
}

完整代码：

package com.msb.test07;

public class TestOuter {
    class D{
        int age = 20;
        String name;
        public void method(){
            /*System.out.println(age);//内部类可以访问外部类的内容
            a();*/
            int age = 30;
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age );//10
        }
    }
    static class E{
        public void method(){
        //静态内部类中只能访问外部类中被static修饰的内容
            System.out.println(age);
        }
    }
    static int age = 10;
    public void a(){
        System.out.println("a");
        {
            System.out.println("这是一个普通块");
            class B{}
        }
        class A{}
        D d = new D();
        System.out.println(d.name);
        d.method();
    }
    static {
        System.out.println("这是一个静态块");
    }
    {
        System.out.println("这是一个构造块");
        class C{}
    }
    public TestOuter() {
    }

    public TestOuter(int age) {
        this.age = age;
    }

}
class Demo {
    public static void main(String[] args) {
        //创建外部类的对象
        TestOuter t = new TestOuter();
        t.a();
        //创建内部类的对象
        //静态内部类创建对象
        TestOuter.E e = new TestOuter.E();
        //非静态的内部类创建对象
        TestOuter t1 = new TestOuter();
        TestOuter.D d = t1.new D();
    }
}

9.在局部内部类中访问到的变量必须是final修饰的

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

package com.msb.test08;

public class Testouter {
    public void method(){
        final int num = 10;
        class A{
           public void  a(){

               System.out.println(num);
           }
        }
    }
    public Comparable method2(){
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new B();

    }
    public Comparable method3(){
        //匿名内部类，没有名字，直接通过这个接口创建这个类的对象，直接用接口接受
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
    public void teat(){
        Comparable com = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
        com.compareTo("abc");
    }
}