黑马程序员技术交流社区

标题: 实例变量和类变量的区别？ [打印本页]
作者: Walking Walking    时间: 2013-3-17 13:22
标题: 实例变量和类变量的区别？
本帖最后由 徐盼盼 于 2013-3-18 13:32 编辑

实例变量和类变量有什么区别呢？能不能分别举出实际的例子来说明呢？

谢谢了
作者: 何仕映    时间: 2013-3-17 13:32
以下面的Person类和Student类为例：
定义Person类的两个属性name和age;  这个就是Person这一类都具备的变量（属性），成为类变量
而下面学生继承Person后，所具有的学号变量（属性），就被成为实体变量，在建立学生的对象中出现
下面是代码：

  2. class Person        //定义Person类
  3. {
  4.         private  String name;        //定义Person类的两个属性name和age;  这个就是Person这一类都具备的变量（属性），成为类变量
  5.                                                         //而下面学生继承Person后，所具有的学号变量（属性），就被成为实体变量，在建立学生的对象的时候，才会出现
  6.         private int age;

  8.         Person(String name,int age)//构造函数初始化
  9.         {
  10.                 this.name = name;
  11.                 this.age = age;
  12.         }

  14.         void show()        //show方法，说出自己的属性
  15.         {
  16.                 System.out.println("My name is:"+name+"\t"+"I am "+age+" years old");
  17.         }
  18. }

  20. class Student extends Person        //Student继承了Person。
  21. {
  22.         private int studentid;                                //增加了一个特有属性学号————————————————————实体变量
  23.         Student(String name,int age)                //当未分配学号的时候，构造函数初始化
  24.         {
  25.                 super(name,age);        //调用父类的构造函数初始化
  26.         }

  28.         Student(String name,int age,int studentid)//当有name、age、studentid三个属性的构造函数
  29.         {
  30.                 this(name,age);
  31.                 this.id = studentid;
  32.         }

  34.         void show()        //重写show（）方法
  35.         {
  36.                 super.show();
  37.                 System.out.println("My id is "+id);//jvm报错，因为操作了父类里面的私有属性。
  38.         }
  39. }

  41. class ExtendsDemo3        //主函数
  42. {
  43.         public static void main(String[] args)
  44.         {
  45.                 Student a = new Student("张三",23);
  46.                 a.show();
  47.         }
  48. }
复制代码
作者: HM李帅    时间: 2013-3-17 13:33
实例变量是针对某个实例而言 对这个类的其他实例就无效了
而类变量是针对这个类而言
这个类的每个实例化出的对象都有这个变量 而且是唯一的 也就是实例a的这个类变量就是实例b的这个类变量
作者: 郭利超    时间: 2013-3-17 13:42
类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

实例变量是类实例化后，系统为其创建的一个类的实例变量的拷贝，即一个实例拥有一个实例变量。   
类变量则是用static声明，系统为每个类变量分配一次存储空间。即所有的实例共享一个类变量。
作者: 文密    时间: 2013-3-17 13:47
实例变量： 其实就是成员变量
类变量：  其实就是被静态的变量
  
作者: chuanyueing    时间: 2013-3-17 13:47
首先先清楚这二者的意思：
类变量就是被静态修饰的变量，可以用类名调用
实例变量只能被对象调用

类变量和实例变量的区别：
1.存放位置
类变量随着类的加载存在于方法区中
实例变量随着对象的建立而存在于堆内存中
2. 生命周期：
类变量生命周期最长，随着类的消失而消失
实例变量生命周期随着对象的消失而消失

这都是内存方面的没法用代码表示（也可能是我不会）
用一个毕老师的例子 我画了个图

class Person
{
String name;
static String country = "cn";//共享数据
public void show()
{
  System.out.println(name+"::"+country)
}
}


class StaticDemo
{
public static void main(String[] args)
{
  Person p = new Person();
  p.name = "zhangsan";
  p.show();
  System.out.println(Person.country);//新的调用方式,不用建立类
}
}

图中p对象没了  实例变量name就没了

而country是整个类加载完后才消失  希望能帮到你




作者: HM赵磊    时间: 2013-3-17 14:07
一、静态修饰的变量可以称为静态变量或者类变量，她是随着类的加载而加载的，她比对象现在存在于内存中。非静态变量也就是实例变量，也可以理解为对象变量，她是通过new操作符创建对象时才存在于对内存中的。
二、静态成员有个特殊的地方-------可以被所有的该类对象所共享，也就是说创建该类的所有实例(对象)共同使用这一个静态成员，这个对象也可以对他进行操作，另一个的对象也可以接着上一次操作的结果再对他进行操作
三、实例变量，通俗理解对象变量，也就是每一个对象自己独有的变量，与其他对象的这个变量无关，在通过new操作符创建每个实例(对象)的时候，都会在实例自己的堆内存中存放自己的实例变量，各自的实例变量发生变化时，不影响其他实例的这个成员
作者: HM张超    时间: 2013-3-17 14:36
最简单的
String a = new String("abc");这样是创建两个对象
String a = "abc"这样是创建一个对象！
简单明了！
作者: 黑马-王鹏    时间: 2013-3-17 14:43
  1. class Person
  2. {
  3.         String name;//成员变量，实例变量。
  4.         static String country = "CN";//静态的成员变量，类变量。
  5.         public static void show()
  6.         {         //编译出错，静态方法不能调用非静态成员
  7.                 System.out.println(country+"::::"+name);
  8.                 //this.haha();//this不能在静态中使用，因为静态随着类加载，
  9.                 //类优先于对象存在
  10.         }
  11.         public void haha()
  12.         {}
  13. }
  14. class  StaticDemo
  15. {
  16.         public static void main(String[] args)
  17.         {
  18.                 //Person p = new Person();//创建对象
  19.                 //System.out.println(p.country);
  20.                 //System.out.println(Person.country);//类名调用静态成员
  21.                 Person.show();//编译出错，静态方法不能调用非静态成员
  22.         }
  23. }

复制代码
存放位置：类变量随着类的加载而存在于方法区中
实例变量随着对象的建立存在与堆内存中
作者: 123    时间: 2013-3-17 14:59
1，static修饰修饰的变量就是类变量，类变量在类的准备阶段开始存在，直到这个类被系统销毁为止，类变量才失效。而实例变量则从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量才销毁。
2，类变量是用类来作为调用者的，而实例变量是使用实例来作为调用者的，实例也可以调用类变量，但是最好不要使用实例来调用类变量，以示区别。
作者: 黄诗宾    时间: 2013-3-17 15:29
类变量也叫静态变量，也就是在变量前加了static 的变量；

实例变量也叫对象变量，即没加static 的变量； 区别在于：

类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，

其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，

不影响其他对象；
例：
  1. public class A{
  2. static int a = 0; //类变量

  4. private int b = 0; //实例变量 }

  6. public class B{
  7. public void main (String[] args){

  9. A a1 = new A();
  10. A a2 = new A();
  11. a1.a = 3; // 等同于 A.a = 3;
  12. a1.b = 4 ;
  13. System.out.println(a2.a); //结果为3
  14. //类变量是针对所有对象的，所以a1改变a，a2的a也改变
  15. System.out.println(a2.b); //结果为0
  16. //实例只改变自身的，所以a1对象的b改变，不影响对象a2的b变量

  18. }
  19. }
复制代码
作者: _王涛    时间: 2013-3-17 20:47
本帖最后由 _王涛 于 2013-3-17 20:49 编辑

    首先要知道java的成员变量分为:实例变量和类变量(也就是static变量).
    类变量也叫静态变量，也就是在变量前加了static 的变量；实例变量也叫对象变量，即没加static 的变量；                                                                                         
    区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；
而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；   
              
作者: 黑马17期-闫东东    时间: 2013-3-17 21:30
类变量：也就是静态属性，属于类属性，被所有对形象共享，随着类的加载而加载，可以通过对象调用也可以通过 类名.属性名 来调用。
实例变量：实例变量随着对象的建立而存在于堆内存中，每个对象都有自己的实例变量。
当一个类的成员属性和方法被static修饰时，这个成员就是就是静态的，它属于类属性(静态属性),类方法（静态方法），属于这个类的所有对象所共享，类的实例访问它时，都是对同一个内存单元的访问，或操作。如下例子：
class Demo
{
static int id=10; //类变量
int  age=1;//实例变量
public static void main(String[] args)
{
Demo d1=new Demo();
d1.id++;
d1.age++;
Demo d2=new Demo();
d2.id++;
d2.age++;
System.out.println(d1.id);//12
System.out.println(Demo.id);//12可以用类名 来访问，
System.out.println(d1.age);//2
System.out.println(d2.age);//2
}
}




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2