java内部类

java提高篇(八)----详解内部类 - chenssy - 博客园

1.成员内部类

内部类可以随意使用外部类中的方法和属性

但是外部类不能访问内部类的方法和属性

注意：内部类中不能写任何static的方法和属性

成员类是依附于外部类的，所以必须先创建外部类，再创建内部类。

package com.test.class_decoracion;
public class OuterClass  {
    private String name ;
    private int age;
    // 内部类可以随意使用外部类中的方法和属性
    String getName()
    {
        return name;
    }
    int getAge()
    {
        return  age;
    }
    public void display(){
        System.out.println("outer class");
    }
    public class InnerClass{
        public InnerClass(){//无参构造函数，将外部类中的name和age更改
            name = "chenssy";
            age = 23;
        }

        public void display(){
            System.out.println("name：" + getName() +"   ;age：" + getAge());
        }
        public OuterClass getOuterClass(){
            return OuterClass.this;
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        outerClass.display();
        innerClass.getOuterClass().display();//可以通过内部类中的getOuterClass方法，访问外部类中的方法和属性
        innerClass.display();
    }
}

2.匿名内部类

和匿名接口一样，都是直接写实现内容，在{}中写类体

        1、 匿名内部类是没有访问修饰符的。

         2、 new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。

         3、 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。

        4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

package com.test.class_decoracion;
interface InnerClass {
    int getNumber();
}
public class OuterClass {
//    定义返回类型是InnerClass的getInnerClass方法
    public InnerClass getInnerClass(final int num,String str2){

       InnerClass inner_class= new InnerClass() {
           int c=10;
           @Override
           public int getNumber() {
               return num+num;
           }
           public int print() {
             return  10;
           }
       };
        return inner_class;
    }

    public static void main(String[] args) {
        OuterClass out = new OuterClass();

        //虽然给匿名内部类写了名字,但是从外部是访问不到的,下面这句会报错
        // System.out.println(out.inner_class);

        //可以用getInnerClass方法来获得匿名内部类 ,
        InnerClass inner = out.getInnerClass(2, "chenssy");

        //注意，只能调用匿名内部类的中抽象方法
        System.out.println(inner.getNumber());
        // 这是非抽象方法,会报错
        //System.out.println(inner.print());
    }
}

3.静态内部类

静态内部类不用声明，在外部可以直接访问

它不能使用任何外部类的非static成员变量和方法。

这是静态内部类和成员内部类的对比

package com.test.class_decoracion;
public class OuterClass {
    private String sex="male";
    public static String name = "chenssy";

    /*静态内部类*/
    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String name2 = "chenssy_static";

        public static void display(){
            /*静态内部类只能访问外围类的静态成员变量和方法
             不能访问外围类的非静态成员变量和方法*/
            System.out.println("OutClass name :" + name);
        }
    }

    /*非静态内部类*/
    class InnerClass2{
        /* 非静态内部类中不能声明静态方法和静态属性 */
        public String _name2 = "chenssy_inner";
         int feijingtai_neibulei_shuxing=10;
        /* 非静态内部类中可以调用外部类的任何成员,不管是静态的还是非静态的 */
        public void display(){
            System.out.println("OuterClass name：" + name);
            System.out.println("OuterClass name：" + sex);
        }
    }

    /*外部类的方法 和在main方法中访问是一样的*/
    public void display(){
        /* 外部类中的方法访问静态内部类,直接使用即可 */
        System.out.println(InnerClass1.name2);
        /* 静态内部类 可以直接使用实例不需要依赖外部类 */
        InnerClass1.display();

        /* 非静态内部的创建需要依赖于外部类 */
       OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /* 非静态内部类的成员需要使用非静态内部类的实例 */
        System.out.println(inner2._name2);
        inner2.display();
    }

    public static void main(String[] args) {

        /* 在外部访问静态内部类,直接使用即可 */
        System.out.println(InnerClass1.name2);
        /* 访问静态内部类的方法，直接使用即可 */
        InnerClass1.display();

        /* 访问非静态内部类的成员需要声明外部类，通过外部类才能去访问内部类的成员*/
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        System.out.println(inner2._name2);
        inner2.display();

        //外部类的方法中访问静态和非静态类中的成员，和在外面访问是一样的
        outer.display();
    }
}