java之匿名对象，成员内部类，局部类部类，匿名内部类

整体分析如下：

匿名对象大致内存空间：

下面说一下成员内部类的用法：

先看一个inner.java：

package innner;

public class Inner1 {
    int age = 25;
    String name = "孙悟空";
    String skill = "我能吹牛逼";


    public Inner1() {
    }

    public Inner1(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //成员内部类，此类是default属性，在同一个包中能被继承与访问，挎包之后不能被继承，也不能被访问
    class Son{
        int age = 1;
        String name = "猪八戒";


        public Son() {
        }

        public Son(int age, String name) {
            this.age = age;
            this.name = name;
        }

        //成员内部类访问内部成员
        void sayOut() {
            System.out.println(name);//就近原则，存在同名成员，优先访问内部类的
            System.out.println(Inner1.this.name);//存在同名成员时这样访问
            System.out.println(skill);//不同名，直接可以调用内部类成员
            System.out.println(Inner1.this.skill);//这样访问也可以
        }

    }
}

 在来一个她的获取文件InnerGet.java:

package innner;

public class InnerGet {
    public static void main(String[] args) {
        //成员内部类的获取方式
        Inner1.Son son = new Inner1().new Son();
        son.sayOut();
    }
}

运行结果：

成员内部类独特的一点说明：

当内部类成员存在静态成员的时候，该内部类也要用static修饰：

上面就是age用static修饰了，它的外部类也要用static修饰,后面再说原因，这个时候如内部类设置成了static，那么我们里面的函数，就不能访问非静态成员，不能有this。

上面就会报错，因为你加了this,还访问了外部类的一个成员skill,为什么skill访问也出错，因为你整个类是先于外部类存在的。

代码修改：

 这个时候，访问内部类数据是可以的。那么我们如何去访问静态变量age:

上面就能打印出结果，那么现在就来说一下，为什么当成员内部类出现一个静态成员时候，该类也要用静态修饰的原因：

首先age可以是Son.age访问，那么Son就必须Inner.Son访问。Son不设置成静态，Inner怎么通过类名访问Son,所以，通过访问方式也要知道它必须被设置成静态的原因。

 局部内部类就不多了，去参考我java第一篇中就可以了。注意一点就是一旦类去访问了函数的局部变量，这个变量就必须被final修饰，表明它的生命周期被延长了。

下面说一下匿名内部类：

可以有名字也可以没名字

前提：必须存在继承与实现的关系

那我们来看一个接口：

FunctionInterface1.java:

@FunctionalInterface
public interface FunctionInterface1 {
    void say();
}

然后我们用这个来实例一下匿名内部类的用法：Simple1.java:

public class Simple1 {
    public static void main(String[] args) {

        String str1 = "i";
        String str2 = "love";
        String str3 = "you";

        //做一个匿名内部类
        new FunctionInterface1(){
            @Override
            public void say() {
                System.out.println("这是一个说话的方法");
                System.out.println(str1 + str2 + str3);//可以调用函数定义的变量
            }
        }.say();

        FunctionInterface1 fi = new FunctionInterface1(){
            @Override
            public void say() {
                System.out.println("这是另外一个可以说话的方法");
            }
        };

        fi.say();

        //匿名内部类
        printStr(new FunctionInterface1() {
            @Override
            public void say() {
                System.out.println(str1 + " " + str2 + " " + str3);
            }
        });

    }

    //将匿名内部类用作函数参数来表示
    public static void printStr(FunctionInterface1 fi) {
        fi.say();
    }

}

测试结果：

好了，就说到这。