精华内容
下载资源
问答
  • JAVA中成员变量,局部变量,实例变量,类变量,有什么关系,,?
    千次阅读
    2021-03-03 14:44:33

    展开全部

    java易混淆概念之类变量32313133353236313431303231363533e4b893e5b19e31333365643662、实例变量、局部变量

    类变量、实例变量、局部变量类变量是类中独立于方法之外的变量,用static 修饰。

    实例变量也是类中独立于方法之外的变量,不过没有static修饰。

    局部变量是类的方法中的变量。

    Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程。

    JDK(Java Development Kit)称为Java开发包或Java开发工具,是一个编写Java的Applet小程序和应用程序的程序开发环境。JDK是整个Java的核心,包括了Java运行环境(Java Runtime Envirnment),一些Java工具和Java的核心类库(Java API)。

    Java看起来设计得很像C++,但是为了使语言小和容易熟悉,设计者们把C++语言中许多可用的特征去掉了,这些特征是一般程序员很少使用的。例如,Java不支持go to语句,代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载(overload)和多继承特征,并且不使用主文件,免去了预处理程序。

    更多相关内容
  • 本文实例讲述了JS中类的静态方法,静态变量,实例方法,实例变量区别与用法。分享给大家供大家参考,具体如下: 1.类的静态方法 先来段代码之后分析 // JS类静态函数 function BaseClass() { } // 类添加add函数 ...
  • 1、类变量、实例变量概念 类变量: 类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量对于所有实例化的对象中是公用的。 实例变量: ...
  • 本文实例讲述了C#静态变量与实例变量的具体用法,分享给大家供大家参考。具体分析如下: 1)在语法定义上的区别: 类变量也叫静态变量,静态变量前要加static关键字,而实例变量前则不加; 实例变量也叫对象变量,...
  • 主要介绍了Ruby中类变量和实例变量的比较,本文讲解了4点类变量和实例变量的不同之处,并给出了代码实例,需要的朋友可以参考下
  • 静态变量和实例变量的区别

    千次阅读 2022-01-12 14:18:43
    静态变量和实例变量的区别

    静态变量和实例变量的区别

    大家好,我是酷酷的韩~
    酷酷的韩金群
    1.在语法定义上的区别:

    静态变量前要加static关键字,而实例变量前则不加。

    2.在程序运行时的区别:

    (1)实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。

    (2)静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。

    (3)总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。

    (4)举例:对于下面的程序,无论创建多少个实例对象,永远都只分配了一个staticVar变量,并且每创建一个实例对象,这个staticVar就会加1;但是,每创建一个实例对象,就会分配一个instanceVar,即可能分配多个instanceVar,并且每个instanceVar的值都只自加了1次。

    public class TestUtils {
        public static int staticVar = 0;
        public int instanceVar = 0;
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                TestUtils testUtils = new TestUtils();
            }
            System.out.println(TestUtils.staticVar);
        }
    
        public TestUtils() {
            staticVar++;
            instanceVar++;
        }
    }
    

    只有经历沧桑,才能遇见曙光。 ------酷酷的韩~

    展开全文
  • Java实例变量和类变量

    万次阅读 多人点赞 2017-09-04 09:02:02
    Java程序的变量大体可分为成员变量和局部变量。其中局部变量可分为如下3类。 形参:在方法签名中定义的局部变量,由方法调用者负责为其赋值,随方法的结束而消亡。 方法内的局部变量:在方法内定义的局部变量,必须...

    Java程序的变量大体可分为成员变量和局部变量。其中局部变量可分为如下3类。

    • 形参:在方法签名中定义的局部变量,由方法调用者负责为其赋值,随方法的结束而消亡。
    • 方法内的局部变量:在方法内定义的局部变量,必须在方法内对其进行显示初始化。这种类型的局部变量从初始化完成后开始生效,随方法的结束而消亡。
    • 代码块的局部变量:在代码块内定义的局部变量,必须在代码块内对其进行显式初始化,这种类型的局部变量从初始化完成后开始生效,随代码的结束而消亡。

    局部变量的作用时间很短暂,它们都被存储在方法的栈内存中。类体内定义的变量被称为成员变量(英文是Field)。如果定义该成员变量时没有使用static修饰,该成员变量又被称为非静态变量或实例变量;如果使用了static修饰,则该成员变量又可被称为静态变量或类变量

    对于static关键字而言,从词义上来看,它是“静态”的意思。但从Java程序的角度来看,static的作用就是将实例成员变为类成员。static只能修饰在类里定义的成员部分,包括成员变量、方法、内部类、初始化块、内部枚举类。如果没有使用static修饰这里类里的成员,这里成员属于该类的实例;如果使用了static修饰,这些成员就属于类本身。从这个意义上看,static只能修饰类里的成员,不能修饰外部类,不能修改局部变量、局部内部类。

    表明上看,Java类里定义成员变量时没有先后顺序,但实际上Java要求定义成员变量时必须采用合法的前后引用。示例如下

    public class ErrorDef {
        int num1 = num2 + 5; //Cannot reference a field before it is defined
        int num2 = 20;
    }

    上面程序中定义num1成员变量的初始值时,需要根据num2变量的值进行计数,这就是“非法前后引用”。
    类似地,两个类变量也不允许采用这样“非法前后引用”,示例如下。

    public class ErrorDef {
        static int num1 = num2 + 5; //Cannot reference a field before it is defined
        static int num2 = 20;
    }

    但如果一个是实例变量,一个是类变量,则实例变量总是可以引用类变量,示例如下

    public class RightDef {
        int num1 = num2 + 5;
        static int num2 = 20;
    }

    上面程序中num1是一个实例变量,而num2是一个类变量。虽然num2位于num1之后被定义,但nun1的初始值却可根据num2计算得到。这是因为,num2变量是一个类变量,num1是实例变量,而类变量的初始化时机总是处于实例变量的初始化时机之前。所以,虽然源代码中先定义了num1,再定义了num2,但num2的初始化时机总是位于num1之前,因此num1变量的初始化可根据num2的值计算得到

    实例变量和类变量的属性

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

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

    下面程序可以很好地表现出来实例变量属于对象,而类变量属于类的特性。

    
    class Person {
        static int eyeNum;
        String name;
        int age;
    
        public void info() {
            System.out.println("Name: " + name + ", Age: " + age);
        }
    }
    
    
    public class FieldTest {
        public static void main(String[] args) {
            // 类变量属于该类本身,只要改类初始化完成,程序即可使用类变量
            Person.eyeNum = 2; // ①
    
            // 通过Person类访问 eyeNum类变量
            System.out.println("Person的eyeNum属性:" + Person.eyeNum);
    
            // 创建第一个Person对象
            Person p1 = new Person();
            p1.name = "zhangsan";
            p1.age = 22;
    
            System.out.println("通过p1变量访问eyeNum类变量:" + p1.eyeNum); // ②
            p1.info();
    
            // 创建第二个Person对象
            Person p2 = new Person();
            p2.name = "lisi";
            p2.age = 30;
            p2.info();
    
            // 通过p2修改Person类的eyeNum类变量
            p2.eyeNum = 4; // ③
    
            System.out.println("通过p1变量访问eyeNum类变量:" + p1.eyeNum);
            System.out.println("通过p2变量访问eyeNum类变量:" + p2.eyeNum);
            System.out.println("通过Person类访问eyeNum类变量:" + Person.eyeNum);
        }
    }

    上面程序中①行代码直接对Person类的eyeNum类变量赋值。这没任何问题,因为eyeNum类变量是属于Person类的,当Person类初始化完成后,eyeNum类变量也随之初始化完成。因此,程序即可对该类变量赋值,也可访问该类变量的值。

    执行①行代码之后,程序的内存分配如图所示。

    这里写图片描述

    一旦Person类初始化完成,程序即可通过Person类访问eyeNum类变量。除此之外,Java还允许通过Person类的任意实例来访问eyeNum类变量

    虽然Java允许通过Person对象来访问Person类的eyeNum类变量,但由于Person对象本身并没有eyeNum类变量(只有实例变量才属于Person实例),因此程序通过Person对象来访问eyeNum类变量时,底层依然会转换为通过Person访问eyeNum类变量。也就是说,不管通过哪个Person对象来访问eyeNum类变量,都与通过Person类访问eyeNum类变量的效果完全相同。因此,在②行代码处通过p1来访问eyeNum变量将再次输出2.

    执行完②行代码后,程序的内存分配如图

    这里写图片描述

    从图中可以看出,当程序创建Person对象时,系统不再为eyeNum类变量分配内存空间,执行初始化,而只为Person对象
    的实例变量执行初始化 – 因为实例变量才属于Person实例,而类变量属于Person类本身。

    当Person类初始化完成之后,类变量也随之初始化完成,以后不管程序创建多少个Person对象,系统不再为eyeNum类变量分配内存,但程序每创建一个Person对象,系统将再次为name、age实例变量分配内存,并执行初始化。

    当程序执行完③行代码之后,内存中再次增加了一个Person对象。当程序通过p2对eyeNum类变量进行赋值时,实际上依然是对Person类的eyeNum类变量进行赋值。此时程序的内存分配如图所示。

    这里写图片描述

    当Person类的eyeNum类变量被改变之后,程序通过p1、p2、Person类访问eyeNum类变量都将输出4。这是由于,不管通过哪个Person对象来访问eyeNum类变量,底层都将转换为通过Person来访问eyeNum类变量。由于p1和p2两个变量指向不同的Java对象,当通过它们访问实例变量时,程序将输出不同的结果。

    实例变量的初始化时机

    对于实例变量而言,它属于Java对象本身,每次程序创建Java对象时都需要为实例变量分配内存空间,并执行初始化。
    从程序运行的角度来看,每次创建Java对象都会为实例变量分配内存空间,并对实例变量执行初始化。
    从语法角度来看,程序可以在3个地方对实例变量执行初始化:

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

    其中第1、2种方式(定义时指定的初始值和非静态初始化块中指定的初始值)比第3种方式(构造器中指定初始值)更早执行,但第1、2中方式的执行顺序与他们在源程序中的排列顺序相同。

    
    class Cat {
        String name;
        int age;
    
        public Cat(String name, int age) {
            System.out.println("执行非静态初始化块");
            this.name = name;
            this.age = age;
        }
    
        {
            System.out.println("执行构造器");
            weight = 3.0;
        }
    
        double weight = 2.5;
    
        public String toString() {
            return "Name: " + name + ", Age: " + age + "Weight: " + weight;
        }
    }
    
    
    public class InitTst {
        public static void main(String[] args) {
            Cat cat1 = new Cat("tom", 3); // ①
            System.out.println(cat1);
    
            Cat cat2 = new Cat("jiafei", 2); // ②
            System.out.println(cat2);
        }
    }

    每当程序调用指定构造器来创建Java对象时,该构造器必然会获得执行的机会。除此之外,该类所包含的非静态初始化块将会获得执行的机会,而且总是在构造器执行之前获得执行。

    当程序执行①行代码创建第一个Cat对象的时候,程序将会先执行Cat类的非静态初始化块,再调用该Cat类的构造器来初始化该Cat实例。执行完①行代码后的内存分配如图所示。

    这里写图片描述

    从图中可以看出,该Cat对象的weight实例变量的值为2.5,二不是初始化块中指定的。这是因为,初始化块中指定初始值,定义weight时指定初始值,都属于对该实例变量执行的初始化操作,他们的执行顺序与它们的顺序相同。在本程序中,初始化块中对weight的赋值位于定义weight语句之前,因此程序将先执行初始化块中的初始化操作,执行完成后weight实例变量的值为3.0,然后再执行定义weight时指定的初始值,执行完成后weight实例变量的值为2.5。 从这个意义上来看,初始化块中对weight所指定的初始化值每次都将被2.5所覆盖。

    当执行②行代码再次创建一个Cat对象时,程序将再一次调用非静态初始化块、相应的构造器来初始化Cat对象。

    执行完②行代码后,程序的内存分配如图所示。

    这里写图片描述

    类变量的初始化时机

    实例变量属于Java类本身,只有当程序初始化该Java类时才会为该类的类变量分配内存空间,并执行初始化。
    从程序运行的角度来看,每JVM对一个Java类只初始化一次,因此Java程序每运行一次,系统只为类变量分配一次内存空间,执行一次初始化。
    从语法角度来看,程序可以在2个地方对类变量执行初始化:

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

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

    public class StaticInitTest {
        // 定义count类变量,定义时指定初始值
        static int count = 2;
    
        // 通过静态初始化块为name类变量指定初始值
        static {
            System.out.println("StaticInitTest的静态初始化块");
            name = "hello";
        }
    
        // 定义name类变量时指定初始值
        static String name = "itmyhome";
    
        public static void main(String[] args) {
            System.out.println("count类变量的值" + StaticInitTest.count);
            System.out.println("name类变量的值" + StaticInitTest.name);
        }
    }

    静态初始化块中为类变量指定初始值,每次运行该程序,系统将会对StaticInitTest类执行初始化:先为所有类变量分配内存空间,再按源代码中的排序执行静态初始化块中所指定的初始值和定义类变量时所指定的初始值.

    对于本例程序而已,静态初始化夸中对name变量的指定初始值位于定义name变量时指定初始值之前,因此系统先将name类变量赋值为“hello”,然后再将该name类变量赋值为“itmyhome”。每运行该程序一次,这个初始化过程只执行一次,因此运行上面程序将看到输出name类变量的值为“itmyhome”.

    下面程序更清楚地表现了类变量的初始化过程。首先定义了Price类,该Price类里有一个静态的initPrice变量,用于代表初始价格。每次创建Price实例时,系统会以initPrice为基础,减去当前打折价格(由discount参数代表)即得到该Price的currentPrice变量值

    
    class Price {
        // 类成员是Price实例
        final static Price INSTANCE = new Price(2.8);
    
        // 再定义一个类变量
        static double initPrice = 20;
    
        // 定义该Price的currentPrice实例变量
        double currentPrice;
    
        public Price(double distinct) {
            // 根据静态变量计算实例变量
            currentPrice = initPrice - distinct;
        }
    }
    
    
    public class PriceTest {
        public static void main(String[] args) {
            // 通过Price的INSTANCE访问currentPrice实例变量
            System.out.println(Price.INSTANCE.currentPrice); // ①
    
            // 创建Price实例
            Price p = new Price(2.8);
            // 通过创建的Price实例访问currentPrice实例变量
            System.out.println(p.currentPrice); // ②
        }
    }

    上面程序中①、②行代码都访问Price实例的currentPrice实例变量,而且程序都是通过new Price(2.8)来创建Price实例的。表面上看,程序输出两个Price的currentPrice都应该返回17.2(由20减去2.8得到),但实际上运行程序并没有输出两个17.2,而是输出-2.8和17.2

    如果仅仅停留在代码表面来看这个问题,往往很难得到正确的结果,下面从内存角度来分析这个程序。第一次用到Price类时,程序开始对Price类进行初始化,初始化分成以下2个阶段。

    • (1)系统为Price的两个类变量分配内存空间。
    • (2)按初始化代码(定义时指定初始化值和初始化块中执行初始值)的排列顺序对类变量执行初始化。

    初始化第一阶段,系统先为INSTANCE、initPrice两个类变量分配内存空间,此时INSTANCE、initPrice的默认值null和0.0。截止初始化进入第二个阶段,程序按顺序依次为INSTANCE、initPrice进行复制。对INSTANCE赋值时要调用Price(2.8),创建Price实例,此时立即执行程序中③代码为currentPrice进行赋值,此时initPrice类变量的值为0,因此赋值的结果是currentPrice等于-2.8。接着,程序再次将initPrice赋为20,但此时对INSTANCE的currentPrice实例变量以及不起作用了。

    当Price类初始化完成后,INSTANCE类变量引用到一个currentPrice为-2.8的Price实例,而initPrice类变量的值为20.0。当再次创建Price实例时,该Price实例的currentPrice实例变量的值才等于20.0

    展开全文
  • 实例变量

    千次阅读 2017-05-30 00:22:43
    什么是实例变量:在类声明的内部但是在类的其他成员方法之外声明的。类的每个对象维护它自己的一份实例变量的副本。 含义:定义在类中但在任何方法之外。  当一个对象被实例化后,每个实例变量的值就跟着确定。 ...

    什么是实例变量在类声明的内部但是在类的其他成员方法之外声明的。类的每个对象维护它自己的一份实例变量的副本。

    含义:定义在类中但在任何方法之外。

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

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

                   实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用性的变量默认值是null,变

                   量的值可以在声明时指定,也可以在构造方法中指定。

    与局部变量的异同:

    局部变量:定义在方法之中的变量。

    1.局部变量要先赋值,再进行运算,而实例变量均已经赋值。(这是局部变量和实例变量最大的区别)

    2.局部变量不允许范围内定义两个同名变量。

    3.实例变量和局部变量允许命名冲突。

    public class Sample{
    private int a=1;//实例变量
    public void b(){
    int a=2;//局部变量
    System.out.println("局部变量:a="+a);
    System.out.println("实例变量:a="+this.a);//局部变量的作用域内引用实例变量:this.变量名
    
    
    }
    public static void main(String[] args){
    new Sample().b();
    }
    
    
    }


    展开全文
  • Java——类变量和实例变量的区别

    万次阅读 多人点赞 2019-04-29 15:47:01
    一是没有static修饰的,这些成员变量是对象中的成员,称为实例变量。 二是有static修饰的,称为类变量(静态变量)。 静态变量(类变量)具备以下特点: 随着类的加载而加载 优先于对象存在 被所有对象所共享...
  • Python类变量和实例变量区别

    千次阅读 2019-07-25 19:01:41
    类变量:定义在类里面,通过类名或对象名引用,如果是通过对象名引用,会先找有没有这个同名的实例变量,如果没有,引用到的才是类变量,类变量的更新,只能通过类名,形如 类名.a = 55 ,不要指望通过实例引用类...
  • 成员变量和成员方法是范围最大定义,简单而论成员变量包括实例变量和类变量,成员方法包括实例方法和类方法。 实例变量 实例变量定义在类中,但是在方法之外,前面没有static修饰,它在一个对象创建时创建,摧毁时...
  • 一、实例变量 1、实例变量是声明在类中,而不是方法中的。 2、实例变量有默认值,可以之间使用。 二、局部变量 1、局部变量声明在方法中。 2、局部变量没有默认值,在使用之前必须初始化。 三、静态变量 1、...
  • Java 基础之实例方法,实例变量,类方法,类变量

    千次阅读 多人点赞 2019-05-18 09:08:17
    实例变量(instance variable) 实例变量:或叫实例域、实例字段(instance field),或叫成员变量(member variable)。实例的变量,每个实例的变量可能不同。 实例方法(instance method) 实例方法:或叫成员方法...
  • 实例变量和局部变量的区别

    千次阅读 2020-07-03 13:25:55
    public class TestInstanceVsLocal { public static void main(String[] args) { ...//局部变量,先赋值,再使用 System.out.println(a); if(true) { int b = 20;//作用范围只在if分支结构中 }
  • 类变量和实例变量的区别是什么?

    千次阅读 2021-02-19 09:30:38
    实例变量也叫对象变量,即没加static 的变量; 区别在于: 类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其...
  • python中类变量和实例变量详解

    千次阅读 2020-05-23 16:23:30
    python中类变量和实例变量详解 在了解类变量和实例变量之前,首先要知道类变量和实例变量的定义。 类变量:可在类的所有实例之间共享的值,就是指不是单独分配给每个实例,实例可以调用类变量。 实例变量:实例化...
  • Java中的类变量和实例变量的区别

    千次阅读 2019-10-08 10:48:43
    实例变量也叫对象变量,即没加static 的变量; 区别在于: 类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其...
  • java中静态变量与实例变量有何区别

    千次阅读 2021-01-13 10:36:55
    实例变量相当于该类的属性,需要 "new "该类才能被调用。而且该变量不常驻内存,当不再被使用时会java回收机制所释放。 三:静态变量与实例变量的区别 存储区域不同:静态变量存储在静态存储区域,实例变量存储在...
  • public class Test{ ...如上代码片段中有一个实例变量,如果在一个多线程高并发的场景下运行,会存在线程安全问题吗?答案是非常有可能。 #mermaid-svg-NQNIAGNu4RCj2E6k .label{font-family:'trebuchet ms'
  • 类变量和实例变量的区别

    千次阅读 2020-05-06 09:56:41
    一、类对象和实例对象 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象去引用类对象的属性和方法,能减少代码的重复率。...实例变量:实例化之后...
  • 静态方法(static method) 先从一道笔试题说起 关于Java中的静态方法,下列说法哪些是正确的() A:静态方法是一个属于...它这边的意思是不能直接访问非静态数据(实例变量),因为非静态数据是属于对象属性的,其...
  • 不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • 静态变量和实例变量的区别?

    千次阅读 2018-12-25 21:53:57
    在语法定义上的区别:静态变量前要加static关键字,而实例变量前则不加。 在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。静态变量不...
  • Java实例变量与类变量(静态变量)的定义: 1、在Java中 变量 分为 成员变量 与 局部变量 ;而 实例变量与类变量 都属于 成员变量; 2、类变量 也称为 static 变量、静态变量; 3、在声明成员变量时,用关键字 ...
  • java中类变量和实例变量

    万次阅读 多人点赞 2019-03-27 16:08:54
    java中所有的变量分为:(1)成员变量和(2)局部变量。 (1)成员变量包括: a) 实例变量 b)类变量(以static修饰) ... 变量修改:多个对象指向不同的实例变量堆内存,即实例变量的值只与对象相...
  • 1、实例变量和类变量的声明 学习Java类的时候我们知道:类体中包括成员变量的声明和方法的定义,而成员变量又可细分为实例变量和类变量。在声明成员变量时,用关键字static给予修饰的称作类变量,否则成为实例变量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,724,976
精华内容 689,990
关键字:

实例变量