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

谢谢了

类变量：也就是静态属性，属于类属性，被所有对形象共享，随着类的加载而加载，可以通过对象调用也可以通过 类名.属性名 来调用。
实例变量：实例变量随着对象的建立而存在于堆内存中，每个对象都有自己的实例变量。
当一个类的成员属性和方法被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
}
}

    首先要知道java的成员变量分为:实例变量和类变量(也就是static变量).
    类变量也叫静态变量，也就是在变量前加了static 的变量；实例变量也叫对象变量，即没加static 的变量；                                                                                         
    区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；
而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；   
              

类变量也叫静态变量，也就是在变量前加了static 的变量；

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

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

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

不影响其他对象；
例：

1. public class A{
   
2. static int a = 0; //类变量
   
3. 
   
4. private int b = 0; //实例变量 }
   
5. 
   
6. public class B{
   
7. public void main (String[] args){
   
8. 
   
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变量
    
17. 
    
18. }
    
19. }
    

复制代码

1，static修饰修饰的变量就是类变量，类变量在类的准备阶段开始存在，直到这个类被系统销毁为止，类变量才失效。而实例变量则从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量才销毁。
2，类变量是用类来作为调用者的，而实例变量是使用实例来作为调用者的，实例也可以调用类变量，但是最好不要使用实例来调用类变量，以示区别。

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. }
    
24. 
    

复制代码

存放位置：类变量随着类的加载而存在于方法区中
实例变量随着对象的建立存在与堆内存中

最简单的
String a = new String("abc");这样是创建两个对象
String a = "abc"这样是创建一个对象！
简单明了！

一、静态修饰的变量可以称为静态变量或者类变量，她是随着类的加载而加载的，她比对象现在存在于内存中。非静态变量也就是实例变量，也可以理解为对象变量，她是通过new操作符创建对象时才存在于对内存中的。
二、静态成员有个特殊的地方-------可以被所有的该类对象所共享，也就是说创建该类的所有实例(对象)共同使用这一个静态成员，这个对象也可以对他进行操作，另一个的对象也可以接着上一次操作的结果再对他进行操作
三、实例变量，通俗理解对象变量，也就是每一个对象自己独有的变量，与其他对象的这个变量无关，在通过new操作符创建每个实例(对象)的时候，都会在实例自己的堆内存中存放自己的实例变量，各自的实例变量发生变化时，不影响其他实例的这个成员

首先先清楚这二者的意思：
类变量就是被静态修饰的变量，可以用类名调用
实例变量只能被对象调用

类变量和实例变量的区别：
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是整个类加载完后才消失  希望能帮到你

实例变量： 其实就是成员变量
类变量：  其实就是被静态的变量
  

类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

实例变量是类实例化后，系统为其创建的一个类的实例变量的拷贝，即一个实例拥有一个实例变量。   
类变量则是用static声明，系统为每个类变量分配一次存储空间。即所有的实例共享一个类变量。

实例变量是针对某个实例而言 对这个类的其他实例就无效了
而类变量是针对这个类而言
这个类的每个实例化出的对象都有这个变量 而且是唯一的 也就是实例a的这个类变量就是实例b的这个类变量

以下面的Person类和Student类为例：
定义Person类的两个属性name和age;  这个就是Person这一类都具备的变量（属性），成为类变量
而下面学生继承Person后，所具有的学号变量（属性），就被成为实体变量，在建立学生的对象中出现
下面是代码：

1. 
   
2. class Person        //定义Person类
   
3. {
   
4.         private  String name;        //定义Person类的两个属性name和age;  这个就是Person这一类都具备的变量（属性），成为类变量
   
5.                                                         //而下面学生继承Person后，所具有的学号变量（属性），就被成为实体变量，在建立学生的对象的时候，才会出现
   
6.         private int age;
   
7. 
   
8.         Person(String name,int age)//构造函数初始化
   
9.         {
   
10.                 this.name = name;
    
11.                 this.age = age;
    
12.         }
    
13. 
    
14.         void show()        //show方法，说出自己的属性
    
15.         {
    
16.                 System.out.println("My name is:"+name+"\t"+"I am "+age+" years old");
    
17.         }
    
18. }
    
19. 
    
20. class Student extends Person        //Student继承了Person。
    
21. {
    
22.         private int studentid;                                //增加了一个特有属性学号————————————————————实体变量
    
23.         Student(String name,int age)                //当未分配学号的时候，构造函数初始化
    
24.         {
    
25.                 super(name,age);        //调用父类的构造函数初始化
    
26.         }
    
27. 
    
28.         Student(String name,int age,int studentid)//当有name、age、studentid三个属性的构造函数
    
29.         {
    
30.                 this(name,age);
    
31.                 this.id = studentid;
    
32.         }
    
33. 
    
34.         void show()        //重写show（）方法
    
35.         {
    
36.                 super.show();
    
37.                 System.out.println("My id is "+id);//jvm报错，因为操作了父类里面的私有属性。
    
38.         }
    
39. }
    
40. 
    
41. class ExtendsDemo3        //主函数
    
42. {
    
43.         public static void main(String[] args)
    
44.         {
    
45.                 Student a = new Student("张三",23);
    
46.                 a.show();
    
47.         }
    
48. }
    

复制代码