精华内容
下载资源
问答
  • 我们已经知道:一个类通过使用new运算符可以创建多个不同的对象,这些对象将被分配不同的内存空间,说得准确些就是:不同的对象实例变量将被分配不同的内存空间,如果类中的成员变量有类变量,那么所有对象的这个...

    类体的定义包括成员变量的定义和方法的定义,并且成员变量又分为实例变量和类变量,用static修饰的变量是类变量。那么类变量和实例变量有什么区别呢?

    我们已经知道:一个类通过使用new运算符可以创建多个不同的对象,这些对象将被分配不同的内存空间,说得准确些就是:不同的对象的实例变量将被分配不同的内存空间,如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其它对象的这个类变量。也就是说对象共享类变量。

    我们知道,当Java程序执行时,类的字节码文件被加载到内存,如果该类没有创建对象,类的实例成员变量不会被分配内存。但是,类中的类变量,在该类被加载到内存时,就分配了相应的内存空间。如果该类创建对象,那么不同对象的实例变量互不相同,即分配不同的内存空间,而类变量不再重新分配内存,所有的对象共享类变量,即所有的对象的类变量是相同的一处内存空间,类变量的内存空间直到程序退出运行,才释放所占有的内存。Java语言允许通过类名直接访问类变量。

    下面例子中的梯形对象共享一个下底。

    例子

    class 梯形

    {

    float

    上底,高;

    static

    float

    下底; //类变量。

    梯形(float

    上底,float 高)

    {

    this.上底=上底;

    this.高=高;

    }

    float

    获取上底()

    {

    return 上底;

    }

    float

    获取下底()

    {

    return 下底;

    }

    }

    class Example4_5

    {

    public

    static void main(String args[])

    {

    梯形

    laderOne,laderTwo; //梯形的字节码被加载到内存。

    梯形.下底=60; //通过类名操作类变量。

    laderOne=new 梯形(18.0f,20);

    laderTwo=new 梯形(9.0f,10);

    System.out.println("laderOne的上底:"+laderOne.获取上底());

    System.out.println("laderOne的下底:"+laderOne.获取下底());

    System.out.println("laderTwo的上底:"+laderTwo.获取上底());

    System.out.println("laderTwo的下底:"+laderTwo.获取下底());

    }

    }

    展开全文
  • 实例变量 和 类变量局部变量特点:作用时间短,存储在方法的栈内存中种类:形参:方法签名中定义的局部变量,由方法调用者负责为其赋值,随方法结束而消亡方法内的局部变量:方法内定义的局部变量,必须在方法内对其...

    实例变量 和 类变量

    局部变量

    特点:作用时间短,存储在方法的栈内存中

    种类:

    形参:方法签名中定义的局部变量,由方法调用者负责为其赋值,随方法结束而消亡

    方法内的局部变量:方法内定义的局部变量,必须在方法内对其进行显示初始化,从初始化后开始生效,随方法结束而消亡

    代码块内的局部变量:在代码块中定义的局部变量,必须在代码块中进行显示初始化,从初始化后开始生效,随代码块结束而消亡

    成员变量

    类体内定义的变量,如果该成员变量没有使用 static 修饰,那该成员变量又被称为非静态变量或实例变量,如果使用 static 修饰,则该成员变量又可被称为静态变量或类变量。

    实例变量和类变量的属性

    使用 static 修饰的成员变量是类变量,属于该类本身,没有使用 static 修饰的成员变量是实例变量,属于该类的实例,在同一个类中,每一个类只对应一个 Class 对象,但每个类可以创建多个对象。

    由于同一个 JVM 内的每个类只对应一个 CLass 对象,因此同一个 JVM 内的一个类的类变量只需要一块内存空间;但对于实例变量而言,该类每创建一次实例,就需要为该实例变量分配一块内存空间。也就是说,程序中创建了几个实例,实例变量就需要几块内存空间。

    这里我想到一道面试题目:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    public class A{

    {

    System.out.println("我是代码块");

    }

    static{

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args){

    A a = new A();

    A a1 = new A();

    }

    }

    结果:

    1

    2

    3

    我是静态代码块

    我是代码块

    我是代码块

    静态代码块只执行一次,而代码块每创建一个实例,就会打印一次。

    实例变量的初始化时机

    程序可在3个地方对实例变量执行初始化:

    定义实例变量时指定初始值

    非静态初始化块中对实例变量指定初始值

    构造器中对实例变量指定初始值

    上面第一种和第二种方式比第三种方式更早执行,但第一、二种方式的执行顺序与他们在源程序中的排列顺序相同。

    同样在上面那个代码上加上一个变量 weight 的成员变量,我们来验证下上面的初始化顺序:

    1、定义实例变量指定初始值 在 非静态初始化块对实例变量指定初始值 之后:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    public class A{

    {

    weight = 2.1;

    System.out.println("我是代码块");

    }

    double weight = 2.0;

    static{

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args){

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    }

    }

    结果是:

    1

    2

    3

    4

    我是静态代码块

    我是代码块

    我是代码块

    2.0

    2、定义实例变量指定初始值 在 非静态初始化块对实例变量指定初始值 之前:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    public class A{

    double weight = 2.0;

    {

    weight = 2.1;

    System.out.println("我是代码块");

    }

    static{

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args){

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    }

    }

    结果为:

    1

    2

    3

    4

    我是静态代码块

    我是代码块

    我是代码块

    2.1

    大家有没有觉得很奇怪?

    我来好好说清楚下:

    定义实例变量时指定的初始值、初始代码块中为实例变量指定初始值的语句的地位是平等的,当经过编译器处理后,他们都将会被提取到构造器中。也就是说,这条语句 double weight = 2.0; 实际上会被分成如下 2 次执行:

    double weight; : 创建 Java 对象时系统根据该语句为该对象分配内存。

    weight = 2.1; : 这条语句将会被提取到 Java 类的构造器中执行。

    只说原理,大家肯定不怎么信,那么还有拿出源码来,这样才有信服能力的吗?是不?

    这里我直接使用软件将代码的字节码文件反编译过来,看看里面是怎样的组成?

    第一个代码的反编译源码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    public class A

    {

    double weight;

    public A()

    {

    this.weight = 2.1D;

    System.out.println("我是代码块");

    this.weight = 2.0D;

    }

    static

    {

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args)

    {

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    }

    }

    第二个代码反编译源码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    public class A

    {

    double weight;

    public A()

    {

    this.weight = 2.0D;

    this.weight = 2.1D;

    System.out.println("我是代码块");

    }

    static

    {

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args)

    {

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    }

    }

    这下子满意了吧!

    通过反编译的源码可以看到该类定义的 weight 实例变量时不再有初始值,为 weight 指定初始值的代码也被提到了构造器中去了,但是我们也可以发现之前规则也是满足的。

    他们的赋值语句都被合并到构造器中,在合并过程中,定义的变量语句转换得到的赋值语句,初始代码块中的语句都转换得到的赋值语句,总是位于构造器的所有语句之前,合并后,两种赋值语句的顺序也保持了它们在 Java 源代码中的顺序。

    大致过程应该了解了吧?如果还不怎么清楚的,建议还是自己将怎个过程在自己的电脑上操作一遍,毕竟光看不练假把式。

    类变量的初始化时机

    JVM 对每一个 Java 类只初始化一次,因此 Java 程序每运行一次,系统只为类变量分配一次内存空间,执行一次初始化。程序可在两个地方对类变量执行初始化:

    定义类变量时指定初始值

    静态初始化代码块中对类变量指定初始值

    这两种方式的执行顺序与它们在源代码中的排列顺序相同。

    还是用上面那个示例,我们在其基础上加个被 static 修饰的变量 height:

    1、定义类变量时指定初始值 在 静态初始化代码块中对类变量指定初始值 之后:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    public class A{

    double weight = 2.0;

    {

    weight = 2.1;

    System.out.println("我是代码块");

    }

    static{

    height = 10.1;

    System.out.println("我是静态代码块");

    }

    static double height = 10.0;

    public static void main(String[] args){

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    System.out.println(height);

    }

    }

    运行结果:

    1

    2

    3

    4

    5

    我是静态代码块

    我是代码块

    我是代码块

    2.1

    10.0

    2、定义类变量时指定初始值 在 静态初始化代码块中对类变量指定初始值 之前:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    public class A{

    static double height = 10.0;

    double weight = 2.0;

    {

    weight = 2.1;

    System.out.println("我是代码块");

    }

    static{

    height = 10.1;

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args){

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    System.out.println(height);

    }

    }

    运行结果:

    1

    2

    3

    4

    5

    我是静态代码块

    我是代码块

    我是代码块

    2.1

    10.1

    其运行结果正如我们预料,但是我们还是看看反编译后的代码吧!

    第一种情况下反编译的代码:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    public class A

    {

    double weight;

    public A()

    {

    this.weight = 2.0D;

    this.weight = 2.1D;

    System.out.println("我是代码块");

    }

    static

    {

    System.out.println("我是静态代码块");

    }

    static double height = 10.0D;

    public static void main(String[] args)

    {

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    System.out.println(height);

    }

    }

    第二种情况下反编译的代码:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    public class A

    {

    static double height = 10.0D;

    double weight;

    public A()

    {

    this.weight = 2.0D;

    this.weight = 2.1D;

    System.out.println("我是代码块");

    }

    static

    {

    height = 10.1D;

    System.out.println("我是静态代码块");

    }

    public static void main(String[] args)

    {

    A a = new A();

    A a1 = new A();

    System.out.println(a.weight);

    System.out.println(height);

    }

    }

    通过反编译源码,可以看到第一种情况下(定义类变量时指定初始值 在 静态初始化代码块中对类变量指定初始值 之后):

    我们在 静态初始化代码块中对类变量指定初始值 已经不存在了,只有一个类变量指定的初始值 static double height = 10.0D; , 而在第二种情况下(定义类变量时指定初始值 在 静态初始化代码块中对类变量指定初始值 之前)和之前的源代码顺序是一样的,没啥区别。

    上面的代码中充分的展示了类变量的两种初始化方式 :每次运行该程序时,系统会为 A 类执行初始化,先为所有类变量分配内存空间,再按照源代码中的排列顺序执行静态初始代码块中所指定的初始值和定义类变量时所指定的初始值。

    展开全文
  • 我理解创建对象和创建变量之间的区别.例如:private int number;MyClass myObj = new MyClass();但我的观点是,这两者之间有什么区别?private MusicPlayer player;player = new MusicPlayer();MusicPlayer是一个类,...

    我理解创建对象和创建变量之间的区别.例如:

    private int number;

    MyClass myObj = new MyClass();

    但我的观点是,这两者之间有什么区别?

    private MusicPlayer player;

    player = new MusicPlayer();

    MusicPlayer是一个类,但我们究竟在这做什么?

    解决方法:

    private MusicPlayer player;

    在这里,您可以在不初始化的情况下创建MusicPlayer类的引用变量(但不创建对象).所以你不能使用这个变量,因为它只是没有指向任何地方(它是null).

    例如,使用Point类:

    Point originOne;

    可以这样表示:

    player = new MusicPlayer();

    在这里,您分配一个MusicPlayer类型的对象,并将其存储在播放器参考中,以便您可以使用它上面的所有功能.

    例如,使用Point类,使用x和y坐标:

    Point originOne = new Point(23, 94);

    可以这样表示:

    两条线的组合相当于:

    private MusicPlayer player = new MusicPlayer();

    标签:java,class

    来源: https://codeday.me/bug/20190929/1830918.html

    展开全文
  • 这篇文章介绍JAVA与对象(实例变量与类变量的区别)(实例方法和类方法的区别 )说明实例变量实例变量声明在一个类中,但在方法、构造方法和语句块之外;当一个对象被实例化之后,每个实例变量的值就跟着确定;实例...

    这篇文章介绍JAVA类与对象(实例变量与类变量的区别)(实例方法和类方法的区别 )说明

    实例变量实例变量声明在一个类中,但在方法、构造方法和语句块之外;

    当一个对象被实例化之后,每个实例变量的值就跟着确定;

    实例变量在对象创建的时候创建,在对象被销毁的时候销毁;

    实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;

    实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见

    实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;

    实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。

    类变量(静态变量)类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。

    无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。

    静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。

    静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。

    静态变量在程序开始时创建,在程序结束时销毁。

    与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。

    默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。

    静态变量可以通过:ClassName.VariableName的方式访问。

    类变量被声明为public static final类型时,类变量名称必须使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。class TiXing{

    float up,height;

    static float down;

    TiXing(float x,float y,float z){

    up=x;

    height=y;

    down=z;

    }

    }

    public class ep3_9{

    public static void main(String args[]){

    TiXing one=new TiXing(1,2,3);

    System.out.println("one's down is:"+one.down);

    TiXing two=new TiXing(4,5,6);

    System.out.println("one's down is:"+one.down);

    System.out.println("two's down is:"+two.down);

    System.out.println("TiXing's down is:"+TiXing.down);

    }

    }

    97d43b09dbfb59aaa08fdf3a7d3a11d3.png

    实例方法和类方法对实例变量和类变量的访问

    实例方法可以对当前对象的实例变量进行操作,也可以对类变量进行操作。实例方法由实例对象调用。类方法不能访问实例变量,只能访问类变量。类方法由类名或者实例对象调用。类方法中不能出现this或者super关键字class TiXing{

    private float up,height;

    private static float down;

    TiXing(float x,float y,float z){

    up=x;

    height=y;

    down=z;

    }

    public void display(){

    System.out.println("up is:"+up+"height is:"+height+"down is:"+down);

    }

    public static void change(float number){

    down=number;

    //System.out.println("height:"+height);//出错

    }

    }

    public class ep3_9{

    public static void main(String args[]){

    TiXing one=new TiXing(1,2,3);

    one.display();

    TiXing two=new TiXing(4,5,6);

    one.display();

    two.display();

    //TiXing.display();//出错

    one.change(101);

    one.display();

    two.change(102);

    two.display();

    }

    }

    8f2496a6b4c9bf03f7dd8971aba99100.png

    展开全文
  • Java 中静态变量和实例变量区别静态变量属于类,该类不生产对象,通过类名就可以调用静态变量。实例变量属于该类的对象,必须产生该类对象,才能调用实例变量。在程序运行时的区别:实例变量属于某个对象的属性,...
  • 成员变量的默认值:具体实例代码:public class StudentTest_01 {public static void main(String[] args) {//创建对象格式,类名 对象名 = new 类名();//无参数使用方法Student s2 = new Student();s2.setName(...
  • 但在Java多线程中,实例变量是多个线程共享资源,要注意同步访问时可能出现的问题。publicclassDemo{//以下都是实例变量(成员变量、对象变量)privateStringnameString;publicintage;protected...
  • 实例变量与实例方法 ###学习目标 能够理解面向对象的思想 能够明确类与对象关系 能够掌握类的定义格式 [ ]掌握实例变量的定义格式 掌握实例方法的定义格式 能够掌握创建对象格式,并访问类中的成员 掌握...
  • 阅读本文约“1.8分钟”实例变量永远都会有默认值,如果你没有明确的赋值给实例变量,或者没有调用setter,实例变量还是会有值!integers 0floating points 0.0booleans falsereference null因此,你无需初始实例变量...
  • 首先弄明白:静态变量属于类的级别,而实例变量属于对象的级别。对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也...
  • 实例变量是属于对象,类变量是属于类,这么说的原因是实例变量是一个类创建完对象之后才能用的,也就是在Student s = new Student();这个语句之后才能使用,例如学生类中有个sname的属性,如果想要使用sname都必须...
  • 在同一个 JVM内,每个类只对应一个Class对象,但每个类可以创建多个Java对象。由于同一个JVM内每个类只对应一个Class对象,因此同一个JVM内的一个类的类变量只需一块内存空间;但对于实例变量而言,该类每创建一次...
  • /*** 在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,* 其中的实例变量才会被分配空间,才能使用这个实例变量。静态变量不属于某* 个实例对象,而是属于类,所以也称为类变量,只要程序加载...
  • 成员变量中静态变量与实例变量的区别: 1.静态变量:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量的内存中有且仅有一个拷贝,可以...
  • JAVA静态变量与实例变量区别修饰符static 修饰符static static 声明的成员变量/方法被视为类的成员变量/方法,而不把它当作实例对象的成员变量/方法。换句话说,静态变量/方法是类固有的,可以直接引用,其它成员...
  • java类的成员变量有两种:一种是被static关键字修饰的变量,叫类变量/静态变量;另一种没有static修饰,为实例变量。...在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例...
  • 类变量与实例变量 在类中被static修饰的变量属于类,称为类变量 不被static修饰的变量成为实例变量 类变量属于类本身,不属于该类的单个实例。类变量是所有对象共有,它的值只要被其中一个对象改变,其他对象得到的...
  • Java 中静态变量和实例变量区别 静态变量属于类,该类不生产对象,通过类名就可以调用静态变量。 实例变量属于该类的对象,必须产生该类对象,才能调用实例变量。 在程序运行时的区别: 实例变量属于某个对象的...
  • Java实例变量、类变量局部变量 一、实例变量 也叫对象变量、类成员变量;从属于类由类生成对象时,才分配存储空间,各对象间的实例变量互不干扰,能通过对象的引用来访问实例变量。但在Java多线程中,实例...
  • 在本篇文章里小编给各位分享的是关于java对象调用成员变量与成员实例方法,需要的朋友们可以学习参考下。
  • 你还分不清 Java对象 实例 变量?什么是类?什么是对象?什么是变量对象和类的关系:Java中的类:Java中的对象Java中的变量Java 中调用 对象的属性(状态) 和 方法(行为)感谢感谢您的阅读,有收获?希望兄弟姐妹...
  • 不同对象的同名实例变量之间的取值互不影响 内存分配的时间 当类的字节码文件加载到内存时,静态变量就分配到了相应的内存空间 当类的对象创建时才会被分配内存 访问方式 可以用类名访问,也可以用对象名访问 ...
  • 1、static⑴、字面意思:静态的。⑵、static在java中声明成员变量时这个变量也...改变某一对象实例变量,不影响其他实例中该对象的值。⑶、用static修饰的方法不能访问非静态的属性和方法。2、变量⑴、变量分为局...
  • Java实例变量、类变量局部变量

    万次阅读 多人点赞 2015-12-21 22:08:50
    但在Java多线程中,实例变量是多个线程共享资源,要注意同步访问时可能出现的问题。 public class Demo { //以下都是实例变量(成员变量、对象变量) private String nameString; public int a

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,137
精华内容 2,054
关键字:

java对象与实例变量

java 订阅