内部类

内部类

把类定义在其他类的内部，这个类就被称为内部类。

内部类可以直接访问外部类的成员，

内部类编译生成的.class文件是Outer$Inner.class

内部类具有延迟加载的功能

成员内部类

在类的成员位置的内部类，就是成员内部类

访问

public class InnerClassDome {
    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner();        //不需要导包直接使用
        i.show();
        Inner i2 = new Outer().new Inner();             //需要导包import com.leex.interClass.Outer.Inner;
        Inner i3 = new Outer().getInner();              //如果Inner是私有的类，private class Innter{}
        Outer.Inner i4 = new Outer().getInner();
    }
}
class Outer {
    private int num = 10;
    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public Inner getInner() {       //这样写还可以给访问加限制,并用private修饰Inner,提高内部类的安全性
        return new Inner();
    }
}

普通的类只能被public和默认修饰，内部类可以被public，protected，默认，private

静态内部类

静态内部类可以理解成外部类的静态成员

1. 普通的类不能被static修饰，而内部类可以
2. 静态内部类只能访问外部内的静态属性，不能访问非静态的属性数

访问

成员内部类被静态修饰后的访问

public class InnerClassDome2 {
    public static void main(String[] args) {
        Outer2.Inner i = new Outer2.Inner();
        Inner i1 = new Inner();         //要导包，一般不这样写，代码可读性差
        
    }
}
class Outer2 {
    private static int num = 10;
    static class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public Inner getInner() {       //同样可以用方法访问，但是失去了static的意义
        return new Inner();
    }
}

内部类为了方便访问加static，为了安全加private

注意

内部类和外部类没有继承关系

/*
面试题：
    要求请填空分别输出30，20，10。
    
注意：
    1:内部类和外部类没有继承关系。
    2:通过外部类名限定this对象
        Outer.this
*/
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //System.out.println()
            //System.out.println(new Outer().num); //也可以
            System.out.println(Outer.this.num);
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }   
}

局部内部类

1.7之前只能访问final修饰的局部变量

1.8之后可以访问非final修饰的局部变量

public class InnerClassDome2 {
    public static void main(String[] args) {
        new Outer2().mothed();
    }
}
class Outer2 {
    private int num = 10;
    public void mothed() {
        class Inner {
            private int num2 = 20;
            public void show() {
                System.out.println(num);        //10
                System.out.println(num2);       //20
            }
        }
        Inner i = new Inner();
        i.show();
    }
}

匿名内部类

1. 匿名内部类
   • 就是内部类的简化写法。
2. 前提：存在一个类或者接口
   • 这里的类可以是具体类也可以是抽象类。
3. 本质是一个继承了该类或者实现了该接口的子类匿名对象。

---

class Outer2 {
    Inner3 i3 = new Inner3() {                      //在外部类的成员位置，必须要有变量接收对象（多态）
        @Override
        public void show() {
            System.out.println("Inner3");
        }
    };
    public void mothed() {
        new Inner() {                               //在局部位置，可以接收也可以接收
            @Override
            public void show() {
                System.out.println("Inner");
            }
        }.show();                                   //直接调用方法，只能用一次
        Inner2 i = new Inner2() {                   //多态
            @Override
            public void show() {
                System.out.println("Inner2");
            }
        };
        i.show();                                   //获取后调用
        i3.show();
    }
}
interface Inner{
    public void show();
}
abstract class Inner2{
    public abstract void show();
}
abstract class Inner3{
    public abstract void show();
}

应用

当一个方法的形参是一个接口或抽象类时，传入的应该是一个该接口或抽象类的具体子类的对象，所以可以使用匿名内部类

/*
匿名内部类在开发中的使用
*/
interface Person {
    public abstract void study();
}

class PersonDemo {
    //接口名作为形式参数
    //其实这里需要的不是接口，而是该接口的实现类的对象
    public void method(Person p) {
        p.study();
    }
}

//实现类
class Student implements Person {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}

class InnerClassTest2 {
    public static void main(String[] args) {
        //测试
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
        System.out.println("--------------------");
        
        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
        pd.method(new Person(){
            public void study() {
                System.out.println("好好学习,天天向上");
            }
        });
    }
}