内部类

概念

定义在其他类内部的类就称为内部类 (inner class)。
按照内部类在 类中 定义的 位置不同，可以分为如下两种：
1.成员位置(成员内部类)：类中方法体之外
2.局部位置(局部内部类)：方法体之中

内部类的访问特点

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

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

/**
 * @Author: zhuku
 * Date: 2020/3/17 21:14
 * project name: javaobject
 * @Version:
 * @Description:
 *
 * 内部类的访问特点：
 *         内部类可以直接访问外部类的成员，包括私有。
 *         外部类要访问内部类的成员，必须创建对象。
 *
 *         内部类的访问(外部类的外部)
 *         外部类名.内部类名 对象名 = 外部类对象.内部类对象
 */
public class Demo1 {
    public static void main(String[] args) {
        //在外部类的外部访问，访问内部类
        //外部类名.内部类名 对象名 = 外部类对象.内部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.testaccess();
    }

}

class Outer{

    private int i;
    private void outerMethod(){
        System.out.println(" private outer ");
    }
    /*
        在外部内中访问内部类中成员
        外部类要访问内部类的成员，必须创建对象
     */
    public void innerTest(){
        // 外部类要访问内部类的成员，必须创建对象。
        Inner inner = new Inner();
        // 可以通过对象直接访问，内部类的成员变量
        System.out.println(inner.innerValue);
        System.out.println(inner.privateInnerVale);
         可以通过对象直接访问，内部类的成员方法
        inner.testaccess();
    }

    class Inner{
        int innerValue = 1;
        private  int privateInnerVale = 1;
        //成员内部类：类中方法体之外
        //可以直接访问外部类的私有成员变量
        //可以直接访问外部类的私有成员方法
        public void testaccess(){
            System.out.println(i);
            outerMethod();
        }
    }
}

内部类的初始化

内部类的访问(外部类的外部)：
外部类名.内部类名 对象名 = 外部类对象.内部类对象
eg:Outer.Inner inner = new Outer().new Inner();
创建一个内部类对象，必须先有一个外部类对象？
1. 如果把成员位置内部类看成一个整体，成员位置内部类，就可以被看作是外部类的成员
2. 类中定义的普通成员，他们都依赖于对象而存在
3. 所以同理，我们的成员位置内部类，依赖于外部类对象而存在.
常见的内部类初始化

public class Demo2 {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        System.out.println(outer1.i);

        Outer1.Inner inner= new Outer1().new Inner();
        System.out.println(inner.j);

        Outer1.StaticInner staticInner = new Outer1.StaticInner();
        System.out.println(staticInner.k);
    }
}
class Outer1{
    int i;

    class Inner{
        int j;

        public void printInner(){
            System.out.println("inner print");
        }
    }
    static class StaticInner{
        int k;

        public void printInner(){
            System.out.println("static inner print");
        }
    }
}

匿名内部类对象

不管是成员或局部位置内部类，我们要使用内部类都分成了2步：
1，定义内部类,
2，创建内部类对象

通过定义匿名内部类对象，我们可以将上面的2步变为1步。

匿名内部类的前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。

匿名内部类对象：
new 类名或者接口名() {重写方法;}

本质：new了一个继承了类或者实现了接口的子类匿名对象

public class Demo3 {
    public static void main(String[] args) {
        Myinterface inter =new MyClass();
        inter.mytest();

        //与上述语句结果相同
        new Myinterface() {
            @Override
            public void mytest() {
                System.out.println("hello my class");
            }
        }.mytest();
 //==================================================
        //抽象类的匿名对象
        new NormalClass(){
            @Override
            void print() {
                System.out.println("hello");
            }
        }.print();

    }
}

//存在一个类或者接口
interface Myinterface{
    void mytest();
}

class MyClass implements Myinterface{
    @Override
    public void mytest() {
        System.out.println("hello my class");
    }
}


abstract class NormalClass{
    int i;
    int j;

    abstract void print();

    public void test(){
        System.out.println("hello");
    }

}

只使用某抽象类，或者接口子类对象一次的情况下使用。

课后习题

课后习题题目与答案