精华内容
下载资源
问答
  • C# 静态成员和实例成员

    千次阅读 2019-05-14 17:13:14
    对象是类的实例,对象有自己的属性和方法,万物皆对象,不可避免的,类也是一种对象,也有它自己的方法和属性,类的成员称为静态成员,包括静态数据和静态方法,而类实例化出的对象的成员称为实例成员。下面让我们来...

    前言:我们都知道,类是对象的抽象,对象是类的实例,对象有自己的属性和方法,万物皆对象,不可避免的,类也是一种对象,也有它自己的方法和属性,类的成员称为静态成员,包括静态数据和静态方法,而类实例化出的对象的成员称为实例成员。下面让我们来了解一下C#中的静态成员和实例成员。
      静态成员(static member):又叫类成员,指的是在成员类型或返回值类型前用static关键字修饰的变量或方法,包括静态数据和静态方法;
      实例成员(instance member):又称非静态成员、对象成员,是没有用static修饰的变量或方法,包括实例数据和实例方法。
      不同点:表面看就是有没有被static修饰,其次是在内存分配上,类加载时,静态成员只只分配一次,有且只有一份存储空间。而对于实例成员,每产生一个实例都要重新分配一个存储空间。
      特点之静态成员:
      1)静态成员(包括静态数据和静态方法)必须由类名调用,不能使用对象调用(静态数据可以由实例方法调用)。
      2)静态数据属于类的级别,当类加载时,一个静态数据在内存只分配一个存储空间,无论new出多少个实例,它也只是有那一个空间。
      3)静态方法只能调用静态数据,不能调用对象。

    特点之实例成员:
      1)实例成员(包括实例数据和实例方法)必须通过对象来调用,不能使用类名调用。
      2)类的实例数据属于类的实例级别,每新创建一个对象,都会在内存中为实例成员开辟一块新的存储空间。
      3)实例方法可以调用实例数据和静态数据。
      附:我们在C#中经常使用的WriteLine等方法都是静态成员,是直接调用类名Console来使用的。
      让我们来用代码来说明方法对数据的调用情况:

    class Demo
     
    {
        int a;                // 实例数据
        static int b;         // 静态数据
        void A()              // 实例方法
     
        {
            a = 1;             // 正确:实例方法可以调用实例数据
            b = 1;             // 正确:实例方法可以调用静态数据
        }
     
        static void B()       // 静态方法
     
        {
            a = 1;             // 错误:静态方法不能调用实例数据
            b = 1;             // 正确:静态方法可以调用静态数据
        }
     
        static void Main()        // 静态方法
        {
            Demo d = new Demo();  // 实例化对象
            d.a = 1;              // 正确:实例可以调用实例数据
            d.b = 1;              // 错误:实例不能调用静态数据
            Demo.a = 1;           // 错误:类名不能调用实例数据
            Demo.b = 1;           // 正确:类名可以调用静态数据
            d.A();                // 正确:实例可以调用实例方法
            d.B();                // 错误:实例不能调用静态方法
            Demo.A();             // 错误:类名不能调用实例方法
            Demo.B();             // 正确:类名可以调用静态方法
        }
    }
    
    

    另外,让我们来用代码说明一下,静态数据只使用一块内存空间:

    public class Demo
     
    {
        static int count=0;  //定义静态数据count
        int number=0;        //定义实例数据number
        public Demo()
        {
    	number =number+ 1;
            count = count + 1;        
        }
     
        public void show()
        {
            Console.WriteLine("number={0} : count={1}", number, count);
        }
    }
     
    class Test
    {
        public static void Main()
        {
            Demo a = new Demo();
            a.show();
            Console.WriteLine("***************");
            Demo b = new Demo();
            b.show();
            Console.WriteLine("***************");
            Demo c = new Demo();
            c.show();
        }
    }
    
    

    输出结果为:
        number=1 : count=1
        ********************
        number=1 : count=2
        ********************
        number=1 : count=3

    可以看出:静态数据的值是随着实例化出的对象数目而改变的,每增加一个实例化对象都会使静态数据值+1,所以所有的对象都是使用的同一个静态数据,即证明了静态数据公用一块内存空间,而每个对象的实例数据都相同,说明每实例化一次都会开辟一块新的内存空间。

    展开全文
  • c# 静态成员和实例成员的区别

    千次阅读 2019-03-10 12:05:35
    c# 静态成员和实例成员的区别 静态成员也称为共享成员,例如静态属性 静态字段 静态方法;静态成员可以在类的实例之间共享。 静态类中只能有静态成员,不能有实例成员,因为静态类不能进行实例化; 在非静态类中 即...

    c# 静态成员和实例成员的区别
    静态成员也称为共享成员,例如静态属性 静态字段 静态方法;静态成员可以在类的实例之间共享。

    静态类中只能有静态成员,不能有实例成员,因为静态类不能进行实例化;

    在非静态类中 即可以有静态成员 也可以有非静态成员;

    只要是静态成员 属性 字段 方法,都需要用类名去调用;

    静态成员和实例成员的区别:

    静态成员需要通过static修饰,非静态成员不需要通过static修饰;

    静态成员属于类,可以直接通过“类名.静态成员”的方式访问;

    非静态成员,必须实例化对象后,通过对象.实例成员来访问;

    当类第一次加载的时候(第一次被加载到内存的时候),该类下的所有的静态成员都会被加载,实例成员有多少个对象,就会创建多少个对象;静态成员会被加载到静态存储区,直到程序退出时才会被释放;

    由上面显然可知,定义静态的成员是可以影响程序的执行效率的。那么什么时候定义静态的成员变量呢?

    ①变量需要被共享的时候②方法需要被反复的调用的时候

    静态成员和实例成员的区别:
    静态成员是需要通过static关键字来修饰的,而实例成员不用static关键字修饰。他们区别如下代码:

    01 class Program
    02 {
    03 static void Main(string[] args)
    04 {
    05 //静态成员属于类,可以直接通过“类名.静态成员”的方式访问
    06 Person.Run();
    07 //实例成员属于对象,需要通过“对象名.实例成员”来访问
    08 Person p = new Person();
    09 p.Sing();
    10 }
    11 }
    12 class Person
    13 {
    14 //静态成员变量
    15 private static int nAge;
    16 //实例成员变量
    17 private string strName;
    18 public static void Run()
    19 {
    20 Console.WriteLine(“我会奔跑!”);
    21 }
    22 public void Sing()
    23 {
    24 Console.WriteLine(“我会唱歌”);
    25 }
    26 }
    当类第一次被加载的时候(就是该类第一次被加载到内存当中),该类下面的所有静态的成员都会被加载。实例成员有多少对象,就会创建多少对象。
    而静态成员只被加载到静态存储区,只被创建一次,且直到程序退出时才会被释放。
    看下面的代码:
    01 class Program
    02 {
    03 static void Main(string[] args)
    04 {
    05 Person p = new Person();
    06 Person p1 = new Person();
    07 Person p2 = new Person();
    08 }
    09 }
    10
    11 class Person
    12 {
    13 //静态成员变量
    14 private static int nAge;
    15 //实例成员变量
    16 private string strName;
    17 public static void Run()
    18 {
    19 Console.WriteLine(“我会奔跑!”);
    20 }
    21 public void Sing()
    22 {
    23 Console.WriteLine(“我会唱歌”);
    24 }
    25 }那么在内存中发生了什么呢?如下图:

    由上面显然可知,定义静态的成员是可以影响程序的执行效率的。那么什么时候定义静态的成员变量呢?
    ①变量需要被共享的时候②方法需要被反复的调用的时候

    转载自https://www.cnblogs.com/yachao1120/p/6551166.html

    展开全文
  • JAVA静态成员和实例成员的加载时机,先有对象还是先load类的静态成员,先有实例还是先调用构造方法等
  • C#—静态成员和实例成员

    千次阅读 多人点赞 2015-09-11 10:09:27
    在C#中,类中的数据成员分为静态成员和实例成员,那么它们是什么,之间又有什么关系呢?我们来看一下。 静态成员(static member)又叫类成员,指的是在成员类型或返回值类型前用static关键字修饰的变量或方法;实例...

      

      前言:我们都知道,类是对象的抽象,对象是类的实例,对象有自己的属性和方法,万物皆对象,不可避免的,类也是一种对象,也有它自己的方法和属性,类的成员称为静态成员,包括静态数据和静态方法,而类实例化出的对象的成员称为实例成员。下面让我们来了解一下C#中的静态成员和实例成员。


      静态成员(static member):又叫类成员,指的是在成员类型或返回值类型前用static关键字修饰的变量或方法,包括静态数据和静态方法;


      实例成员(instance member):又称非静态成员、对象成员,是没有用static修饰的变量或方法,包括实例数据和实例方法。


      不同点:表面看就是有没有被static修饰,其次是在内存分配上,类加载时,静态成员只只分配一次,有且只有一份存储空间。对于实例成员,每产生一个实例都要重新分配一个存储空间。


      特点之静态成员:

      1)静态成员(包括静态数据和静态方法)必须由类名调用,不能使用对象调用(静态数据可以由实例方法调用)。

      2)静态数据属于类的级别,当类加载时,一个静态数据在内存只分配一个存储空间,无论new出多少个实例,它也只是有那一个空间。

      3)静态方法只能调用静态数据,不能调用对象。


      特点之实例成员:

      1)实例成员(包括实例数据和实例方法)必须通过对象来调用,不能使用类名调用。

      2)类的实例数据属于类的实例级别,每新创建一个对象,都会在内存中为实例成员开辟一块新的存储空间。

      3)实例方法可以调用实例数据和静态数据。


      附:我们在C#中经常使用的WriteLine等方法都是静态成员,是直接调用类名Console来使用的。

      让我们来用代码来说明方法对数据的调用情况:

    class Demo
    
    {
        int a;                // 实例数据
        static int b;         // 静态数据
        void A()              // 实例方法
    
        {
            a = 1;             // 正确:实例方法可以调用实例数据
            b = 1;             // 正确:实例方法可以调用静态数据
        }
    
        static void B()       // 静态方法
    
        {
            a = 1;             // 错误:静态方法不能调用实例数据
            b = 1;             // 正确:静态方法可以调用静态数据
        }
    
        static void Main()        // 静态方法
        {
            Demo d = new Demo();  // 实例化对象
            d.a = 1;              // 正确:实例可以调用实例数据
            d.b = 1;              // 错误:实例不能调用静态数据
            Demo.a = 1;           // 错误:类名不能调用实例数据
            Demo.b = 1;           // 正确:类名可以调用静态数据
            d.A();                // 正确:实例可以调用实例方法
            d.B();                // 错误:实例不能调用静态方法
            Demo.A();             // 错误:类名不能调用实例方法
            Demo.B();             // 正确:类名可以调用静态方法
        }
    }

      另外,让我们来用代码说明一下,静态数据只使用一块内存空间:

    public class Demo
    
    {
        static int count=0;  //定义静态数据count
        int number=0;        //定义实例数据number
        public Demo()
        {
    	number =number+ 1;
            count = count + 1;        
        }
    
        public void show()
        {
            Console.WriteLine("number={0} : count={1}", number, count);
        }
    }
    
    class Test
    {
        public static void Main()
        {
            Demo a = new Demo();
            a.show();
            Console.WriteLine("***************");
            Demo b = new Demo();
            b.show();
            Console.WriteLine("***************");
            Demo c = new Demo();
            c.show();
        }
    }
    

      输出结果为:

        number=1 : count=1
        ********************
        number=1 : count=2
        ********************
        number=1 : count=3

      可以看出:静态数据的值是随着实例化出的对象数目而改变的,每增加一个实例化对象都会使静态数据值+1,所以所有的对象都是使用的同一个静态数据,即证明了静态数据公用一块内存空间,而每个对象的实例数据都相同,说明每实例化一次都会开辟一块新的内存空间。


    1

    展开全文
  • 类成员和实例成员的访问

    千次阅读 2017-06-17 16:09:45
    1.类成员和实例成员1)类的成员:字段,方法,内部类;使用static修饰的成员 2)实例成员:没有使用static修饰的成员 3)类成员只能访问类成员,实例成员只能访问实例成员 4)类成员直接属于类,可以通过类来访问static...

    1.类成员和实例成员

    1)类的成员:字段,方法,内部类;使用static修饰的成员
    2)实例成员:没有使用static修饰的成员
    3)类成员只能访问类成员,实例成员只能访问实例成员
    4)类成员直接属于类,可以通过类来访问static字段和static方法。实例成员只属于对象,通过对象来访问非static字段和非static方法(对象其实可以访问类成员,但是底层依然使用类名访问的)

    2.使用类成员跟实例成员的注意事项

    1)在static方法中,只能调用static成员,否则出现”无法从静态上下文中引用非静态变量”
    2)非static方法,可以访问静态成员,也可以访问实例成员
    3)静态成员访问成员变量,该成员变量必须使用static进行修饰

    3.什么时候定义成static的字段和方法

    如果这个状态/行为属于整个事物(类),就直接使用static修饰,被所有对象所共享。在开发中往往把工具方法使用static修饰,如所用到的二分法查找,排序等等,如果不使用static修饰,则这些方法属于该类的对象,我们得创建对象再调用方法,因为创建N个对象会损耗内存,降低性能。在开发中工具对象只需要一份即可,可能创建N个对象,此时我们往往把该类设计为单例,但是还是有点麻烦。所以一般的,在开发设计中,为了调用简单,我们使用static修饰
    “`
    4.类成员使用的优点和缺点

    1)优点:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象都存储一份,可以直接被类名调用
    2)缺点:生命周期过长。因为类成员是随着类的加载而加载的,意味着只要JVM还在运行就会一直存在,而不像实例成员那样,只要对象没有使用了就会被回收

    5.代码:

    package com.JAVABASIS6;
    class ClassDemo2{
    void isDo(){
    System.out.println(“该学习了”);
    }
    }
    public class StaticAndObjectDemo {
    static String name = “成员变量”;
    public static void main(String[] args){
    //如果成员变量前面不用static进行修饰则会报错,Cannot make a static reference to the non-static field name,因为静态变量访问成员变量,该变量必须使用static进行修饰
    System.out.println(name); //输出为”成员变量”
    //当使用这句:ClassDemo2.isDo();//会报错:Cannot make a static reference to the non-static method isDo() from the type ClassDemo2

    }
    }

    展开全文
  • 20180228 java 类成员和实例成员的访问类中的成员:方法、字段、内部类。类成员:使用static修饰的实例成员:没有使用static修饰的成员static只能修饰类内,方法外的成员。类成员只能访问类成员,实例成员只能访问...
  • 下面关于实例成员的说法,哪些是正确的?...实例成员包括实例成员变量和实例成员方法,实例成员变量(对象的字段)和方法(对象的方法)是隶属于对象的,实例成员变量的值代表了该对象的状态,实例成员方法代表了该...
  • java中类的静态成员和实例成员

    千次阅读 2017-08-05 15:03:12
    java中的实例成员包括实例方法和实例成员变量,实例成员都没有被static修饰; 二:使用语法 关于使用静态成员和实例成员的具体语法规则如下: public class Player { public String palyerName = “wade”; public...
  • Java类成员和实例成员

    千次阅读 2011-08-04 09:34:20
    Java类中的成员(属性和方法)可以分成两种,分别... 实例成员中是属于对象的,即属于对象级别的,它包括实例成员属性(也称为实例成员变量)和实例成员方法,只有创建了对象之后才能访问实例成员属性和实例成员方法。
  • python类成员变量和实例成员变量

    千次阅读 2017-05-12 14:52:39
    # python code class Vehicle:  def __init__(self,... self.speed = speed #speed实例成员变量  def drive(self,distance):  print 'need %f hour(s)'% (distance/self.speed) class Bike(Vehicle
  • 2.实例成员:实例的睡醒、方法 (1)例如:$("#id").css()  这里的css()就是一个实例成员。因为$("#id")是一个jquery对象,而对象是一个实例 (2)$.trim()  这里的trim()就是一个静态成员。因为$是一个函数,...
  • js构造函数的静态成员和实例成员

    千次阅读 2017-03-03 18:05:38
    js构造函数的静态成员和实例成员 实例对象的原型链 构造函数的原型链
  • C#实例成员和静态成员

    千次阅读 2011-11-03 13:31:23
    C#类的成员分为两种类型,如下表所示 ...存储对象所需数据的成员,函数可以使用这些数据执行...1、实例成员,默认情况下,所有成员都是实例成员,除非他们是常理或者有前缀static关键字,如 public int ID; pub
  • 类成员只能访问类成员,实例成员只能访问实例成员。类成员,直接属于类,可以通过类来访问static属性和static方法; 实例成员,只属于对象,通过对象来访问非static属性和非static方法。 (对象其实可以访问类成员...
  • 实例成员与类成员

    千次阅读 2018-05-26 10:48:09
    类体中包括成员变量的声明与方法的定义,而成员变量又可以分为实例变量和类变量。在声明成员变量的时候,用关键字Static修饰的为类变量,否则称作实例变量。实例变量与类变量的区别:*不同对象的实例变量互不相同*...
  • 常量或类型声明会隐式地声明为静态成员,其他没有用static修饰的成员都是实例成员(instance member)或者称为非静态成员。静态成员属于类,被这个类的所有实例所共享;实例成员属于对象(类的实例),每一个对象都...
  •  实例成员实例成员变量,实例代码块,实例成员方法  构造方法  析构方法  下面做的实验,主要是验证 当new 一个子类时,子类和它的父类中 静态成员变量,静态代码块,实例成员变量,实例代码块,构造方法 ...
  • 一、C#静态和实例概念 静态概念:公共的、全局的、不属于个别实例的定义。 实例概念:new 出来的具体单个对象。随着作用域定义,使用,销毁(多数实例,通过垃圾回收机制自动销毁)。 静态 实例 关键字...
  • 实例方法必须在类实例化后通过对象来调用,而静态方法可以在类实例化之前就使用。...静态方法在访问本例的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实
  • C# 静态成员与实例成员

    千次阅读 2007-10-21 19:21:00
    静态成员:在类的成员的类型或者...实例成员属于对象(类的实例),每一个对象都有实例成员的不同副本。 下面看一下静态成员和实例成员的特点:静态成员:1>静态成员必须通过类名使用.运算符来引用,而不能用对象
  • Java之实例成员与类成员

    千次阅读 2018-09-23 00:44:25
    类体中的成员变量可细分为实例变量和类变量。用关键字static修饰的称作类变量,否则称为实例变量。例如: class Dog{ float x; //实例变量 static int y; //类变量 } 实例变量与类变量的区别: ①不同...
  • 而调用静态方法的时候,实例成员可能还没有初始化,如果静态方法可以访问实例成员,那么就可能会访问不存在的变量或方法,所以静态方法只能访问静态成员不能访问实例成员,实例方法是可以访问静态成员和实例成员的,...
  • Java线程安全问题之静态成员变量、实例成员变量、局部变量 (原文地址:http://blog.csdn.net/will_awoke/article/details/38044415) java多线程编程中,存在很多线程安全问题,至于什么是线程安全呢...
  • 实例成员和类成员之间的区别

    千次阅读 2007-04-22 10:03:00
    在类中声明一个变量和方法时,可以指定他们是实例成员还是类成员。类成员是指有static保留字修饰的成员变量和成员方法。例:static int classPar;//类成员,classPar为静态变量。int instancePar;//实例成员。那么...
  • 实例成员和静态成员

    千次阅读 2012-05-03 22:17:59
    Instance成员和static成员(p318) 实例变量/函数(instance variable):和一个类定义的实例(对象)密切相关。对同一个类的不同对象,其实例变量占有不同的存储空间。 Static变量(static variable or class ...
  • 静态成员 : 静态成员变量,静态代码块,静态成员方法实例成员实例成员变量,实例代码块,实例成员方法构造方法析构方法 下面做的实验,主要是验证 当new 一个子类时,子类和它的父类中 静态成员变量,静态代码块...
  • 在阅读 TypeScript 文档的时候,经常会看到 类的静态属性 或者类的 类的实例属性 等名词,阅读其他篇章可能会出现另一个 类的静态成员 之类的名词。 把文档中的名词提取出来,分析后就可以发现:这些名词就是称呼多...
  • java中类成员和实例成员调用的区别

    千次阅读 2017-02-10 11:01:48
    在Java中,以static修饰的成员变量和方法成为类成员变量和类方法,其属于整个类而不是属于单个对象。 但是在Java中,允许用Java类的实例–对象来调用类变量,这其实是不符合内部实际运行结果的。 如下代码:public...
  • ③子类实例成员变量(参数列表里初始化,而不是在构造函数体内) ④父类静态成员变量 ⑤父类静态成员函数 ⑥父类实例成员变量 ⑦父类构造函数 ⑧子类构造函数 规则可以总结为: 子类成员变量先于父类成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 725,512
精华内容 290,204
关键字:

实例成员