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内部类

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

 

文章目录

 

一、什么是内部类?

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

/**
*	我是一个外部类(外部是相对内部而言)
*/
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、创建内部类对象的时刻并不依赖于外围类对象的创建。

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

三、如何使用内部类

简单的总结如下(暂时不太理解也没有关系,我们下面会通过例子依此演示):
Java新生代内部类概述
我们通过一些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
    就会产生如下错误:传入局部内部类所在方法的参数同理,如果一直不变则可使用,反之则会报错。
    在这里插入图片描述

(四)匿名内部类

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加载静 态成员或方法,内部类还没有加载,因为非静态内部类的加载依赖于实化, 而此时却试图在内存中创建该内部类的静态成员,这明显是矛盾的。所以非 静态内部类不能有静态成员变量或静态方法。

 

  • 5
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值