精华内容
下载资源
问答
  • * 静态变量 :static 它属于整个类所共有,静态成员可以使用类名直接访问,也可以使用对象进行访问; * java会给程序变量一个初始值,不会给局部变量初始值,若局部变量不给初始值,不能通过编译; */ public ...
    package com.imooc;
    
    /*
     * 成员变量:在类中定义,用来描述对象将要有什么
     * 局部变量:在类的方法中定义,在方法中临时保存数据
     * 静态变量 :static 它属于整个类所共有,静态成员可以使用类名直接访问,也可以使用对象进行访问;
     * java中会给程序变量一个初始值,不会给局部变量初始值,若局部变量不给初始值,不能通过编译;
     */
    public class Demo {
    
        int age = 18;
        static String stuName="Mary";
    
        public int Age1()
        {
            int age = 0;
            return age;
        }
    
        public int Age2()
        {
            int age = 0;
            return this.age;
        }
    
        public static void main(String []args)
        {
            Demo d = new Demo();
            int a1 = d.Age1();
            System.out.println(a1);//此时输出结果是局部变量的值,0;
                                  //要想输出成员变量的值,应该是return this.age;
            int a2 = d.Age2();
            System.out.println(a2);//此时输出的结果是成员变量age的值18;
    
            System.out.println(d.stuName);//通过对象访问静态变量
            System.out.println(Demo.stuName);//通过类直接访问静态变量;两种方法均可输出
                                             //stuName的值
        }
    }
    
    展开全文
  • 问题描述: 在Mymethod,有static函数,有普通函数,如果想在static函数调用普通函数,会报标题错误。 问题原因: static函数是静态函数,可以有类名::fun直接调用,即使没有Mymethod对象也可以调用,不需要...

    问题描述:

    在Mymethod中,有static函数,有普通函数,如果想在static函数中调用普通函数,会报标题错误。

    问题原因:

    static函数是静态函数,可以有类名::fun直接调用,即使没有Mymethod对象也可以调用,不需要分配对象空间;

    而普通函数必须由Mymthod对象调用,及分配了对象空间才有这个函数的意义。

    问题解决:

    1、把普通函数改为static【建议】

    2、声明一个Mymethod对象,使用对象.fun来调用

    转载于:https://www.cnblogs.com/judes/p/9211973.html

    展开全文
  • 一、java对象初始化过程  第一步,加载该类,一个java对象在初始化前会进行类加载,在... i 初始化该类静态成员  ii 执行该类静态代码块  第二步,创建对象,如果该类有父类,则创建对象时会先创建其父类对...

    一、java对象初始化过程

      第一步,加载该类,一个java对象在初始化前会进行类加载,在JVM中生成Class对象。加载一个类会进行如下操作,下面给出递归描述。(关于Class对象详见反射 点击这里)

        如果该类有父类,则先加载其父类。    

        i 初始化该类静态成员

        ii 执行该类静态代码块

      第二步,创建对象,如果该类有父类,则创建对象时会先创建其父类的对象,外层包裹子类的属性和方法,然后返回子类的引用,下面给出递归描述。

        如果该类有父类,先创建父类的对象。

        i 初始化该类普通成员。  

        ii 执行普通代码块。

        iii 调用该类构造方法。

    二、案例测试

      该类对象作为成员变量

    public class Info{
        public Info(String s) {
            System.out.println(s);
        }
    }

      父类

    public class Parent {
        
        public static Info info = new Info("Parent static member");      //静态成员
         
        public Info info2 = new Info("Parent common member");            //普通成员
        
        static {                                                         //静态代码块
            System.out.println("parent static block");
        }
        
        {                                                                //普通代码块
            System.out.println("parent common block");
        }
        
        public Parent() {                                                //父类构造方法
            System.out.println("Parent.Parent()");
        }
    }

      子类

    public class Child extends Parent{
        
        public static Info info = new Info("Child static member");       //静态成员
        
        public Info info2 = new Info("Child common member");             //普通成员
        
        static {                                                         //静态代码块
            System.out.println("Child static block");
        }
        
        {                                                                //普通代码块
            System.out.println("Child  common block");
        }
        
        public Child() {                                                 //子类构造方法
            System.out.println("Child.Child()");
        }
    }

     下面测试类的加载过程,我们不创建对象,而是直接加载类,并且是加载子类

    public class InitObjectTest{
        public static void main(String[] args) {
            try{
                //Class.forName("Parent");
                Class.forName("Child");
            }catch(Exception e){
                
            }
            //System.out.println("=============== now , we create an Object below ===========");
            //new Parent();
        }
    }

    测试结果:

     

    测试结果符合上面所写的加载类的规则,先初始化父类静态成员,再执行父类静态块,然后初始化子类静态成员,最后执行子类静态块。我们可以看到静态成员确实在类加载时初始化。

    注意:类的加载只进行一次,之后创建对象将不再进行类加载,这也是为什么静态代码块只执行一次的原因。

     

    下面,将父类加载与创建父类对象分开,观察测试结果

     

    public class InitObjectTest{
        public static void main(String[] args) {
            try{
                //Class.forName("Parent");
                Class.forName("Parent");
            }catch(Exception e){
                
            }
            System.out.println("=============== now , we create an Object below ===========");
            new Parent();
        }
    }

     

    测试结果:

     

    测试结果符合上面的规则,我们先显示的加载了Parent类,所以后面在new Parent()时就没有再加载类了。在创建对象时,先初始化普通成员,再执行普通代码块,最后调用构造方法。

     

    下面加上子类进行测试。

    public class InitObjectTest{
        public static void main(String[] args) {
            try{
                //Class.forName("Parent");
                //Class.forName("Parent");
            }catch(Exception e){
                
            }
            System.out.println("=============== now , we create an Object below ===========");
            new Child();
        }
    }

    测试结果:

     

    当我们没有显示的加载类时,new对象时,会自动加载类。而输出的前四行就是,加载类的反应。后面的六行是创建对象的反应,先初始父类的普通成员,再执行父类的普通代码块,然后调用父类构造方法,然后进行子类的类似操作。完全符合上面描述的创建过程。

     

    下面测试,先加载父类,然后直接创建子类对象。

    public class InitObjectTest{
        public static void main(String[] args) {
            try{
                //Class.forName("Parent");
                Class.forName("Parent");
            }catch(Exception e){
                
            }
            System.out.println("=============== now , we create an Object below ===========");
            new Child();
        }
    }

    测试结果:

     

    首先就加载了父类,在创建子类对象时需要加载子类,加载子类时,需要加载父类,而父类在之前就已经加载过了,所以这里并没有再次加载。

     三、总结

      到此,静态成员、静态代码块、普通成员、普通代码块、构造方法以及父类的这些模块之间的执行时序就讲完了。分成加载和创建两个步骤来看,十分清晰,每个步骤中又涉及父类的加载,这是一个递归的过程。成员的初始化在代码块的执行之前,因为代码块可能会操作成员。代码块常常用于初始化成员。

      本文个人编写,水平有限,如有错误,恳请指出,欢迎讨论分享

    转载于:https://www.cnblogs.com/wanghang-learning/p/9275183.html

    展开全文
  • 关于为什么局部内部类只能访问final变量和非静态成员内部类为什么不能定义static成员的问题,csdn的解答比较清楚,借鉴:第一个问题:LLC必须访问方法内final的变量或者参数归根到底是由于LLC所在方法的局部变量...

    关于为什么局部内部类只能访问final变量和非静态成员内部类为什么不能定义static成员的问题,csdn的解答比较清楚,借鉴:

    第一个问题:LLC必须访问方法内中final的变量或者参数归根到底是由于LLC所在方法中的局部变量的生命周期要短于LLC的生命周期。
    描述:LLC定义在方法的内部,它可以访问方法中的变量和参数,当方法被调用时,局部变量和参数在栈内存中入栈,然后再在堆内存中创建一个内部类对象,方法调用结束后栈内存中的变量和参数就出栈消亡了,但是堆内存中的内部类对象是在没有对象变量引用它的时候才会被垃圾回收器给回收了,所以完全可能一个方法已调用结束(局部变量已死亡),但该局部类的对象仍然活着。即:局部类的对象生命期会超过局部变量。如果此时再调用LLC对象的方法,会由于局部变量不能访问发生编译错误,
    解决办法:LLC对象可以访问同一个方法中被定义为final的局部变量。定义为final后,编译程序的实现方法:将所有的LLC对象要访问的final型局部变量,都拷贝成为该内部类对象中的一个数据成员。这样,即使栈中局部变量(含final)已死亡,但由于它是final,其值永不变,因而LLC对象在局部变量死亡后,照样可以访问final型局部变量。

    第二个问题:这个跟编译器的内存处理有关系,静态成员变量需要在一开始就分配内存进行初始化,而一般的类成员只是在类实例化的时候才会为止分配内存初始化,从方面来说,假如允许非静态类中有静态成员变量,如下面所示:

        class A{ 
            public class B{ 
                static string var_a; 
            } 
        } 
    

    那么在程序一开始就需要给A.B.var_a分配内存并初始化,假如这个成立了,那么A.B也应该会有相应的内存,但是由于B只是A的一个非静态成员变量,在类A还没有实例化的时候就以及有了相应的内存(也就是非静态成员变量只有在类的实例中才会有相应的内存位置),这样跟原来的标准有冲突,假如JAVA编译器(或者JAVA虚拟机)支持这种做法(其实也是可以实现的),这有的后果会导致编译器混乱无序的,大大增加了编译器的难度和复杂性,每一种语言都有预先制定好的语言标准,相对应的编译器都是基于这种标准来实现的,假如随意突破这种标准,那只会导致灾难性的后果而已。

    参考:
    http://topic.csdn.net/u/20091003/18/c2d31cda-0e0f-4598-8f2e-becfb718c14b.html?17058

    展开全文
  • 关于c++静态说法

    千次阅读 2014-11-21 08:44:27
    看了网上观点,大致有这几种比较好。 观点一:根据现代C++观点,静态类没有必要存在于C++。...在C++中静态方法不如非静态非类的成员方法好,尤其是使用了模板情况下。 我疑问:如果只声明类起显示
  • 1.改了一个实体类A某一个成员变量类型,以及受影响引用修改。 2.但是其中一个B类引用了实体类A,但是情况特殊,并没有受到影响报错,就没有修改该类。 3.因为迟迟不能上线,现在要对B类进行修改,修改过后...
  • 一、java对象初始化...i 初始化该类静态成员ii 执行该类静态代码块第二步,创建对象,如果该类有父类,则创建对象时会先创建其父类对象,外层包裹子类属性和方法,然后返回子类引用,下面给出递归描述。如果...
  • 在JAVA,对于变量的描述,大方向上只分为成员变量、局部变量。 成员变量 又叫类变量,是直接在类或者的方法外定义的变量,一般不需要初始化,在编译时,系统会自动初始化(一般是在类加载时初始化,先于方法)。 ...
  • 关于Android项目中的主要目录解读

    千次阅读 2018-05-02 08:56:23
    Android自动生成和维护,包含一个非常重要.Java文件:R.java,它里面包含很多静态类,每个静态类中的静态成员名称都对应res文件夹中的一个资源名称,保存着该资源索引,是程序与资源文件建立联系桥梁,不可...
  • 首先接着分析在黑马基础测试中的一个关于继承题目,题目描述如下: 声明类Person,包含2个成员变量:name、age。定义函数sayHello(),调用时输出:我叫***,今年***岁了。声明类Chinese继承Person。 这是一个很...
  • 1.接口用于描述系统对外提供所有服务,因此接口中的成员常量和方法都必须 是公开(public) 类型,确保外部使用者能访问它们; 2.接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象 (abstract...
  • 网上看到关于static的描述,有个不理解的地方求解: 描述: 1 - 在静态方法不能访问类的非静态成员变量和非静态成员方法; 2 - 即使没有显示地声明为static,类的构造器实际上也是静态方法。 问题: 如果按这个...
  • 关于java类生命周期

    2018-07-02 06:41:38
    2.成员变量生命周期,定时任务中的一个类,成员变量第一次进入类某方法 会进行赋值,我知道成员变量与类生命周期是相同,那么在下一次调用这个 类之前都是空闲状态,会被回收吗 3.关于java JVM管理内存...
  • 首先接着分析在黑马基础测试中的一个关于继承题目,题目描述如下: 声明类Person,包含2个成员变量:name、age。定义函数sayHello(),调用时输出:我叫***,今年***岁了。声明类Chinese继承Person。 这是一个...
  • 成员函数与内联函数

    2019-09-21 19:10:41
    11.关于成员函数特征下列描述中,______是错误. 成员函数一定是内联函数 B. 成员函数可以重载 C. 成员函数可以设置缺省参数值 D. 成员函数可以是静态的 [A] [解析] 因为成员函数可以在类体内定义,也...
  • 第一个问题:首先要明确通常...而枚举初始化则经常讨论的是枚举内部静态成员的初始化。第二个问题:所谓的“:”,其实只是Java增强for循环一个语法糖。public enum Color {RED(0), BLACK(1);private int value;Colo...
  • 2.书上写设计视图描述系统内部的静态结构和动态行为,那么到底何以划分静态结构、动态行为? 3.面向对象编程,什么是成员、什么是对象(书p197)?protected关键词对派生类影响到底是什么? 4.需求工程迭...
  • 只有当类处于生命周期时, * 程序才能使用这个类:如访问它的静态成员,创建它实例。 * 加载过程负责把类二进制数据读入到java虚拟机方法区,并且在堆区内创建一个描述 * 这个类class对象。连接过程...
  • string::npos静态成员常量:是对类型为size_t元素具有最大可能值。当这个值在字符串成员函数中的长度或者子长度被使用时,该值表示“直到字符串结尾”。作为返回值他通常被用作表明没有匹配。 string::npos是...
  • 关于接口

    2016-09-05 16:30:53
    (1)接口用于描述系统对外提供所有服务,因此接口中的成员常量和方法都必须是公开(public)类型,确保外部使用者能访问它们; (2)接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象...
  • 文章目录jni.h 定义了 jfieldID获取成员属性对应 jfieldID获取静态属性对应 jfieldID获取jfieldID 对应属性值设置jfieldID 对应属性值关于属性描述字符串,用于获取 jfieldID jni.h 定义了 jfieldID //java...
  • 关于匈牙利命名法

    2015-09-03 17:47:00
    匈牙利命名法常见与Windows编程中的命名。在Java或者其他编程语言合理使用匈牙利命名法,可以有效增强编码可读性。 匈牙利命名法是一种编程时命名规范。基本原则是:变量名=属性+类型+对象描述 属性...
  • c++语言学习

    2020-12-03 22:12:06
    关于静态成员的描述我很容易认为它不是对象的成员。第一是因为我认为对象是某个具体可以描述类的特征;第二要想作为类的成员,就要是简单的数据。但是确切的说,对象可以是具体的,也可以是抽象的,而类的成员正是...
  • 61-70

    2019-07-09 10:41:59
    注:以下问题的部分解析并非全部是自己原创,只是为了...1、下列关于一个类的静态成员的描述中,不正确的是( ) A 该类的对象共享其静态成员变量的值 B 静态成员变量可被该类的所有方法访问 C 该类的静态方法只能...
  • AI异构计算

    2019-12-16 18:23:43
    下面描述正确的是:ACD以下关于栈的说法正确的是:A关于多线程与多进程编程,下面描述错误的是:ABC下列关于多态性说法不正确的是:定义析构函数时,注意:CC出现如下类型的结构体定义:对静态成员的正确描述是...
  • 错题笔记五

    2020-05-11 18:45:55
    2. c/c++关于类的静态成员的不正确描述是( )。 静态成员不属于对象,是类的共享成员 c++11之前,非const的静态数据成员要在类外定义和初始化 静态成员函数不拥有this指针,需要通过类参数访问对象成员 只有...
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行操作(类方法)。对象某些组成部分对于外界来说是可见(公有部 分),而某些部分却是隐藏(私有部分)。特殊类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行操作(类方法)。对象某些组成部分对于外界来说是可见(公有部 分),而某些部分却是隐藏(私有部分)。特殊类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对对象执行操作(类方法)。对象某些组成部分对于外界来说是可见(公有部 分),而某些部分却是隐藏(私有部分)。特殊类方法(构造函数和析构函数)在对象创建和释放...

空空如也

空空如也

1 2 3 4 5 6
收藏数 109
精华内容 43
关键字:

关于静态成员的描述中