Java成员内部类和静态内部类

时间 2019-11-12

标签 java 成员部类静态栏目 Java 繁體版

原文原文链接

Java成员内部类和静态内部类java

使用内部类最吸引人的缘由是：每一个内部类都能独立地继承一个（接口的）实现，因此不管外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。测试

在咱们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候咱们能够利用内部类提供的、能够继承多个具体的或者抽象的类的能力来解决这些程序设计问题。能够这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。this

其实使用内部类最大的优势就在于它可以很是好的解决多重继承的问题，可是若是咱们不须要解决多重继承问题，那么咱们天然可使用其余的编码方式，可是使用内部类还可以为咱们带来以下特性（摘自《Think in java》）：编码

一、内部类能够用多个实例，每一个实例都有本身的状态信息，而且与其余外围对象的信息相互独立。spa

二、在单个外围类中，可让多个内部类以不一样的方式实现同一个接口，或者继承同一个类。.net

三、建立内部类对象的时刻并不依赖于外围类对象的建立。设计

四、内部类并无使人迷惑的“is-a”关系，他就是一个独立的实体。code

五、内部类提供了更好的封装，除了该外围类，其余类都不能访问。对象

在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。blog

成员内部类：

成员内部类也是最普通的内部类，它是外围类的一个成员，因此他是能够无限制的访问外围类的全部成员属性和方法，尽管是private的，可是外围类要访问内部类的成员属性和方法则须要经过内部类实例来访问。

在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，因此只有先建立了外围类才可以建立内部类。

静态内部类：
关键字static中提到static能够修饰成员变量、方法、代码块，其余它还能够修饰内部类，使用static修饰的内部类咱们称之为静态内部类，不过咱们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，咱们知道非静态内部类在编译完成以后会隐含地保存着一个引用，该引用是指向建立它的外围内，可是静态内部类却没有。没有这个引用就意味着：

一、它的建立是不须要依赖于外围类的。

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

代码示例：

package binarytree;

/**
 * Created with IntelliJ IDEA.
 * User: ASUS
 * Date: 14-7-11
 * Time: 下午3:26
 * To change this template use File | Settings | File Templates.
 */
public class OuterClass {

    private int tmp;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getTmp() {
        return tmp;
    }

    public void setTmp(int tmp) {
        this.tmp = tmp;
    }

    /**
     * private 访问权限
     * 成员内部类
     */
    private class InnerClass {
        private int a;
        private int b;

        public InnerClass(int a, int b) {
            this.a = a;
            this.b = b;
        }

        private int getA() {
            return a;
        }

        private void setA(int a) {
            this.a = a;
        }

        private int getB() {
            return b;
        }

        private void setB(int b) {
            this.b = b;
        }
    }


    public int doWithInnerClass() {
        InnerClass innerClass = new InnerClass(1, 2);
        if (innerClass.getA() > innerClass.getB()) {
            return innerClass.getA();
        } else {
            return innerClass.getB();
        }
    }


    /**
     * public 访问权限
     * 成员内部类
     * <p/>
     * 成员内部类也是最普通的内部类，它是外围类的一个成员，因此他是能够无限制的访问外围类的
     * 全部成员属性和方法，尽管是private的。可是外围类要访问内部类的成员属性和方法则须要经过内部类实例来访问。
     */
    public class PubInner {
        private int a;
        private int b;

        public PubInner(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public int getB() {
            return b;
        }

        public void setB(int b) {
            this.b = b;
        }

        public int getTotal() {
            return tmp + a + b;
        }
    }


    /**
     * 默认访问权限
     * 成员内部类
     */
    class DefaultInnerClass {
        private int a;
        private int b;

        public DefaultInnerClass(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public int getB() {
            return b;
        }

        public void setB(int b) {
            this.b = b;
        }
    }

    /**
     * 静态内部类
     * 访问权限是static
     */
    public static class StaticInner {
        public static final int MAX = Integer.MAX_VALUE;

        private int a;
        private int b;

        public StaticInner(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public int getB() {
            return b;
        }

        public void setB(int b) {
            this.b = b;
        }
    }
}

测试代码：

package binarytree;

import org.junit.Test;

/**
 * Created with IntelliJ IDEA.
 * User: ASUS
 * Date: 14-7-11
 * Time: 下午3:05
 * To change this template use File | Settings | File Templates.
 */
public class TestInnverClass {


    /**
     * 对于内部类的访问权限若是是private，则这个内部类是不可见的。
     */
    @Test
    public void test() {
        OuterClass outerClass = new OuterClass();
        int value = outerClass.doWithInnerClass();
        System.out.println(value);
    }


    /**
     * 测试public访问权限的内部类
     */
    @Test
    public void test0877() {

        OuterClass.PubInner pubInner00 = new OuterClass().new PubInner(1, 2);
        System.out.println(pubInner00.getA());

        OuterClass outerClass = new OuterClass();
        outerClass.setTmp(233);
        OuterClass.PubInner pubInner = outerClass.new PubInner(1, 2);

        int a = pubInner.getA(), b = pubInner.getB();
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }

        System.out.println("Total=" + pubInner.getTotal());
    }


    /**
     * 测试静态内部类，public访问权限
     */
    @Test
    public void test2323() {
        OuterClass.StaticInner staticInner = new OuterClass.StaticInner(1, 2);
        int a = staticInner.getA(), b = staticInner.getB();
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }


    /**
     * 默认访问权限的内部类
     */
    @Test
    public void test9765() {
        OuterClass.DefaultInnerClass defaultInnerClass = new OuterClass().new DefaultInnerClass(1, 2);
        int a = defaultInnerClass.getA(), b = defaultInnerClass.getB();
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

关于public，private，protected，默认的访问权限请看http://my.oschina.net/xinxingegeya/blog/212490

=====================END====================