精华内容
下载资源
问答
  • 非静态内部类
    2019-08-12 20:34:01

    在一个类中定义的类叫内部类,内部类可以为静态内部类(用static关键字修饰),也可以为非静态内部类(普通类)。

     

    区别一:

            静态内部类可以有静态成员变量和方法,非静态内部类只能有非静态的成员变量和方法。也就是说,在内部类中如果要定义静态成员,则该内部类一定要用static关键字声明为静态的。(跟抽象类类似,如果要在类中定义抽象方法,则该类一定要声明为抽象类)。

    区别二:

            静态内部类只能访问外部类的静态成员变量和方法,而非静态内部类可以访问外部类所有的成员变量和方法。

    区别三:

            静态内部类实例可以直接创建,不需要和外部类实例绑定,而创建非静态内部类需要先创建外部类实例。例如有外部类Outer,内部类Inner,如果内部类Inner是静态的,创建内部类Inner实例的方法是:Outer.Inner  var = new Outer.Inner();如果内部类是非静态的,创建内部类Inner实例的方法是:Outer.Inner var = new Outer().new Inner()。

    区别四:

            非静态内部类默认持有外部类的引用,可能会导致内存泄漏;静态内部类没有外部类的引用。

    更多相关内容
  • 静态内部类和非静态内部类的区别

    千次阅读 2020-07-20 10:55:18
    静态内部类和非静态内部类的区别: 1. 静态内部类不持有外部类的引用 在普通内部类中,可以直接访问外部类的属性、方法,即使是private类型也可以,这是因为普通内部类持有外部类的引用,可以自由访问。而静态内部类...

    静态内部类和非静态内部类的区别:

    1. 静态内部类不持有外部类的引用

    在普通内部类中,可以直接访问外部类的属性、方法,即使是private类型也可以,这是因为普通内部类持有外部类的引用,可以自由访问。而静态内部类只能访问外部类的静态方法和静态属性(如果是private也能访问)

    2. 静态内部类不依赖外部类

    普通内部类与外部类之间是相互依赖关系,内部类实例不能脱离外部类实例,也就是说他们会同生共死,一起声明,一起被垃圾回收。而静态内部类是可以独立存在的,即使外部类消亡了,静态内部类还是可以存在的。 静态内部类形似内部,神似外部。编译之后的类文件名格式为:外部类$内部类

    3. 普通内部类不能声明static的方法和变量

    普通内部类不能声明static的方法和变量,允许static常量;静态内部类的方法可以是静态的方法也可以是非静态的方法,没有限制。

    4 静态内部类和非静态内部类在创建时有区别

    
    import java.util.*;
    
    
    class Solution {
        static int d = 60;
        int f = 30;
        public class World{
            public static final int c=20;
            public void hello(){
                System.out.println("hello 我是普通内部类"+f+d);
            }
        }
        public static class  Hello{
            public static int a =10;
            public int b = 10;
            public void hello(){
                System.out.println("hello 我是静态内部类"+d);
            }
            public static void world(){
                System.out.println("world");
            }
        }
        public static void main(String[] args) {
            World world = new Solution().new World();
            world.hello();
    
            Hello hello = new Solution.Hello();
            hello.hello();
    
        }
    }
    

    参考博客:https://www.cnblogs.com/downey/p/4946815.html

    展开全文
  • 上次有朋友问我,java中的可以是static吗?我给他肯定的回答是可以的,在java中我们可以有静态实例变量、...当然也可以是静态的,下面小编整理了些关于java中的static class相关资料分享在脚本之家平台供大家参考
  •     如果一个类中定义了静态成员变量和静态方法,那么静态方法可以访问...静态内部类非静态内部类同静态方法和非静态方法类似。 为什么要使用内部类  &n...

    静态内部类和非静态内部类的区别

    主要区别有三点:定义、访问和声明

    • 定义

      • 静态内部类中可以定义类变量、类方法、常量、成员变量和方法;非静态内部类只能定义常量、成员变量和方法
    • 访问

      • 静态内部类只能访问外部类的静态成员变量和静态方法,并且不能引用外部类的对象(this);非静态内部类可以访问外部类的所有成员和方法
    • 声明

      • 声明静态内部类时,不依赖于外部类对象;声明非静态内部类时,依赖于外部类对象
    # 静态内部类
    OutClass.InnerClass innerClass =  new OutClass.InnerClass();
    
    # 非静态内部类
    OutClass.InnerClass innerClass = new OutClass().new InnerClass();
    

    内部类使用技巧

    在这里插入图片描述

    展开全文
  • public class InnerClassTest { int a = 1; static int b = 2; private int c = 3;... //非静态内部类 class Inner1{ void test(){ System.out.println(a); //外部类属性 System.out.println(b); //外部.
    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加载静 态成员或方法,内部类还没有加载,因为非静态内部类的加载依赖于实化, 而此时却试图在内存中创建该内部类的静态成员,这明显是矛盾的。所以非 静态内部类不能有静态成员变量或静态方法。

     

    展开全文
  • Java静态内部类和非静态内部类

    千次阅读 2019-01-08 17:35:53
    一、非静态内部类: 1、变量和方法不能声明为静态的。(类的编译顺序:外部类–静态方法或属性–内部类,如果内部类声明为静态的,造成编译顺序冲突。个人理解) 2、实例化的时候需要依附在外部类上面。比如:B是A的...
  • Java中内部类加载时间:一般是只有运到了才会初始化,而不是外部内加载的时候(不管是静态还是非静态内部类)。 注意到一个问题: 内部类只有是静态的,其内部类中才能有静态属性和静态方法; 如果内部类非静态的...
  • Java非静态内部类

    千次阅读 2019-04-18 08:55:07
    Java非静态内部类 在java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类 接下来我要说的是以下这种内部类,非静态内部类。首先了解非静态内部类的定义。 非静态内部类: 1....
  • Java中静态内部类和非静态内部类有什么区别?

    万次阅读 多人点赞 2018-12-24 16:33:34
    要想清楚static内部类static内部类的区别,首先要了解内部类的概念及特点,然后再进行一个全面的对比。 什么是内部类呢?简单的说就是在一个类的内部又定义了一个类,这个类就称之为内部类(Inner Class)。看...
  • 静态内部类与外部的加载顺序 它们的关系是按需加载,如果你调用了外部类的静态属性、静态方法或者构造器,那么外部类将会被加载而内部类并不会加载。 如果你调用了静态内部类的静态属性、静态方法或者构造器,那么...
  • 外部类调用非静态内部类的的方法

    千次阅读 2019-09-28 17:06:25
    外部类调用非静态内部类的的方法 我们知道,一个类的内部类里面的方法,是不可以被直接调用的。但是如果我们想使用内部中的方法,我们应该怎么做呢? 第一种办法 public class test{ public static void main...
  • 静态内部类和非静态内部类的比较

    千次阅读 2019-01-02 10:02:14
    静态内部类和非静态内部类的区别 静态内部类只能访问外部类的静态成员和静态方法 非静态内部类不管是静态方法还是非静态方法都可以在非静态内部类中访问 静态内部类和非静态内部类主要的不同: (1)静态内部类...
  • 非静态内部类持有外部类的引用时有可能导致内存泄漏 解决方法: 使用静态内部类替换 private static class MyHandler extends Handler { WeakReference<Activity > mActivityReference; MyHandler(Activity...
  • 我们经常用到的AsyncTask、Runnable、Handler、Thread等类,在采用非静态内部类|匿名内部类的方式使用的话,都会隐式地持有外部类的引用。 其原因其实也好理解的,如果不是隐式地持有外部类的引用,我们怎么可以在...
  • android 内存泄漏有一个重要的原因是非静态内部类持有外部类的引用,所以外部类的内存资源一直得不到回收,就可能会造成内存泄漏。常见的就是下面的这种创建handler方式: public class MainActivity extends ...
  • 有些情况下,我们把一个类放在另一个类的内部定义,称为内部类(innerclasses)。 内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰...
  • Java中的静态内部类和非静态内部类

    千次阅读 多人点赞 2017-08-09 11:43:29
    参考:Oracle官方文档Nested Classes...而内部类又分为两种,静态内部类(static nested classes)和非静态内部类(inner classes)。 例如这样的关系://外部类 class OuterClass { //静态内部类 static class StaticNes
  • publicclassOuter { publicString name ="MAH"; publicclassInner//非静态内部类 { publicintNum =4;//非静态内部类的Feild publicvo
  • java非静态内部类如何创建对象实例

    千次阅读 2018-11-13 22:37:03
    java非静态内部类如何创建对象实例: public class A { public class NestA { } } 在A的外部创建NestA的方法如下 A a = new A(); A.NestA nestA = a.new NestA();   接下来我们通过实际的项目经历给大家...
  • 静态内部类和非静态内部类区别

    千次阅读 2016-04-21 17:23:34
    静态内部类可以创建静态的成员,而非静态的内部类不可以,原因:内部类相当于外部类的一个属性,非静态内部类中如果可以使用静态成员,但是非静态内部类是相当于非静态成员,是在类实例化的时候才可以使用的,所以在...
  • 1.在非静态内部类条件下不能逐步创建对象,要先创建一个外部类对象,再创建内部类对象。 个人理解:因为类还没加载即还没分配内存,内部所有非静态成员都没分配内存,不可能直接创建一个非静态内部类对象。 2.在静态...
  • 非静态内部类并不随外部类一起加载,只有在实例化外部类之后才会加载。 现在考虑这个情况:在外部类并没有实例化,内部类还没有加载,这时候如果 调用内部类的静态成员或方法,内部类...
  • 内部类中不能使用静态的变量和静态的方法,这句话今天刚听到的时候感觉没毛病,但是,内部类中也不一定不能使用静态的变量,我们可以通过添加final 的方法的来使用,内部类静态的方法是不能使用的 看下面的代码 ...
  • 1.非静态内部类创建方式之一 package test; public class TestClass { public class Inner{ void fun(){ System.out.println(1); } } } package test; import test.TestClass.Inner; // 请注意这里,一定一定...
  • 首先要明确一点: static修饰方法、成员变量是属于自己的。并不属于特定的某个对象。...所以还有这么一说,不能在静态方法内使用非静态的成员变量,因为这个成员变量不是自己的,而是某一个对象的...
  •  * 非静态内部类可能导致的内存泄露及其优化    *     * 在MainActivity中定义了两个内部类InnerClassTest和ThreadSubClass.    * 在这里需要注意一个问题:    * 内部类持有外部类的引用!...
  • 非静态内部类、非静态匿名内部类会持有外部对象的引用,静态内部类、静态匿名内部类则不会持有外部对象的引用 非静态匿名内部类 非静态匿名内部类为何会持有外部类的引用呢? 静态匿名内部类不持有外部...
  • 最近看了一个帖子,问为什么非静态内部类中不能有 static 成员变量却可以有 static final 属性的编译期常量,看起来似乎很简单,实际上却是一箭双雕的一道题,即考察了非静态内部类相关知识,还考察了 final 的各种...
  • 最近遇到一个疑惑,为啥静态内部类不可以继承非静态内部类理解呢?一查资料,都是千篇一律,都是对内部类的讲解,都不能直接找到这个疑惑的答案。请教了一些大神,最后明白了其中原委,这里做个记录,哪天又不清楚了...
  • 接下来执行对象的创建,如果我们要执行代码中的变量int a 初始化,那么必须先执行加载外部类,再加载内部类,最后初始化静态变量 a ,问题就出在加载内部类上面,我们可以把内部类看成外部类的非静态成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 394,729
精华内容 157,891
关键字:

非静态内部类

友情链接: SDcard.rar