精华内容
下载资源
问答
  • 一、C#静态和实例概念 静态概念:公共的、全局的、不属于个别实例的定义。 实例概念:new 出来的具体单个对象。随着作用域定义,使用,销毁(多数实例,通过垃圾回收机制自动销毁)。 静态 实例 关键字...

    一、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 项目结构整理

    展开全文
  • 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

    展开全文
  • C# 静态成员和实例成员

    千次阅读 2019-05-14 17:13:14
    前言:我们都知道,类是对象的抽象,对象是类...下面让我们来了解一下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,所以所有的对象都是使用的同一个静态数据,即证明了静态数据公用一块内存空间,而每个对象的实例数据都相同,说明每实例化一次都会开辟一块新的内存空间。

    展开全文
  • JAVA静态成员和实例成员的加载时机,先有对象还是先load类的静态成员,先有实例还是先调用构造方法等
  • 1.静态成员:构造函数的属性、方法 2.实例成员:实例的睡醒、方法 (1)例如:$("#id").css()  这里的css()就是一个实例成员。因为$("#id")是一个jquery对象,而对象是一个实例 (2)$.trim()  这里的trim()...
     
    
    1.静态成员:构造函数的属性、方法
    2.实例成员:实例的睡醒、方法
    (1)例如:$("#id").css()
                这里的css()就是一个实例成员。因为 $("#id")是一个jquery对象,而对象是一个实例
    (2)$.trim()
                   这里的trim()就是一个静态成员。因为$是一个函数,通过函数去访问成员
    3.一般来说会把工具方法作为静态成员,把和对象相关的方法作为实例成员
    展开全文
  • 代码详解了普通成员函数、普通类成员函数静态成员函数的使用方法,已测试,可直接使用
  • C++中静态成员函数访问非静态成员实例 实现代码: #include /* 静态成员函数只能访问静态数据成员、静态成员函数类以外的函数数据,不能访问非静态数据成员,但静态成员函数或静态数据成员可由任意访问许可...
  • js构造函数的静态成员和实例成员

    千次阅读 2017-03-03 18:05:38
    js构造函数的静态成员和实例成员 实例对象的原型链 构造函数的原型链
  • 1.1. 静态成员的声明 在类定义中,关键字 static 声明 不绑定到类实例的成员( 该成员无需创建对象即可访问) 1.2. 静态数据成员的定义 静态数据成员定义的规则 。。。略; 静态数据成员的定义规则复杂,在类...
  • java中类的静态成员和实例成员

    千次阅读 2017-08-05 15:03:12
    一:基本介绍 java中的静态成员包括静态方法和静态成员变量,静态成员都是由static...关于使用静态成员和实例成员的具体语法规则如下: public class Player { public String palyerName = “wade”; public static
  • 在外部调用静态方法时,可以使用"类名....而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。特殊的就是一个类的main方法,都是以public static void限制的,所以这个方法可以
  • 数据成员可以分静态变量、非静态变量两种. 静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名...一个类中也可以包含静态成员和静态成员,类中也包括静态构造函数和非静态构造函数
  • C#—静态成员和实例成员

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

    2019-04-16 16:20:15
    c++静态成员使用实例,是在学习谭浩强老师c++课本的过程中写的
  • 所以有static关键字的属性方法的类的静态成员对象实例都不会去登记内存而仅仅是引用回类的静态成员的内存。 只有不带static的实例成员对象才会去登记内存自己存储起来。 所以静态成员不用new对象就可以直接通过...
  • 静态成员函数静态成员函数的根本区别在于非静态函数由对象名.或者对象指针->调用,调用时编译器会向函数传递this指针;静态成员函数则有类名::或者对象名.调用,编译器不向函数传递this指针,不识别对象个体,...
  • 首先呢我们知道c++类中的成员分为成员变量成员函数两大类,如果再加上static给以区分的话那么会有以下四种:静态成员变量,非静态成员变量;静态成员函数,非静态成员函数  (1)成员变量  我们知道类的静态成员...
  • C++ 静态成员的类内初始化详解及实例代码 一般来说,关于C++类静态成员的初始化,并不会让人感到难以理解,但是提到C++ 静态成员的”类内初始化”那就容易迷糊了。 我们来看如下代码: //example.h #include #...
  • 当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态...静态成员不可在类体内进行赋值,因为它是被所有该类的对象所
  • 一:首先介绍下静态成员和实例成员的区别 说明: 静态成员也称为共享成员,例如静态属性 静态字段 静态方法;静态成员可以在类的实例之间共享。 静态类中只能有静态成员,不能有实例成员,因为静态类不能进行实例化...
  • 不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • 类中静态成员变量普通变量的区别——实例代码(VS2010),已测试,没有问题。
  • 常量或类型声明会隐式地声明为静态成员,其他没有用static修饰的成员都是实例成员(instance member)或者称为非静态成员静态成员属于类,被这个类的所有实例所共享;实例成员属于对象(类的实例),每一个对象都...
  • 静态变量与实例变量的区别 静态变量:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量的内存中有且仅有一个拷贝; 实例变量:实例变量...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • 1.静态成员实例成员 1.1定义及说明 数据成员: 静态成员静态成员变量是类相关联的,可以作为类中”共”有的变量(是一个共性的表现),他不依赖特定对象的存在,访问的时候通过类名加点操作符加变量名来访问. 实例...
  • using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;...namespace _0605_实例类的静态成员和静态类 { class Program { static void Main(st...
  • PHP静态成员变量

    2021-01-20 00:58:47
    可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员. 1、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 346,766
精华内容 138,706
关键字:

静态成员和实例成员