13.C# 定义类成员

1.定义字段

class MyClass
{
   public int MyInt;
}

字段可以用readonly修饰，表示该字段只能在构造函数中赋值，还可以用static表示该字段是静态字段

class MyClass
{
    public int MyInt=17;//注意公共字段使用PascalCasing标准命名，即每个单词首字母大写
    private  int age=18; //私有变量用camelCasing标准命名，首字母小写，之后每个单词首字母大写
    public int StaInt =13;
}

2.定义属性

class MyClass
{
    private int myInt;
    public int MyInt{
        get{return myInt;}
        protected set { myInt=value;}//set访问器只当前类和继承该类的子类能访问
}    }

属性拥有两个类似函数的块，称为访问器，可以忽略其中一个访问器来创建只读或只写属性。访问器可以拥有自己的访问修饰符，但访问性不能高于它所属的属性。属性可以用abstract、virtual、override修饰，但不能用于字段。

C#提供了一种定义属性的简写方式，可以不用定义私有字段，编译器会自动添加一个用于存储该属性的字段，但我们不知道该字段叫什么，无法直接对该字段进行修改。

public int MyInt { get; set; }

3.定义方法

    class MyClass
    {
        public void GetString()
        {
            Console.WriteLine("AAAA");
        }
    }

方法可以用可访问修饰符public、protected、internal、private修饰，默认为private；非访问修饰符virtual、override、abstract、sealed、extern、static修饰，extern表示方法定义放在其他地方

4.隐藏基类方法

当基类的方法不像预期的那样工作时可以使用new关键字隐藏基类的方法，如

    class Program
    {
        static void Main(string[] args)
        {
            MyClass a = new MyClass();
            a.DoingSomething();//子类方法
            MyBaseClass b = a;
            b.DoingSomething();//基类方法
            Console.ReadLine();
        }
    }

    class MyBaseClass
    {
        public void DoingSomething()
        {
            Console.WriteLine("基类方法");
        }
    }

    class MyClass : MyBaseClass
    {
        public new void DoingSomething()
        {
            Console.WriteLine("子类方法");
        }
    }

隐藏基类方法时，使用子类对象调用访问的是子类的方法，使用父类对象调用访问的是父类的方法，注意隐藏和重写的区别，重写时不管用子类还是父类对象调用方法，都将访问的是子类的方法（多态性），如下

    class Program
    {
        static void Main(string[] args)
        {
            MyClass a = new MyClass();
            a.DoingSomething();//子类方法
            MyBaseClass b = a;
            b.DoingSomething();//子类方法
            Console.ReadLine();
        }
    }

    class MyBaseClass
    {
        public virtual void DoingSomething()
        {
            Console.WriteLine("基类方法");
        }
    }

    class MyClass : MyBaseClass
    {
        public override  void DoingSomething()
        {
            Console.WriteLine("子类方法");
        }
    }

5.调用重写或隐藏的基类方法

有时候可能是在父类方法的基础上做修改，这样在重写方法时就需要调用父类的方法，可以使用base关键字调用重写的父类方法

class MyBaseClass
    {
        public virtual string DoingSomething()
        {
            return "父类方法";
        }
    }

    class MyClass : MyBaseClass
    {
        public override string DoingSomething()
        {
            return base.DoingSomething()+ " 子类方法";
        }
    }

注：base代表的是父类的对象实例，所以不能在静态方法中调用

6.this 关键字

this关键字代表当前类的对象实例，可以使用this关键字访问当前对象的实例成员。和base一样this不能用在静态方法中

    class MyClass
    {
        public  void DoingSomething(object o)
        {
            this.WriteSomething(this);//用this调用成员方法，并把当前对象实例传给该方法
        }

        public void WriteSomething(MyClass c)
        {
            Console.WriteLine(c.ToString());
        }
    }

7.接口的实现

    interface IMyInterface
    {
        void DoingSomething();
        void DoingSomethingElse();
    }

    class MyClass : IMyInterface
    {
        public void DoingSomething()
        {
        }

        public void DoingSomethingElse()
        {
        }
    }

也可以在基类中实现接口成员，如

    interface IMyInterface
    {
        void DoingSomething();
        void DoingSomethingElse();
    }

    class MyBaseClass
    {
        public void DoingSomething()
        {
        }
    }

    class MyClass : MyBaseClass
    {
        public void DoingSomethingElse()
        {
        }
    }

父类中实现了方法DoingSomething，子类只要实现剩余的方法即可

以上两种方法是隐式的实现接口，下面是显示实现接口的方法

    interface IMyInterface
    {
        void DoingSomething();
        void DoingSomethingElse();
    }

    class MyClass : IMyInterface
    {
        void IMyInterface.DoingSomethingElse()
        {
        }

        void IMyInterface. DoingSomethingElse()
        {
        }
    }

隐式实现接口和显式实现接口的区别在于：隐式实现接口需要用public修饰实现的成员，而显式实现的成员不能有访问修饰符修饰，并且需要用接口名.成员名限定实现的接口成员。

除了语法上的区别外，显式实现的接口成员只能通过接口访问，隐式实现的成员可以通过接口和类来访问。即

显式实现的接口成员只能用如下方式访问

            IMyInterface b = new MyClass();
            b.DoingSomething();

隐藏实现的可以这两种方式都可以

            MyClass a = new MyClass();

            a.DoingSomething();//子类方法

            IMyInterface b = new MyClass();
            b.DoingSomething();

 8.嵌套类型的定义（内部类）

C#类内部不仅可以定义方法、变量等成员，也可以在类内部定义类，此时内部类不仅能使用public、internal关键字修饰，还可以使用private、protected修饰

public class MyClass
    {
        public class myNestedClass
        {
            public int nestedClassField;
        }

        public myNestedClass GetInternalClass()
        {
            return new myNestedClass();
        }
    }

如果内部类是public或者internal的就可以在MyClass类外部定义内部类的实例，但必须用限定名称

 MyClass.myNestedClass n = new MyClass.myNestedClass();

9.部分类

C#可以使用部分类定义，把类的定义放在多个文件中。如把字段、属性和构造函数放在一个文件，而把方法放在另一个文件。部分类定义对于用来隐藏窗口布局代码非常有用

    public partial class MyClass
    {
        //类体
    }

应用于部分类的接口会应用于整个类，下面两种方式是等价的

方式一：

    public partial class MyClass:IMyInterface1
    {
        //类体
    }

    public partial class MyClass:IMyInterface2
    {
        //类体
    }

方式2：

  public  class MyClass:IMyInterface1,IMyInterface2
    {
        //类体
    }

10.部分方法

可以在部分类中定义部分方法，在一个部分类中定义部分方法，但不包含方法体，在另一个部分类中包含实现代码

    public partial class MyClass
    {
        partial void MyPartialMethod();
    }

    public partial class MyClass
    {
         partial void MyPartialMethod()
         {

         }
    }

部分方法可以是静态的，但是部分方法总是private，且不能有返回值，它们使用的参数也不能是out类型。因为部分方法如果没有方法体，编译器会完全删除该方法。如果方法有返回值，那么该方法就可以作为表达式的一部分，如

int a =Func(a,b)

如果Func是部分方法且没有方法体，那么编译器就不知道怎么执行上一句代码；同样如果输入参数是out类型，因为out类型的参数必须在方法体内赋值，如果没有方法体就会有问题。

分部方法不能具有访问修饰符或 virtual、abstract、override、new、sealed 或 extern 修饰符

原文地址：https://www.cnblogs.com/lidaying5/p/10526692.html

时间： 2024-11-01 12:11:10

13.C# 定义类成员的相关文章

使用prototype 对象定义类成员

使用prototype 对象定义类成员上一节介绍了类的实现机制以及构造函数的实现,现在介绍另一种为类添加成员的机制:prototype 对象.当new 一个function 时,该对象的成员将自动赋给所创建的对象,例如:<script language="JavaScript" type="text/javascript"><!--//定义一个只有一个属性prop的类function class1(){this.prop=1;}//使用函数的pro

C#定义类成员

1.成员定义 public--成员可以由任何代码访问. private--成员只能由类中的代码访问(如果没有使用任何关键字,就默认使用这个关键字). internal--成员只能由定义它的程序集(项目)内部的代码访问. protected--成员只能由类或派生类中的代码访问. 后两个关键字可以合并使用,所以也有protected internal成员.他们只能有项目(更确切地讲,是程序集)中派生类的代码来访问. 也可以使用关键字 static 来声明字段.方法和属性,这表示它们是类的静态成员,而

php类成员函数二次定义，动态定义类成员函数

应用场景:1.动态载入类成员(一些swoole框架,修改的代码需要重载服务器,可以动态多次载入扩展函数文件)2.团队开发写同一个文件的避免冲突,自己单独可以一个扩展文件:3.一个类的代码太多太多,将一些成员函数分解到多个文件中: <?phpclass user{static $funcs=array(); static function ext($method,$func){self::$funcs[$method]=$func;}//调用一个不存在的方法 function __call($fu

让类成员函数指针成为可调用对象

类成员函数指针实践上是一个指针类型,不可直接通过调用运算符()作为可调用对象调用,一般调用该类成员函数指针需要指定该指针对应的对象. 一般情况下调用类成员函数指针: // a.h #ifndef A_H #define A_H #include <iostream> using std::cout; using std::endl; class A{ public:     void print(); }; #endif // a.cpp #include "a.h" vo

PHP 如何定义类、成员属性及其操作与魔术方法

PHP 类的定义与属性 一.类的定义类的关键字定义使用 class :例:class test{ } 二.类的属性与方法 class test{ $name = 'LH' ; //成员属性........ //成员方法........public function t1(){ } }三.定义一个不能继承的类 final class test{ }//final关键字只能修饰类和方法.不能用来修饰成员属性! 四.类.成员属性及方法的声明 1.public //公用的 表示全局的,类内部外部子类都可

《Effective Java 第二版》学习笔记 第13条 使类和成员的可访问性最小化

第四章 类和接口 第13条 使类和成员的可访问性最小化 1.设计良好的模块会隐藏所有的实现细节,把它的API与实现清晰的隔离开来,模块之间只通过它们的API进行通信,一个模块不需要知道其他模块的内部工作情况:即信息隐藏或封装,是软件设计的基本原则之一. 2.Java提供了许多机制来协助信息隐藏.访问控制(access control)机制决定了类.接口和成员的可访问性(accessibility). 3.第一规则:尽可能地使每个类或者成员不被外界访问.或者说在保证功能的情况下,使用最小的访问级别

C++ 定义引用型类成员变量

作者 : 卿笃军 1)早在学习C语言的时候,我们就知道,在定义结构体的时候,不能在结构体中定义该结构体类型的变量: struct node { int a; // struct node b; //错 struct node *next; //对 }; 因为,该结构体还在定义中....不知道结构体里面具体有什么内容,所以无法定义对象b.但是可以定义指针*next. 2)现在,C++里面多出来了一个叫引用的东东(很强大): 引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样.

模板类成员函数的定义和声明为什么要放在一个文件中

"通常情况下,你会在.h文件中声明函数和类,而将它们的定义放置在一个单独的.cpp文件中.但是在使用模板时,这种习惯性做法将变得不再有用,因为当实例化一个模板时,编译器必须看到模板确切的定义,而不仅仅是它的声明.因此,最好的办法就是将模板的声明和定义都放置在同一个.h文件中.这就是为什么所有的STL头文件都包含模板定义的原因."[1] "标准要求编译器在实例化模板时必须在上下文中可以查看到其定义实体:而反过来,在看到实例化模板之前,编译器对模板的定义体是不处理的--原因很简单

在类外部定义类的成员函数

#include <stdio.h> class A {    public:    int b;             void   print1 (); }; void A:: print1() //在类外部定义类的成员函数时候必须加上所属类的类名 { printf("打印"); }  void main() {             A a;    a.print1();    getchar(); }