java 内部类

Java中静态内部类和非静态内部类有什么区别？

1、什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

• 成员内部类 ：定义在类中方法外的类。

定义格式：

class 外部类 {
    class 内部类{

    }
}

访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类或者其它类 要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

//外部类或者其它类中
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

//外部类中
内部类名 对象名 = new 内部类名();

// 外部类
public class Body {

    public void methodW1(){
        // 访问内部类的成员
        //Body.Heart bh = new Body().new Heart();
        Heart bh = new Heart();
        System.out.println(bh.numN);// 10
        bh.methodN1();// 内部类的成员方法 methodN1
    }

    // 成员变量
    private int numW = 100;

    // 成员方法
    private void methodW2(){
        System.out.println("外部类的成员方法 methodW2");
    }


    // 内部类
    public class Heart{
        // 成员变量
        int numN = 10;

        // 成员方法
        public void methodN1(){
            System.out.println("内部类的成员方法 methodN1");
        }

        public void methodN2(){
            // 访问外部类的成员
            System.out.println(numW);
            methodW2();
        }
    }


}

static内部类

static内部类是内部类中一个比较特殊的情况，Java文档中是这样描述static内部类的：一旦内部类使用static修饰，那么此时这个内部类就升级为顶级类。

也就是说，除了写在一个类的内部以外，static内部类具备所有外部类的特性

static内部类可以在内部定义static元素

与static内部类不同，内部接口自动具备静态属性。也就是说，普通类是可以直接实现内部接口的

匿名内部类

匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。

代码一：

abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头...");
    }
}
public class Test {
    public static void main(String[] args) {
        /*
            匿名内部类:
                概述:本质其实就是一个类的匿名子类的对象
                作用:就是用来简化代码的,没有其他的功能
                格式:
                    new 类名(父类)(){
                        实现抽象方法
                    };
         */
        // 需求:调用Animal类的eat方法
        // 1.创建一个子类继承Animal类
        // 2.在子类中重写eat抽象方法
        // 3.创建子类对象
        // 4.使用子类对象调用eat方法
        Dog d = new Dog();// 创建Animal子类对象
        d.eat();// d---->是Animal类的子类的对象
        // 问题:以上4步一步都不能少,有点麻烦,是否可以简化代码?
        // 解决:匿名内部类可以简化代码,因为它可以不创建子类的情况下,直接得到一个类的子类对象

        System.out.println("==========================");
        // 创建Animal子类对象<=====>Animal类的匿名内部类
        // 父类的引用指向子类的对象
        Animal anl = new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类");
            }
        };// 是Animal类的子类的对象
        anl.eat();
    }
}

代码二：

interface A{
    public abstract void show();
}
class Imp implements A{
    public void show(){
        System.out.println("实现类实现show方法");
    }
}
public class Test {
    public static void main(String[] args) {
        /*
            匿名内部类:
                概述:本质是一个接口的匿名实现类的对象
                格式:
                    new 接口名(){
                        实现抽象方法
                    };
         */
        // 需求:调用A接口的show方法
        // 1.创建实现类实现A接口
        // 2.在实现类中重写show方法
        // 3.创建实现类对象
        // 4.使用实现类对象调用show方法
        Imp imp = new Imp();// imp就是接口的实现类的对象
        imp.show();

        System.out.println("==============================");
        // 简化: 匿名内部类
        A a = new A() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        a.show();
    }
}