内部类相关——定义、匿名内部类、回调实现及静态内部类

内部类，顾名思义就是在一个类中的类。内部类可以访问所在类的数据，包括私有数据，而又可以对其他类隐藏，在快速实现回调函数时可以使用匿名内部类，比较便捷。

1、以下为一个简单的内部类例子，内部类可以定义为私有以对其他类隐藏起来；可以用内部类来达到实现多继承的效果。需要注意的是，通过成员函数传入内部类的变量必须定义为final类型，以保证数据的一致性。

public class Cat extends Walk{
    //private私有类，继承Walk和Eat
    private class LittleCat extends Eat {
        public void doSomething() {
            System.out.println("Walking....Eating....");
        }
    }

    public static void main(String[] args) {
        LittleCat lCat = new Cat().new LittleCat();//创建内部类对象方式，通过先创建所在外围类对象再创建内部类对象
        lCat.doSomething();
    }

    public void event(final String name) {
        class EatFish{
            public void eat() {
                //name = "Tom";//在这里修改会报错，name 必须为final类型，保证数据一致
                System.out.println(name);
            }
        }
        EatFish test = new EatFish();
        test.eat();
    }
}

两个父类：

public class Walk {
}

public class Eat {
}

2、匿名内部类
从名称可以知道匿名就是没有类名的类，匿名内部类用于快速调用接口或抽象类等等中的方法，不需要多写一个实现类来实现调用。

抽象类

public abstract class Dog {
    abstract void eat();
}

接口

public interface Animal {
    void eat();
}

测试类

public class AnonymousDemo {

    public static void main(String[] args) {

        /**
         * 通过创建的一个接口或抽象类分引用，快速便捷重写需要实现的方法，不需要先写一个实现类再实例化以调用方法
         */

        //实现接口方式
        Animal dog = new Animal() {
            @Override
            public void eat() {
                System.out.println("like bone.");
            }
        };
        dog.eat();//向上转型的实例，直接调用重写的eat方法

        //继承抽象类的方式
        Dog littleDog = new Dog() {
            @Override
            void eat() {
                System.out.println("I like bone.");
            }
        };
        littleDog.eat();
    }
}

此外，Java的回调函数式可以通过匿名内部类来实现，比如以下例子

(1)封装的类和提供的接口
封装给别人调用的类

public class Person {

    private EatFood eatFood;

    /**
     * 普通方式，构造传递引用
     */
    public Person(EatFood eatSomething){
        this.eatFood = eatSomething;//构造时传入引用
    }


    /**
     * 普通方式，成员函数传递引用
     */
    public Person(){
    }
    public void setCallBack(EatFood eatSomething) {
        this.eatFood = eatSomething;//用成员函数传入引用
    }

    //需要调用的方法
    public void eatFood() {
        eatFood.eat();
    }
}

调用类需要的接口定义

public interface EatFood {
    void eat();
}

(2)实际调用
一般做法都会写一个类实现接口

public class EatRice implements EatFood {
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("It's time to eat rice.");
    }
}

然后是实际使用的类

public class PeronEatTest {
    public static void main(String[] args) {
        //普通方式，构造传递引用
        Person personOne = new Person(new EatRice());//EatRice实现类方式。多写一个方法传入也可
        personOne.eatFood();

        //普通方式，成员函数传递引用
        Person personOne = new Person();
        EatRice eatRice = new EatRice();
        personOne.setCallBack(eatRice);
        personOne.eatFood();
}

如果使用匿名内部类就便捷了许多

public class PeronEatTest {
    public static void main(String[] args) {    
        Person personTwo = new Person(new EatFood() {
            @Override
            public void eat() {
                // TODO Auto-generated method stub
                System.out.println("It's time to eat rice.");
            }
        });
        personTwo.eatFood();
    }
}

3、静态内部类
创建是不需要依赖于外围类，但也不能使用任何外围类的非static成员变量和方法

public class Cat{

    private String str = "cat";
    private static String str_static = "cat";

    private class LittleCat{
        //public static String str_test = "test";//错误，非静态内部类变量不能为静态
        public static final String str_test = "test";//但加上final就可以
        public void doSomething() {
            str = "little cat";
            System.out.println("Walking....Eating....");
        }
    }

    static class BigCat{
        public void doSomething() {
            //str = "little cat";//错误，静态内部类反问外围非静态变量和方法
            str_static = "big cat";
            System.out.println("I am a big cat.");
        }
    }

    public static void main(String[] args) {
        LittleCat lCat = new Cat().new LittleCat();//依赖外围类
        lCat.doSomething();

        BigCat bigCat = new BigCat();//不依赖外围类
        bigCat.doSomething();
    }