精华内容
下载资源
问答
  • 2019-03-10 12:05:35

    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

    更多相关内容
  • C++ 静态成员的类内初始详解及实例代码 一般来说,关于C++类静态成员的初始,并不会让人感到难以理解,但是提到C++ 静态成员的”类内初始”那就容易迷糊了。 我们来看如下代码: //example.h #include #...
  • 当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态...静态成员不可在类体内进行赋值,因为它是被所有该类的对象所
  • 静态方法是一种特殊的成员方法,它不属于类的某一个具体的实例,而是属于类本身。所以对静态方法不需要首先创建一个类的实例,而是采用 类名.静态方法 的格式 。 1)static方法是类中的一个成员方法,属于整个类,即...
  • 需要先实例化对象,用对象调用 静态只会执行调用一次,并且在程序退出之前会一直保持状态,占领内存 实例化一次调用一次 先执行静态方法 后执行实例方法 二、C#静态类和实例类 .

    一、C#静态和实例概念

    静态概念:

    公共的、全局的、不属于个别实例的定义。

    加载时调用一次,占领内存,不会销毁。

    实例概念:

    new 出来的具体单个对象。

    随着作用域定义,使用,销毁(多数实例,通过垃圾回收机制自动销毁)。

    静态实例
    关键字static修饰类或方法不能使用static修饰类或方法
    修饰后类直接调用需要先实例化对象,用对象调用
    静态只会执行调用一次,并且在程序退出之前会一直保持状态,占领内存实例化一次调用一次
    先执行静态方法后执行实例方法

     

    二、C#静态类和实例类

    静态类:

    1.全局公共封装类,使用 static class定义。

    2.使用方式:类名.属性 、类名.方法

    3.一般不为静态类,设置构造方法

    4.静态资源程序启动时就加载,即可使用

    常用的底层基础类库不少是静态类

    例如:Syste.Math

    实例类:

    1.最常用的面向对象编程的类 使用class 定义

    2.使用方式 需要 new 出对象后,才能使用。

      FileInfo file = new FileInfo(@"e://one.txt");

     

    三、C#静态成员和实例成员

    静态成员:

    1.静态成员是属于“类”的或者说属于所有对象共有的

    2.静态成员:静态属性,静态方法, 使用static 声明

    3.静态成员,从当前类中可以直接使用; 从其他类中,需要通过 类名.静态成员 使用。

    4.实例方法中可以访问静态成员,静态发放中不能直接访问实例成员。

     

    实例成员:

    1.需要 new 运算执行后才可使用

    2.实例成员,可以归垃圾回收机制销毁,可以自定义销毁

     

    举例说明静态成员使用:

    static void Test2()
    {
        //FileInfo file = new FileInfo(@"e://one.txt");
    
        Student stu1 = new Student();
        stu1.RealName = "张三";
    
        Student stu2 = new Student();
        stu2.RealName = "李四";
        Console.WriteLine($"系统中学生总数量:{Student.AllCount}");//打印2
    }
    
    public class Student
    {
        /// <summary>
        /// 学生总数量
        /// </summary>
        public static int AllCount { get; set; } = 0;
    
        public string RealName { get; set; }
        public Student()
        {
            //没创建一个对象就累计一下
            AllCount++;
        }
    }

     

     

    更多:

     C# 字符串格式化_C# 字符串格式化整理

     C# 字符串拼接整理_C#字符串拼接方式整理

    C# 项目结构整理_.Net 项目结构整理

    展开全文
  • 1:仅包含静态成员。 2:无法实例化。 3:静态类的本质,是一个抽象的密封类,所以不能被继承,也不能被实例化。 4:不能包含实例构造函数。 5:如果一个类下面的所有成员,都需要被共享,那么可以把这个类定义为...
  • java 使用静态成员变量计算内存中实例化的对象数目
  • 可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员. 非...
  • PHP静态成员变量

    2021-01-20 00:58:47
    可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员. 1、...
  • 1.1. 静态成员的声明 在类定义中,关键字 static 声明 不绑定到类实例的成员( 该成员无需创建对象即可访问) 1.2. 静态数据成员的定义 静态数据成员定义的规则 。。。略; 静态数据成员的定义规则复杂,在类...

    1.1. 静态成员的声明


     在类定义中,关键字 static 声明 不绑定到类实例的成员( 该成员无需创建对象即可访问)

     

    1.2. 静态数据成员的定义

     

    静态数据成员定义的规则

    。。。略; 

    静态数据成员的定义规则复杂,在类外定义并初始化且不带static关键字,大部分情况况下不会出错,即使出错咱们也能根据编译器提示的错误信息,快速解决错误点

     

    2. Static member (静态成员)

     

    2.1. 静态数据成员具有静态存储期

     

    2.2. 静态存储期

     

    对象的存储在程序开始时分配,而在程序结束时回收 

    (1)      只存在对象的一个实例(只有一份)

    (2)      静态存储器对象未明确初始化时会被自动“零初始化(待会程序展示)

    3. 实例成员和静态成员

     

    在我下面的例子中,一旦实例化了Square(创建了Square的对象),每个对象中都有各自的side成员。这个side成员就叫做实例成员。 

    而numberOfObjects只存在一个,是由所有的Square对象共享的,叫做静态成员。

     

    class Square 
    {
    
    private:
    
      double side;
    
      static int numberOfObjects;
    
      // ...
    
    public:
    
      Square():Square(1.0){}//这是C++11的代理构造
    
      Square(double side){this->side = side; numberOfObjects++;}
    
      // ...
    
    };//类的声明,可单放在.h文件中
    
    //xx.cpp文件
    int Square::numberOfObjects;//静态成员在类外初始化,不写值,就默认为0,当然可以“ ....= 10;”
    int main() {
    
        Square s1{}, s2{5.0};
    
    }

     

    总结:静态成员函数可以访问静态成员变量

               静态成员函数不可以访问非静态成员变量

               非静态成员函数可以访问静态成员变量

    原因:非静态成员函数有this指针所以可访问该类的所有成员(当然包括属于该类的静态成员变量),静态成员函数没有this指针,故只能访问属于该类静态成员

    关于总结部分,可自己用简单代码验证,可参考以下代码贴图:

     

     

                                                  

    展开全文
  • 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,所以所有的对象都是使用的同一个静态数据,即证明了静态数据公用一块内存空间,而每个对象的实例数据都相同,说明每实例化一次都会开辟一块新的内存空间。

    展开全文
  • 1.Javascript的构造函数中可以添加一些成员,可以在构造函数本身添加,也可以在构造函数的内部的this上添加,通过这两种方式添加的成员,就分别成为静态成员实例成员。 静态成员:在构造函数本上添加的成员称为...
  • #include <iostream> using namespace std; class Data { public: Data() { cout<<"无参构造"<<endl; count++; } Data(const Data &ob) { cout<...
  • 静态类对象,静态类下的静态成员会一直占用在内存且只实例化一次,说明静态类成员的生命周期是从调用到程序结束或机制回收 场景使用 1)静态类或成员:数据库连接字符串,可以定义为静态,调用和获取比较频繁 2)...
  • 静态类与非静态类基本相同,但存在一个区别:静态类不能实例化。也就是说,不能使用 new 关键字创建静态类类型的变量。因为没有实例变量,所以要使用类名本身访问静态类的成员。例如,如果名为 UtilityClass 的静态...
  • 17年3月25号去了广州的CVTE技术面.... 不过我们可以为静态成员提供const整数类型的类内初始值,这样子的话要求静态成员必须是字面值常量类型的 constexpr。  下面给出自己的实现。 #include using names
  • 文章目录类中静态成员变量与静态成员函数的特点静态成员变量示例代码typeid运算符静态成员函数示例代码this指针访问权限 类中静态成员变量与静态成员函数的特点 在类中以static 修饰的变量以及函数称为静态成员变量...
  • 在java中,成员变量分为两种:实例成员变量和静态成员变量。 1.1.1实例成员变量 实例成员变量:是定义在方法外部和类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据 代码示例: class Person ...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • C#的类中可以包含两种方法:静态方法和非静态方法。 使用了static 修饰符的方法为静态方法,反之则是非静态方法。...静态方法效率上要比实例化高,静态方法的缺点是不自动进行销毁,而实例化的则可以做销毁。 3.静
  • C++类静态成员与类静态成员函数 当将类的某个数据成员声明为static时该静态数据成员只能被定义一次而且要被同类的所有对象共享各个对象都拥有类中每一个普通数据成员的副本但静态数据成员只有一个实例存在与定义了...
  • C#—静态成员实例成员

    千次阅读 多人点赞 2015-09-11 10:09:27
    在C#中,类中的数据成员分为静态成员和实例成员,那么它们是什么,之间又有什么关系呢?我们来看一下。 静态成员(static member)又叫类成员,指的是在成员类型或...实例成员属于类的实例(即对象),只能先将类实例化
  • C++的静态成员变量和静态成员函数

    万次阅读 2019-05-22 15:35:41
    与普通的成员变量和成员函数相比,静态成员函数和静态成员变量是属于类的,而不是属于对象的,也就是说,在类实例化为对象之前,静态成员变量和静态成员函数就已经分配了内存空间了,而普通成员函数和成员变量只有在...
  • (1)加上static就是静态成员,不加就是非静态成员。 (2)在一个类中,既可以有静态成员,也可以有非静态资源。 (3)在调用实例成员时,需要使用对象名(实例).实例中的成员。 (4)在调用静态成员的时候,...
  • 静态成员函数访问非静态数据成员【C++】

    千次阅读 多人点赞 2021-05-11 10:33:56
    静态成员函数访问非静态数据成员静态数据成员静态成员函数 静态数据成员 定义格式: static 类型名 静态数据成员名 ; 详解:由于静态数据成员属于本类的所有对象共享,不属于特定类对象,因此在未产生类对象时作用...
  • 只是不需要先实例化外部类再通过外部类的对象,肯定需要通过外部类点的形式获取静态成员的 1 、静态内部类中,只能直接访问外部类的静态成员,如果需要调用非静态成员,通过对象得到实例 2 、静态内部类对象实例...
  • 静态成员与非静态成员的区别

    千次阅读 2019-08-24 10:08:54
    一、静态成员的特点: (1)static数据成员在类的内部声明,但只能在类的外部定义,在类的外部不能指定static,在类的定义时候进行初始; (2)static数据成员只能在类的外部进行初始(特例:当整型const static...
  • C# 静态成员的初始

    千次阅读 2014-05-15 10:18:37
    (2)静态成员实例化。 (3)构造函数先调用父类的,再调用子类。 2)两个类中,静态变量相互引用的情况。但静态变量没有初始化完成的时候,它的值是该变量数据类型默认值(记住这一点很重要)。如int的...
  • 静态成员实例成员

    2017-11-27 14:11:00
    对象成员(实例成员): 没有加static修饰符的属性和方法就是实例成员。实例成员每new一个对象都是新建一个内存地址,每个对象里的实例成员指向的都是各自...类成员(静态成员): 加上static修饰符的方法和属性就是静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 315,799
精华内容 126,319
关键字:

静态成员 实例化