java基础：静态内部类和非静态内部类对外部类属性的使用

public class InnerClassTest {
    int a = 1;
    static int b = 2;
    private int c = 3;
    private static int d = 4;
	//非静态内部类
    class Inner1{
        void test(){
            System.out.println(a);   //外部类属性
            System.out.println(b);   //外部类静态属性
            System.out.println(c);   //外部私有类属性
            System.out.println(d);   //外部静态私有类属性
        }
    }

	//静态内部类
    static class Inner2{
        void test(){
            System.out.println(a);  //外部类属性  有错误    
            System.out.println(b);  //外部类静态属性
            System.out.println(c);  //外部私有类属性  有错误
            System.out.println(d);  //外部静态私有类属性
        }
    }
    

}

非静态内部类
1.可以访问外部类的非静态属性，包括私有属性
2.可以访问外部类的静态属性，包括静态私有属性

静态内部类
1.只可以访问外部类的静态属性，包括静态私有属性
2.不可以可以访问外部类的非静态属性，包括私有属性

 

1. public class Outer

2. {

3. public String name = "MAH";

4. public class Inner //非静态内部类

5. {

6. public int Num = 4;//非静态内部类的Feild

7. public void acc()

8. {

9. System.out.println(name);//非静态内部类可以直接访问外部类的成员

10. }

11. }

12. public void accessInner()

13. {

14. System.out.println("内部类的Num值是：" + new Inner().Num);

15. }

16. public static void main(String[] args)

17. {

18. Outer b = new Outer();

19. System.out.println("这是外部类的主方法" + b.name);

20. b.accessInner(); //外部类通过调用accessInner方法产生一个非静态内部类的实例

21. }

22. }

非静态内部类可以直接访问外部类的成员，而外部类不可以直接访问非静态内部类的成员

原因：

   非静态内部类没有被static修饰，所以这个内部类就不是类相关的，也就说不是类的，是实例的，

但是我们非静态内部类要创建实例，外部类一定会先创建一个外部类的实例，非静态内部类的实例就是寄生在外部类的实例上的。所以，非静态内部类的实例可以直接访问外部类的成员，因为，外部类已经创建一个实例的，内部类保留了外部类创建的实例的引用

静态内部类不一样！

静态内部类是被static修饰的，所以是类的一员。根据静态成员不能访问非静态成员的原则，静态内部类是不能访问外部类的非静态成员的

 

java中的类可以是static吗？答案是可以。在java中我们可以有静态实例变量、静态方法、静态块。类也可以是静态的。

java允许我们在一个类里面定义静态类。比如内部类（nested class）。把nested class封闭起来的类叫外部类。在java中，我们不能用static修饰顶级类（top level class）。只有内部类可以为static。

     静态内部类和非静态内部类之间到底有什么不同呢？下面是两者间主要的不同。

    （1）内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。

    （2）非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。

    （3）一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。

基于上面的讨论，我们可以通过这些特性让编程更简单、有效。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

/* 下面程序演示如何在java中创建静态内部类和非静态内部类 */ class OuterClass{   private static String msg = "GeeksForGeeks";   // 静态内部类   public static class NestedStaticClass{     // 静态内部类只能访问外部类的静态成员     public void printMessage() {      // 试着将msg改成非静态的，这将导致编译错误      System.out.println("Message from nested static class: " + msg);     }   }   // 非静态内部类   public class InnerClass{     // 不管是静态方法还是非静态方法都可以在非静态内部类中访问     public void display(){      System.out.println("Message from non-static nested class: "+ msg);     }   } } class Main {   // 怎么创建静态内部类和非静态内部类的实例   public static void main(String args[]){     // 创建静态内部类的实例     OuterClass.NestedStaticClass printer = new OuterClass.NestedStaticClass();     // 创建静态内部类的非静态方法     printer.printMessage();      // 为了创建非静态内部类，我们需要外部类的实例     OuterClass outer = new OuterClass();        OuterClass.InnerClass inner = outer.new InnerClass();     // 调用非静态内部类的非静态方法     inner.display();     // 我们也可以结合以上步骤，一步创建的内部类实例     OuterClass.InnerClass innerObject = new OuterClass().new InnerClass();     // 同样我们现在可以调用内部类方法     innerObject.display();   } }     一：成员内部类： 最常见的内部类就是成员内部类，也称作普通内部类； 1、Inner类定义在Outer类的内部，相当于Outer类的成员变量的位置，Inner类可以使用任意访问修饰符，如：public、private、protected等。 2、Inner类中定义的test()方法可以访问Outer类中的数据，不受访问控制符的影响。 3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );如创建Inner的内部类对象：要先创建外部类对象：Outer o = new outer(); 创建内部类：Inner i = o.new Inner();访问Inner中的test()方法：i.test(); 例如： 4、如果外部类和内部类具有相同的成员变量或方法，内部类可以直接访问内部类的成员变量或方法，但如果内部类访问外部类的成员变量或者方法时，需要使用this关键字；如下： 二：静态内部类 静态内部类就是用static修饰的内部类，这种内部类的特点是： 1、静态内部类不能直接访问外部类的非静态成员，但，可以通过new 外部类().成员的方式访问； 2、如果外部类的静态成员与内部类的静态成员相同， 可以通过"类名.静态成员"来访问外部类的静态成员；如果不同，可以直接调用外部类的静态成员名。 3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建； 三：方法内部类： 1、方法内部类就是定义在外部类的方法中，方法内部类只在该方法内可以用； 2、由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

Java内部类

本文将通过WHAT、WHY、HOW三个方面来展开Java内部类的相关知识。

 

文章目录

• Java内部类
• • 一、什么是内部类？
  • 二、为什么要用内部类？
  • 三、如何使用内部类
  • • （一）成员内部类
    • • 1、外部类、内部类
      • 2、其他类使用成员内部类
      • 3、运行结果（和innerShow()方法对照）：
      • 4、小结：【成员内部类当成Outer的成员信息存在 】
    • （二）静态内部类
    • • 1、外部类、内部类
      • 2、其他类使用成员内部类
      • 3、运行结果（注意加载顺序）
      • 4、小结【和成员内部类对比理解（区别异同）】
    • （三）局部内部类
    • • 1、外部类、内部类
      • 2、运行结果
      • 3、小结【局部内有很多局限，应注意作用域】
      • 4、局部内部类访问局部变量的限制
    • （四）匿名内部类
    • • 1、定义接口
      • 2、匿名内部类使用
      • 3、结果
      • 4、小结【匿名内部类常常被用来重写某个或某些方法】

 

一、什么是内部类？

可以将一个类的定义放在里另一个类的内部，这就是内部类。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。

/**
*	我是一个外部类（外部是相对内部而言）
*/
public class Outer{
	/**
	*	我是一个内部类
	*/
	class Inner{
	//...
	}
}

二、为什么要用内部类？

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。——《Think in java》

也就是说内部类拥有类的基本特征。(eg：可以继承父类，实现接口。)在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。（注：内部类可以嵌套内部类，但是这极大的破坏了代码的结构，这里不推荐使用。）

/**
 1. Outer类继承了ClassA，实现了IFunctionA
*/
public class Outer extends ClassA implements IFunctionA{ 
	/**
	*	Inner类继承了ClassB，实现了IFunctionB
	*/
	public class Inner extends ClassB implements IfunctionB{
	//
	} 
}

除了上面的优点之外还有如下四点：

1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
2、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
3、内部类提供了更好的封装，除了该外围类，其他类都不能访问。
4、创建内部类对象的时刻并不依赖于外围类对象的创建。

具体来说，内部类信息（属性、方法）可以和外部类重名；内部类是具有类的基本特征的独立实体；可以利用访问修饰符隐藏内部类的实施细节，提供了更好的封装；静态内部类使用时可直接使用，不需先创造外部类。

三、如何使用内部类

简单的总结如下（暂时不太理解也没有关系，我们下面会通过例子依此演示）：

我们通过一些demo来理解如何使用内部类

（一）成员内部类

1、外部类、内部类

/**
 * 外部类、成员内部类的定义
 */
public class Outer {

    private int outerVariable = 1;
    private int commonVariable = 2;
    private static int outerStaticVariable = 3;
    //省略getter/setter
     
    /**
     * 成员方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 内部类
     */
    public class Inner {
    
        private int commonVariable = 20;

        /**
         * 构造方法
         */
        public Inner() {
        }

        /**
         * 成员方法，访问外部类信息（属性、方法）
         */
        public void innerShow() {
            //当和外部类冲突时，直接引用属性名，是内部类的成员属性
            System.out.println("内部的commonVariable:" + commonVariable);
            //内部类访问外部属性
            System.out.println("outerVariable:" + outerVariable);
            //当和外部类属性名重叠时，可通过外部类名.this.属性名
            System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
            System.out.println("outerStaticVariable:" + outerStaticVariable);
            //访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }
    
    /**
     *	外部类访问内部类信息
     */
    public void outerShow() {
        Inner inner = new Inner();
        inner.innerShow();
    }
}

2、其他类使用成员内部类

/*
*	其他类使用成员内部类
 */
public class Other {
    
    public static void main(String[] args) {
        //外部类对象
        Outer outer = new Outer();
        //创造内部类对象
        Outer.Inner inner = outer.new Inner();
        inner.innerShow();
        /*
        * 可在Outer中定义get方法，获得Inner对象,那么使用时，只需outer.getInnerInstance()即可。
        * public Inner getInnerInstance(Inner类的构造方法参数){
        *   return new Inner(参数);
        * }
        */
    }
}

3、运行结果（和innerShow()方法对照）：

4、小结：【成员内部类当成Outer的成员信息存在 】

1. 可以是任何的访问修饰符。
2. 内部类的内部不能有静态信息。
3. 内部类也是类,该继承继承，该重写重写，该重载重载，this和super随便用。
4. 外部类如何访问内部类信息，必须new之后打点访问。
5. 内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类.this.属性或者方法。
6. 其它类如何访问内部类：

                 Outer outer=new Outer();
                 //创造内部类对象
                 Outer.Inner inner=outer.new Inner();
                 inner.inner_show();

（二）静态内部类

1、外部类、内部类

/**
 * 外部类、内部类定义
 */
public class Outer {

    private int outerVariable = 1;

    /**
     * 外部类定义的属性(重名)
     */
    private int commonVariable = 2;
    
    private static int outerStaticVariable = 3;

    static {
        System.out.println("Outer的静态块被执行了……");
    }

    /**
     * 成员方法
     */
    public void outerMothod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /*
    *	静态方法
    */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }


    /**
     * 静态内部类
     */
    public static class Inner {
        /**
         * 成员信息
         */
        private int innerVariable = 10;
        private int commonVariable = 20;

        static {
            System.out.println("Outer.Inner的静态块执行了……");
        }

        private static int innerStaticVariable = 30;

        /**
         * 成员方法
         */
        public void innerShow() {
            System.out.println("innerVariable:" + innerVariable);
            System.out.println("内部的commonVariable:" + commonVariable);
            System.out.println("outerStaticVariable:"+outerStaticVariable);
            outerStaticMethod();
        }

        /**
         * 静态方法
         */
        public static void innerStaticShow() {
        	//被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable"+outerStaticVariable);
        }
    }

    /**
     * 外部类的内部如何和内部类打交道
     */
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
}

2、其他类使用成员内部类

public class Other {

    public static void main(String[] args) {
        //访问静态内部类的静态方法，Inner类被加载,此时外部类未被加载，独立存在，不依赖于外围类。
        Outer.Inner.innerStaticShow();
        //访问静态内部类的成员方法
        Outer.Inner oi = new Outer.Inner();
        oi.innerShow();
    }
}

3、运行结果（注意加载顺序）

4、小结【和成员内部类对比理解（区别异同）】

1. 内部可以包含任意的信息。
2. 静态内部类的方法只能访问外部类的static关联的信息。
3. 利用 外部类.内部类 引用=new 外部类.内部类(); 然后利用引用.成员信息(属性、方法)调用。
4. 访问内部类的静态信息，直接外部类.内部类.静态信息就可以了。
5. 静态内部类可以独立存在，不依赖于其他外围类。

（三）局部内部类

1、外部类、内部类

/**
 *	外部类、内部类
 */
public class Outer {
    /**
     * 属性和方法
     */
    private int outerVariable = 1;
    /**
     * 外部类定义的属性
     */
    private int commonVariable = 2;
    /**
     * 静态的信息
     */
    private static int outerStaticVariable = 3;

    /**
     * 成员外部方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }

    /**
     * 静态外部方法
     */
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }

    /**
     * 程序的入口
     */
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerCreatMethod(100);
    }

    /**
     * 成员方法，内部定义局部内部类
     */
    public void outerCreatMethod(int value) {
        /**
         * 女性
         */
        boolean sex = false;

        /**
         * 局部内部类，类前不能有访问修饰符
         */
        class Inner {

            private int innerVariable = 10;
            private int commonVariable = 20;
			/**
			*	局部内部类方法
			*/
            public void innerShow() {
                System.out.println("innerVariable:" + innerVariable);
                //局部变量
                System.out.println("是否男性:" + sex);
                System.out.println("参数value:" + value);
                //调用外部类的信息
                System.out.println("outerVariable:" + outerVariable);
                System.out.println("内部的commonVariable:" + commonVariable);
                System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                System.out.println("outerStaticVariable:" + outerStaticVariable);
                outerMethod();
                outerStaticMethod();
            }
        }
        //局部内部类只能在方法内使用
        Inner inner = new Inner();
        inner.innerShow();
    }
}

•  

2、运行结果

3、小结【局部内有很多局限，应注意作用域】

1. 类前不能有访问修饰符。
2. 仅在此方法内使用。
3. 无法创造静态信息。
4. 可以直接访问方法内的局部变量和参数（有限制，下面详谈），但是不能更改。
5. 可以随意的访问外部类的任何信息。

4、局部内部类访问局部变量的限制

Variable ‘xxx’ is accessed from within inner class, needs to be final or effectively final

它的意思是：变量’xxx’从内部类中访问，需要final或有效的final

具体限制如下：

1. 直接被final修饰的变量。
2. 已被赋值且始终未改变的变量（有且仅有赋值一次）,引用指向不能改变。JDK8以前（不包括8）只能访问被final修饰的变量。eg:
   
   就会产生如下错误：传入局部内部类所在方法的参数同理，如果一直不变则可使用，反之则会报错。
   

（四）匿名内部类

1、定义接口

/**
*	接口中方法默认为public 
*/
public interface IAnimal{
	void speak();
}

2、匿名内部类使用

/**
*	外部内、内部类
*/
public class Outer {

    public static IAnimal getInnerInstance(String speak){
        return new IAnimal(){
            @Override
            public void speak(){
                System.out.println(speak);
            }};
        	//注意上一行的分号必须有
    }
    
    public static void main(String[] args){
    	//调用的speak()是重写后的speak方法。
        Outer.getInnerInstance("小狗汪汪汪！").speak();
    }
}

3、结果

小狗汪汪汪！

4、小结【匿名内部类常常被用来重写某个或某些方法】

1. 匿名内部类是没有访问修饰符的。
2. 使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。
3. 匿名内部类访问方法参数时也有和局部内部类同样的限制。
4. 匿名内部类没有构造方法。

JVM的类加载规则 ： 1. static类型的属性和方法，在类加载的时候就会存在于内存中。 2. 要想使用某个类的static属性和方法，那么这个类必须要加载到JAVA虚拟机中。 3. 非静态内部类并不随外部类一起加载，只有在实例化外部类之后才会加载。 现在考虑这个情况：在外部类并没有实例化，内部类还没有加载，这时候如果 调用内部类的静态成员或方法，内部类还没有加载，却试图在内存中创建该内 部类的静态成员，这明显是矛盾的。所以非静态内部类不能有静态成员变量或 静态方法。 假设 ：在外部类并没有实例化，内部类还没有加载，这时候如果JVM加载静 态成员或方法，内部类还没有加载，因为非静态内部类的加载依赖于实化， 而此时却试图在内存中创建该内部类的静态成员，这明显是矛盾的。所以非 静态内部类不能有静态成员变量或静态方法。