内部类小结

         最近看了一点内部类，进行一次小结，与各位道友论道，内部类，顾名思义：类中有类。好了，废话不多说，直接开始：

         首先，我所关心的是内部类的权限有没有限制：

package com.Jevin.innerClass.demo07;

/**
 * 在一个内部类中是可以用public，protected，default，private
 * 四种权限修饰符的
 */
public class Animal {

    public class Dog{}

    class Cat{}

    private class Pig{}

    protected class Mouse{}

}

        所幸，内部类没有权限限制，四种权限修饰符都可以修饰。

          第二件事，我所关心的是：内部类对外部类成员的访问限制，包括静态的和非静态的，当然，内部类也分为静态的和非静态的：

package com.Jevin.innerClass.demo07;

public class School {

    private String name;
    public static int age;


    private String getName(){
        return name;
    }
    public static int getAge(){
        return age;
    }


    /**
     * 在非静态内部类中可以访问外部类的所有成员，
     * 包括静态成员和非静态成员
     */
    class Student{
        String a=name;
        int b=age;

        String c=getName();
        int d=getAge();

        //如果想要在内部类中获取外部类的对象，可以通过".this"获取
        public School school(){
            return School.this;
        }
    }

    /**
     * 在静态内部类中只能访问外部类的静态成员
     */
    static class Teacher{
        //String aa=name; //报错
        int bb=age;

        //String cc=getName(); //报错
        int dd=getAge();
    }

    /**
     * 在外部类的非静态方法中可以直接创建静态内部类和非静态内部类的对象；
     */
    public void mainOne(){
        //创建Student对象：
        Student s=new Student();

        //创建Teacher对象：
        Teacher t=new Teacher();
    }

    /**
     * 而在外部类的静态方法中是可以直接创建静态内部类对象的，
     * 但是如果想要创建非静态内部类对象需要一个外部类的对象的引用，然后通过".new"的方式创建
     * @param args
     */
    public static void mian(String[] args){
        //创建Student对象：
        School school=new School();
        Student student=school.new Student();

        //创建Teacher对象：
        Teacher teacher=new Teacher();
    }

}

        但是在另外一个方法中的main方法中，创建对象又有所区别的：

package com.Jevin.innerClass.demo07;

public class Test {
    public static void main(String[] args) {
        //创建Student对象：
        School school=new School();
        School.Student student=school.new Student();

        //创建Teacher对象：
        School.Teacher teacher=new School.Teacher();
    }
}

        那么另外一个对立的问题就出现了，在外部类访问内部类的成员可以吗？亲测不可以，这里就不上代码了。

       最后一个有意思的问题，匿名内部类：

package com.Jevin.innerClass.demo07;

public interface Contents {
    int value();
}

package com.Jevin.innerClass.demo07;

/**
 * 匿名内部类：在返回对象中插入了一个类的成员的定义；
 */
public class Jevin {
    public Contents contents(){
        return new Contents(){
            private int i=11;
            @Override
            public int value() {
                return i;
            }
        };
    }

    public static void main(String[] args){
        Jevin jevin=new Jevin();
        Contents contents=jevin.contents();
    }
}

        是不是很难理解，确实如此，它可以等效为：

 

package com.Jevin.innerClass.demo07;

public class Jevin {

    class MyContents implements Contents{

        private int i=11;

        @Override
        public int value() {
            return i;
        }
    }

    public Contents contents(){
        return new MyContents();
    }

    public static void main(String[] args){
        Jevin jevin=new Jevin();
        Contents contents=jevin.contents();
    }
}

        大致上我的理解就到这里了，以后有新的理解在发吧！！！