精华内容
下载资源
问答
  • Java 面向对象中的两类 变量 : 成员变量和局部变量
  • 我们知道Java的非成员变量需要强制让你给它赋值,因为学过C语言都知道声明一个变量不初始化就是乱码,乱码没有意义,还有安全隐患。所以Java强制让你给非成员变量赋值,至于为什么成员变量有默认值?那得多亏了构造...

    我们知道Java的非成员变量需要强制让你给它赋值,因为学过C语言都知道声明一个变量不初始化就是乱码,乱码没有意义,还有安全隐患。所以Java强制让你给非成员变量赋值,

    至于为什么成员变量有默认值?

    那得多亏了构造函数,想要new对象必须至少拥有一个构造函数,拿默认的无参构造函数来讲,虽然表面上看着它什么也没做,其实底层不单只是为对象分配内存,它也同时初始化对象上的成员变量。

    一个深刻的例子就是,C语言构造结构体时,肯定不是单单声明出来,而是自己写一个类似于Java的构造函数来构造一个结构体。

    typedef struct _User{

    char *account

    char *password

    }User;

    User* new_User() //无参构造函数

    {

    User *this = (User *)malloc(sizeof(User));

    this->account = NULL;

    this->password = NULL;

    return this;

    }

    User* new_User(char* account, char *password) // 有参构造函数,当然C语言不支持重载,函数同名只是为了示范

    {

    User *this = (User *)malloc(sizeof(User));

    this->account = account;

    this->password = password;

    return this;

    }

    int main(void)

    {

    User *user1 = new_User("admin","admin");

    printf("帐号:%s\n密码:%s\n",user1->account, user1->password);

    return 0;

    }

    展开全文
  • 上次我们已经介绍过java类变量和实例变量,今天我们再来看一下java成员变量和成员方法,它们的概念以及异同表现在哪些方面。首先,我们需要知道的是,这些都是java类中的概念。1.成员属性就是对该类定义的一些变量...

    上次我们已经介绍过java类变量和实例变量,今天我们再来看一下java的成员变量和成员方法,它们的概念以及异同表现在哪些方面。

    首先,我们需要知道的是,这些都是java类中的概念。

    1.成员属性就是对该类定义的一些变量属性;

    2.成员方法就是对该类定义的一些函数方法。

    简单来说,成员方法和成员属性就是属于这个类的方法和变量。它们的异同主要如下:

    ⑴可以在类中存在的只有成员变量和成员方法,只要有一个方法就可以称为成员方法,它其实是方法的统称;

    ⑵类包括成员变量和方法两个部分。成员变量表示类的属性,是数据域的形式表达,而方法是数据的操作的定义。

    ⑶在java中,方法只能作为类的成员,也就是成员方法。方法操作类已经定义的数据,并且提供对数据的访问的代码。在大多数情况下,程序的其他部分都是通过类的方法和其他类的实例进行交互的。

    ⑷在类中,除了变量外的都是成员方法。方法中有一种是对成员变量进行初始化的,称为构造方法。构造方法之外的就是一般的方法。

    ⑸成员方法分为构造方法和一般的方法。构造方法没有返回值,并且方法名必须和类名一样,具体代码示例如下:public class MyTest

    {

    public MyTest()

    {}

    从上可知,}里面就是一个构造方法,也被称为构造函数,它里面可以有参数,也可以没参数,可以看出一般是在创建类的对象的时候使用。而普通的方法就是类中的那些方法,public是修饰符,和修饰类和变量(变量就是变量属性)是同一个意思。类方法的定义就是用static修饰该方法,那么在使用该方法的时候,就是用(类.该方法)来调用。

    再来看一下成员方法的具体划分。

    1.根据返回值,有明确返回值方法,返回void类型的方法。

    2.根据形式参数,无参方法和带参方法*。

    需要注意的是,构造方法没有返回值,方法名和类名一样,其作用是用于在NEW一个类的时候,会优先调用这个类的构造方法,构造方法内部可以作一些变量的初始化或者创建这个类时必须调用的一些方法和运算,它会随着类的创建而自动去调用。

    为大家举例说明一下,如果我们需要做一个i+j的运算,在这期间我们用到了构造函数,让其改变了i和j的初始化值,具体代码如下:public class Text

    {

    int i = 0;

    int j = 0;

    /**

    * Text 的构造函数 将i和J的值重新初始化赋值

    */

    public Text()

    {

    i = 1;

    j = 2;

    };

    public static void main(String[] args)

    {

    Text s = new Text();

    //此时当你NEW完Text()时程序已经自动执行了Text的构造 函数i和j的值已经是1和2

    System.out.println(s.i + s.j);

    }

    }

    以上就是有关java成员变量和方法的含义以及异同点表现在哪些方面的大致内容。想要了解更多java常见问题,敬请关注奇Q工具网。

    推荐阅读:

    展开全文
  • Java成员变量初始化顺序

    千次阅读 2018-11-24 22:28:49
    Java成员变量分为两类:1、类变量 2、实例变量 1、类变量初始化 类变量简单来说就是被static修饰的变量,类变量属于类本身 1.1 初始化时机 定义类变量时指定初始化 静态代码块中对类变量指定初始化 1.2 初始化...

    Java中成员变量分为两类:1、类变量 2、实例变量

    1、类变量初始化

    类变量简单来说就是被static修饰的变量,类变量属于类本身

    1.1 初始化时机

    • 定义类变量时指定初始化
    • 静态代码块中对类变量指定初始化

    1.2 初始化顺序

    上述两种方式在程序中的排列顺序即为执行顺序

    class ClassVarInit{
    	static int value=10;
    	static{
    		value=100;
    		name="静态代码块中对类变量指定初始化";
    	}
    	static String name="定义类变量时指定初始化";
    	public static void main(String[] args){
    		System.out.println(value);//输出:100
    		System.out.println(name);//输出:"定义类变量时指定初始化"
    	}
    }
    

    利用javap工具可以明显的看到类变量的赋值顺序

    javap -c ClassVarInit.class
    
    Compiled from "ClassVarInit.java"
    public class demo.ClassVarInit {
      static int value;
    
      static java.lang.String name;
    
      public demo.ClassVarInit();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang
    /Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: getstatic     #2                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
           3: getstatic     #3                  // Field value:I
           6: invokevirtual #4                  // Method java/io/P
    rintStream.println:(I)V
           9: getstatic     #2                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          12: getstatic     #5                  // Field name:Ljava
    /lang/String;
          15: invokevirtual #6                  // Method java/io/P
    rintStream.println:(Ljava/lang/String;)V
          18: return
    
      static {};
        Code:
           0: bipush        10
           2: putstatic     #3                  // Field value:I
           5: bipush        100               
           7: putstatic     #3                  // Field value:I
          10: ldc           #7                  // String 静态代码
    块中对类变量指定初始化
          12: putstatic     #5                  // Field name:Ljava
    /lang/String;
          15: ldc           #8                  // String 定义类变
    量时指定初始化
          17: putstatic     #5                  // Field name:Ljava
    /lang/String;
          20: return
    }
    

    2、实例变量初始化

    实例变量属于实例对象

    2.1 初始化时机

    • 定义实例变量时指定初始化
    • 非静态代码块中对实例变量指定初始化
    • 构造器中对实例变量指定初始化

    2.2 初始化顺序

    前两种方式在程序中的排列顺序即为执行顺序,且都优先于构造器初始化

    class InstanceVarInit{
    	public InstanceVarInit(int value,String name){
    		this.value=value;	
    		this.name=name;
    	}
    	int value=10;
    	{
    		value=100;
    		name="非静态代码块中对实例变量指定初始化";
    	}
    	String name="定义实例变量时指定初始化";
    	public static void main(String[] args){
    		InstanceVarInit obj=new InstanceVarInit(1000,"构造器中对实例变量指定初始化");	
    		System.out.println(obj.value);//输出:1000
    		System.out.println(obj.name);//输出:"构造器中对实例变量指定初始化"
    	}
    }
    
    javap -c InstanceVarInit.class
    
    Compiled from "InstanceVarInit.java"
    public class demo1.InstanceVarInit {
      int value;
    
      java.lang.String name;
    
      public demo1.InstanceVarInit(int, java.lang.String);
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang
    /Object."<init>":()V
           4: aload_0
           5: bipush        10
           7: putfield      #2                  // Field value:I
          10: aload_0
          11: bipush        100
          13: putfield      #2                  // Field value:I
          16: aload_0
          17: ldc           #3                  // String 非静态代
    码块中对实例变量指定初始化
          19: putfield      #4                  // Field name:Ljava
    /lang/String;
          22: aload_0
          23: ldc           #5                  // String 定义实例
    变量时指定初始化
          25: putfield      #4                  // Field name:Ljava
    /lang/String;
          28: aload_0
          29: iload_1
          30: putfield      #2                  // Field value:I
          33: aload_0
          34: aload_2
          35: putfield      #4                  // Field name:Ljava
    /lang/String;
          38: return
    
      public static void main(java.lang.String[]);
        Code:
           0: new           #6                  // class demo1/Inst
    anceVarInit
           3: dup
           4: sipush        1000
           7: ldc           #7                  // String 构造器中
    对实例变量指定初始化
           9: invokespecial #8                  // Method "<init>":
    (ILjava/lang/String;)V
          12: astore_1
          13: getstatic     #9                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          16: aload_1
          17: getfield      #2                  // Field value:I
          20: invokevirtual #10                 // Method java/io/P
    rintStream.println:(I)V
          23: getstatic     #9                  // Field java/lang/
    System.out:Ljava/io/PrintStream;
          26: aload_1
          27: getfield      #4                  // Field name:Ljava
    /lang/String;
          30: invokevirtual #11                 // Method java/io/P
    rintStream.println:(Ljava/lang/String;)V
          33: return
    }
    
    展开全文
  • java 成员变量和类变量的区别

    千次阅读 2018-03-16 11:13:09
    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...

    由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。

    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。

    成员变量和类变量的区别:

       1、两个变量的生命周期不同

          成员变量随着对象的创建而存在,随着对象的回收而释放。

          静态变量随着类的加载而存在,随着类的消失而消失。

       2、调用方式不同

          成员变量只能被对象调用。

          静态变量可以被对象调用,还可以被类名调用。

       3、别名不同

          成员变量也称为实例变量。

          静态变量也称为类变量。

       4、数据存储位置不同

          成员变量存储在堆内存的对象中,所以也叫对象的特有数据。

          静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。

    static 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。

       特点:

       1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

       2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。

        3、静态随着类的加载而加载。而且优先于对象存在。

     

    弊端:

       1、有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

       2、静态方法只能访问静态成员,不可以访问非静态成员。

          因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。

       3、静态方法中不能使用this,super关键字。

          因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。

     

    什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

    成员分两种:

       1、成员变量。(数据共享时静态化)

          该成员变量的数据是否是所有对象都一样:

          如果是,那么该变量需要被静态修饰,因为是共享的数据。 

          如果不是,那么就说这是对象的特有数据,要存储到对象中。 

       2、成员函数。(方法中没有调用特有数据时就定义成静态)

          如果判断成员函数是否需要被静态修饰呢?

          只要参考,该函数内是否访问了对象中的特有数据:

          如果有访问特有数据,那方法不能被静态修饰。

          如果没有访问过特有数据,那么这个方法需要被静态修饰。

    成员变量和静态变量的区别:

       1、成员变量所属于对象。所以也称为实例变量。

          静态变量所属于类。所以也称为类变量。

       2、成员变量存在于堆内存中。

          静态变量存在于方法区中。

       3、成员变量随着对象创建而存在。随着对象被回收而消失。

          静态变量随着类的加载而存在。随着类的消失而消失。

       4、成员变量只能被对象所调用 。

          静态变量可以被对象调用,也可以被类名调用。

       所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。

    展开全文
  • java成员变量是什么

    千次阅读 2019-07-02 07:58:28
    java中 变量分成员变量 和局部变量 成员变量是指这个类的变量,局部变量是类中方法体内定义的变量。
  • 转载:https://blog.csdn.net/qq_24644517/article/details/82288493 package deep; public class DefaultValue { // 实例成员变量 private boolean bool; private byte b; private short s; private ...
  • 不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • Java 成员变量和静态变量的区别

    千次阅读 2019-01-02 23:01:03
    文章目录Java 成员变量和静态变量的区别变量声明默认值与 Python 的联系实例变量的声明类变量的声明static 方法 Java 成员变量和静态变量的区别 1)成员变量所属于对象。所以也称为实例变量。 静态变量所属于类。...
  • 主要介绍了Java成员变量与局部变量的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • Java 成员变量和成员方法

    万次阅读 多人点赞 2018-12-07 10:25:44
    Java 语言中对象的属性以成员变量的形式存在,对象的方法以成员方法的形式存在。 成员变量Java 中对象的属性也称为成员变量。为了了解成员变量,首先定义一个图书类,成员变量对应于类对象的属性,在 Book 类...
  • Java 成员变量的默认值

    万次阅读 2018-04-20 14:38:44
    其实,成员变量在创建时,系统会为其分配一个默认值。不同类型的变量,默认值也不相同。 例: package deep; public class DefaultValue { // 实例成员变量 private boolean bool; private byte b; privat....
  • java成员变量和方法

    千次阅读 2018-08-11 23:33:25
    能在类中存在的只有成员变量和成员方法,只要是一个方法就可以称为成员方法,它只是方法的统称。 类包括成员变量和方法两部分。成员变量表示类的属性,一数据域的形式表达,方法是数据的操作的定义。 在JAVA中,...
  • Java成员变量的初始化

    千次阅读 2017-02-23 22:30:39
    Java成员变量的初始化 类变量与成员变量
  • Java成员变量的定义。

    千次阅读 2017-10-27 10:43:43
    今天看源代码,看到一个新奇的成员变量定义方法。 private String name, pwd;  其中的效果也是 private String name; private String pwd; 两个效果都是相同的,也可以get和set。 只要是同种的...
  • java成员变量何时被回收
  • Java成员变量是自身、本类对象

    千次阅读 2016-06-03 15:43:45
    如题,假如java类里的成员变量是自身的对象,则新建该类对象时内存中怎么分配空间,我感觉似乎死循环了。 不过我想的肯定是错的,因为很多类的成员变量是自身对象,并且绝对无错,举个例子: Class A{ private ...
  • java中,成员变量分为两种:实例成员变量和静态成员变量。 1.1.1实例成员变量 实例成员变量:是定义在方法外部和类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据 代码示例: class Person ...
  • Java成员变量调用方法赋值问题

    千次阅读 2017-09-23 12:12:59
    当依靠方法给成员变量赋值时,有可能会犯以下错误。class Node{ public Node(String str){ data=str; } Node next; String data; @Override public String toString() { return data; } } public
  • 声明时为成员变量赋值,那么你一创建对象,这个赋值就进行,而且先于构造器执行。 而且你每次创建这个类的对象,都是同一个值。 构造方法初始化可以单独为每一个对象赋不同的值 执行顺序: 执行父类静态代码,执行子类...
  • Java成员变量的隐藏

    千次阅读 2019-05-31 16:21:47
    Java成员变量的隐藏 前几天看一篇文章,里面提到了成员变量的"重写"问题,刚看到的时候我非常疑惑,难道成员变量不是和方法一样的重写机制吗?结果当然是啪啪打脸。这个知识点确实是我的知识误区,因为我记得当初...
  • java成员变量在什么时候赋值的?

    千次阅读 2017-01-18 16:04:59
    作者:RednaxelaFX 链接:... 来源:知乎 著作权归作者所有,转载请联系作者获得授权。 ...从Java SE 6开始是这样的: public class MyClass { private int a = 1; // field declaration with
  • 至于为什么成员变量有自己的初始值,而不需要强制赋值,那是因为new对象的时候,构造函数帮你初始化了。一个典型的代表是:为什么空构造函数啥也不做也非得存在那么搞笑?虽然看起来是空的什么都没做,但底层做了很...
  • Java 成员变量与局部变量名重复

    千次阅读 2015-08-17 09:45:27
    Java成员变量和局部变量可以重复定义。
  • Java成员变量与成员方法

    千次阅读 2019-05-27 10:28:49
    Java中对象的属性成为成员变量, 有时候很多人也喜欢把成员变量等同于全局变量, 因为成员变量在某一个类中都有效 (成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中...
  • java中的成员变量是什么发布时间:2020-06-10 09:34:20来源:亿速云阅读:171作者:Leahjava中的成员变量是什么?这篇文章运用了实例代码展示,代码非常详细,可供感兴趣的小伙伴们参考借鉴,希望对大家有所帮助。...
  • 主要介绍了Java反射如何修改private final成员变量值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java 使用类作为成员变量 java 使用类作为成员变量
  • 在定义成员变量时可以对其初始化,java使用默认的值对其初始化。如图所示: 成员变量的作用范围是整个类体,类是对象的类型用static修饰的成员变量称为静态变量或类变量,而没有使用static修饰的成员变量称为实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 579,995
精华内容 231,998
关键字:

java成员变量

java 订阅
友情链接: chapter37.rar