C#学习笔记（八）——定义类的成员

最新推荐文章于 2024-08-25 01:49:33 发布
最新推荐文章于 2024-08-25 01:49:33 发布
阅读量227 收藏 2
点赞数
原文链接：http://www.cnblogs.com/BlueMountain-HaggenDazs/p/4088555.html
版权

一、成员的定义

image

1、定义字段

class Myclass
    {
        public int MyInt;
    }

可以使用readonly关键字，表示这个字段只能在执行构造函数的过程中赋值，或者由初始化语句赋值。

静态成员通过定义它的类来进行访问（MyClass.MyInt） 

 

2、定义方法

class Myclass
    {
        public int MyInt;

        public string GetString()
        {
            return "Here is a string!";
        }
    }

image

与override一样，也可以使用sealed指定在派生类中不能对这个方法作进一步的修改，。

使用extern可以在项目外部提供方法的实现代码。

 

3、定义属性

         get和set区别：get是只读，set是只写。然后get块一定要有一个返回值，下面是示例。

private int myInt;
public int MyIntProp
        {
            get
            {
                return myInt;
            }

            set
            {

            }
        }

        这样的话，由于myInt这个字段是私有的，外部成员时不能访问的，但是通过这个get和set就可以在外部修改了，但是前提是属性是共有的。

        set是一个赋值的功能，但是set可以通过一系列操作来达到不同途径来设置方法。而且还可以这里加上出错的警告之类的。

        然后就是get和set一样也可以在前面加上一系列的限定关键字。例如

protected set 
{
     myInt = value;
}

 

4、一个demo

创建一个MyClass.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Exercise
{
    class MyClass
    {
        public readonly string Name;
        private int intVal;

        public int Val
        {
            get
            {
                return intVal;
            }
            set
            {
                if(value>=0&&value<=10)
                {
                    intVal = value;
                }
                else
                {
                    throw (new ArgumentOutOfRangeException("Val", value, "Val must be assigned a value between 0 and 10."));
                }
            }
        }

        public override string ToString()
        {
            return "Name:" + Name + "\nVal:" + Val;
        }
        public MyClass(string newName)
        {
            Name = newName;
            intVal=0;
        }
    }
}

在Main.cs中添加

#region Using directives

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

#endregion

namespace Exercise
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Creating object myObj...");
            MyClass myobj = new MyClass("My Object");
            Console.WriteLine("myObj created.");

            for(int i=-1;i<=0;i++)
            {
                try
                {
                    Console.WriteLine("\nAttemp to assign {0} to myObj.val...", i);
                    myobj.Val = i;
                    Console.WriteLine("Value {0} assigned to myObj.Val.", myobj.Val);

                }
                catch(Exception e)
                {
                    Console.WriteLine("Exception {0} thrown.", e.GetType().FullName);
                    Console.WriteLine("Message:\n\"{0}\"", e.Message);
                }
            }
            Console.WriteLine("\nOutputting myobj.Tostring()...");
            Console.WriteLine(myobj.ToString());
            Console.WriteLine("myobj.ToString() Output.");
            Console.ReadKey();
            
        }
    }
}

 

二、类的高级议题

1、隐藏基类方法

（1）当从基类中继承一个非抽象的成员的时候，也就继承了其实现代码。

       如果继承的成员时虚拟的，就可以用override重写这段代码。

       无论继承的成员是不是虚拟的，都可以隐藏基类的代码。

public class MyBaseClass
    {
        public void DoSometing()
        {
            //Base implementation
        }
    }

    public class MyDeriveClass:MyBaseClass
    {
        public void DoSometing()
        {
            //Derived class implementation, hides base implementation
        }
    }

         尽管这段代码正常运行,但是还是会有一个waring，可以提醒我们是否有意隐藏这个成员。如果确实要隐藏这个成员，我们可以使用关键字new显式地表明意图。

public class MyDeriveClass:MyBaseClass
    {
        new public void DoSometing()
        {
            //Derived class implementation, hides base implementation
        }
    }

 

（2）如果重写基类中的方法，派生类中的基类方法会被取代，即使是通过基类类型进行的，情况也是相同的。

public class MyBaseClass
    {
        public virtual void DoSometing()
        {
            Console.WriteLine("FUCK");
            //Base implementation
        }
    }

    public class MyDeriveClass:MyBaseClass
    {
        public override void DoSometing()
        {
            Console.WriteLine("FUCK you!");
            //Derived class implementation, hides base implementation
        }
    }

    

MyDeriveClass myObj = new MyDerivedClass();
MyBaseClass myBaseObj;
myBaseObj = myObj;
myBaseObj.DoSomething();

明显，运算结果是FUCK you！

（3）还有就是可以使用隐藏基类的方法实现复写所能实现的功能。

 

2、调用重写或隐藏的基类方法

（1）重要性：

        a、要对派生类的用户隐藏继承的公共成员，但仍能在类中访问其功能。

        b、要给继承的虚拟成员添加实现代码，而不是地重写的新执行代码替换它。

（2）base关键字

         使用base关键字可以使用基类中的隐藏的相应的方法。

base.DoSomething();

（3）this关键字

  a、可以在类内部使用，引用对象的实例。

  b、把当前对象实例的引用传递给一个方法。

  c、限定本地类型的成员。

return this.someData

 

3、嵌套的类型定义

class MyClass
    {
        public class myNestClass
        {
            public int nestedFlassField;
        }
    }

       如果内部定义的类是共有的，那么就可以在外部使用，但是要加上限定名称，例如

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

       如果嵌套的类声明为私有，或者声明为其他与执行该实例化的代码不兼容的访问级别就不能在外部访问。

 

三、接口的实现

1、定义方法

interface IMyInterface
    {

    }

接口成员的定义与类相似，但是有一些重要的区别：

image

但是如果要隐藏继承了基接口的成员，可以用关键字new来定义他们。

在接口中定义的属性可以定义访问块get和set中的哪一个能够用于该属性~~~~~~~~~~~~

interface IMyInterface
    {
        int MyInt(get;set;)
    }

 

2、在类中实现接口

         实现接口的的类必须包含该接口所有成员的实现代码，且必须匹配指定的签名（包括匹配指定的get和set快），并且必须是公共的。

interface IMyInterface
    {
        void DoSomething();
        void DoSomethingElse();
    }

    public class Myclass:IMyInterface
    {
        public void DoSomething()
        {

        }
        public void DoSomethingElse()
        {

        }
    }

       可以使用virtual 或者abstract来实现接口成员。还可以在基类上实现接口。

interface IMyInterface
    {
        void DoSomething();
        void DoSomethingElse();
    }

    public class Myclass:IMyInterface
    {
        public void DoSomething()
        {

        }
    }

    public class MyDerivedClass:Myclass,IMyInterface
    {
        public void DoSomethingElse()
        {

        }
    }

     继承一个实现给定的基类，就意味着派生类隐式地支持这个接口。

     当然如果基类中的方法定义为虚拟，那么派生类就可以替代这个方法，而不是隐藏它们。

（1）显示实现接口成员。

      如果显示地实现接口成员，那么这个成员就是能通过接口来访问，不能通过该类来访问。

通过类访问：

Myclass myobj = new Myclass();
myobj.DoSomething();

通过接口访问:

Myclass myobj = new Myclass();
IMyinterface myInt = myobj;
myInt.DoSomething();

（2）用非公共的可访问性添加属性存取器

      简单的来说就是接口中如果定义了set而没有定义get，那么get就可以在类中添加，并且它的限制级更高。

 

四、部分类定义

          就是使用部分类定义，把类的定义放在多个文件中。我们只需要在每个包含部分类定义的文件中对类使用partial关键字就好。

public partical class MyClass
{
}

           应用于部分类的接口也会应用于整个类..

         部分类只能继承同一个基类,因为C#规定类只能继承一个基类.

 

五、部分方法定义

        在一个部分声明，另一个部分实现（同C++）

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

public partical class MyClass
{
     partical void MypartialMethod()
     {
     }
}

 

六、一个demo

//这是卡片类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Ch10CardLib
{
    public class Card
    {
        public Rank rank;
        public Suit suit;
    
        private Card()
        {
            throw new System.NotImplementedException();
        }

        public Card(Suit newSuit, Rank newRank)
        {
            suit = newSuit;
            rank = newRank;
        }

        public string Tostring()
        {
            return "The" + rank + "of" + suit + "s";
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//这是一副牌
namespace Ch10CardLib
{
    public class Deck
    {
        private Card[] cards;
    
        public Deck()
        {
            cards = new Card[52];
            for (int suitVal = 0; suitVal < 4; suitVal++)
            {
                for (int rankVal = 1; rankVal < 14; rankVal++)
                {
                    cards[suitVal * 13 + rankVal - 1] = new Card((Suit)suitVal, (Rank)rankVal);
                }
            }
        }

        public Card Getcard(int cardNum)
        {
            if(cardNum>=0&&cardNum<=51)
                return cards[cardNum];
            else
                throw(new System.ArgumentOutOfRangeException("cardNum",cardNum,"Value must between 0 and 51"));
        }

        public void Shuffle()
        {
            Card[] newDeck = new Card[52];
            bool[] assigned = new bool[52];
            Random sourceGen = new Random();
            for(int i=0;i<52;i++)
            {
                int destCard=0;
                bool foundCard=false;
                while(foundCard==false)
                {
                    destCard = sourceGen.Next(52);
                    if(assigned[destCard]==false)
                    {
                        foundCard = true;
                    }
                }
                assigned[destCard]=true;
                newDeck[destCard]=cards[i];
            }
            newDeck.CopyTo(cards,0);
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

//枚举
namespace Ch10CardLib
{
    public enum Rank
    {
        Ace = 1,
        Deuce,
        Three,
        Four,
        Five,
        Six,
        Seven,
        Eight,
        Nine,
        Ten,
        Jack,
        Queen,
        King,
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Ch10CardLib
{
    public enum Suit
    {
        Club,
        Dimaond,
        Heart,
        Spade,
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Ch10CardLib;
//主程序
namespace Ch10CardClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Deck myDeck = new Deck();
            myDeck.Shuffle();
            for(int i=0;i<52;i++)
            {
                Card tempCard = myDeck.Getcard(i);
                Console.WriteLine(tempCard.Tostring());
                if (i != 51)
                    Console.Write(", ");
                else
                    Console.WriteLine();
            }
            Console.ReadKey();
        }
    }
}

image

最后的最后，记住一点很好用的地方：

那就是用在类图处，可以直接使用工具栏提供好的类、枚举之类的工具快速创建，十分方便。

image

转载于:https://www.cnblogs.com/BlueMountain-HaggenDazs/p/4088555.html

KEVINZHAO124517
关注
第七篇 定义类成员
chenxl929的博客
06-20 611
1 成员定义        这里的成员包括字段，属性，方法。字段类似于C++的成员变量；属性是一个很独特的成员，一般用于访问私有字段；方法与C++的成员函数类似。成员都提供四种访问 性。        pubilic--------------------成员可以由任何代码访问        private--------------------默认此关键字，成员只能由类中的代码访问  
练习代码----第一天
ruin987的博客
07-22 205
C++
类的定义、数据成员与成员方法
weixin_42761339的博客
11-15 1206
私有成员与公有成员： class A: def __init__(self,value1=0,value2=0): #构造方法 self._value1=value1 self.__value2=value2 #私有成员 def setValue(self,value1,value2): ...
C++语言学习（八）—— 继承、派生与多态（二）
最新发布
歆歆~黯了
08-25 748
多继承、多态、运算符重载、赋值兼容规则、虚函数
【C#】类_封装_成员属性
guai006的博客
12-18 363
用于保护成员变量。
c++类的成员变量详解
m0_49133355的博客
07-18 424
C++ 类的成员变量是类的一部分，用于存储类的状态或属性。C++ 提供了多种类型的成员变量，包括普通成员变量、静态成员变量、常量成员变量、可变成员变量（mutable）和引用成员变量。理解和使用这些成员变量类型，可以帮助开发者更好地设计和实现类及其行为，确保数据的封装和安全性。引用成员变量：指向其他变量的引用，必须在初始化列表中初始化。私有成员变量：只能在类内部访问，通常通过公共成员函数访问。保护成员变量：在类外部不可访问，但在派生类中可以访问。普通成员变量：每个对象有自己独立的成员变量。
C#学习笔记——基本语法
08-31
类是对象的蓝图，它定义了对象的属性（成员变量）和行为（成员函数）。例如，`class Rectangle` 定义了一个矩形类，包含了长度和宽度属性以及计算面积和显示信息的方法。 3. **注释**：注释用于提高代码的可读性，...
C#学习笔记之——调用C++
07-15
### C#调用C++知识点详解 #### 一、引言 随着软件开发技术的不断发展，跨语言编程已经成为一种常见的需求。特别是在企业级应用中，往往需要利用不同语言的优势来构建更加高效、灵活的系统。C#作为一种面向对象的...
C#学习笔记004——生成（创建）文本文件
SYW的博客
09-07 5093
———————————— C#：生成（创建）文本文件 ————————————— 很重要的一个头文件：using System.IO; 很重要的类：StreamWriter、StreamWriter、File — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — 法一：作为一个初级自学菜鸟（分不清StreamWriter和StreamWriter，也搞不懂他们怎么用），我最常用的方法 必要控件：一个Button + 一个 TextBox
C#学习笔记——类和对象篇
Lcl_huolitianji的博客
08-16 602
Unity3D数字孪生开发笔记——（五）一、枚举1、简单枚举2、标志枚举（Flags）3、按位运算符4、数据类型转换二、类和对象1、什么是类什么是对象1>类和对象2>创建类3>创建对象2、构造函数3、访问修饰符4、this关键字5、属性1>自动属性6、类构造7、static 一、枚举 1、简单枚举 列举某种数据的所有取值 作用：增强代码的可读性，限定取值 语法：enum 名字{值1、值2、值3、值4……} 枚举元素默认为int，准许使用枚举类型有byte、sbyte、short、u
c#系列学习笔记——枚举
m0_57781768的博客
11-20 397
C#枚举介绍。
【C++】泛型编程 ⑥ ( 类模板 | 类模板语法 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-18 322
一、类模板 1、类模板引入 2、声明类模板语法 3、调用类模板语法 二、代码示例 - 类模板 1、代码示例 2、执行结果
C++学习笔记--引用作为返回值：用引用接收和用变量接收的区别
游戏码农一枚，不定时分享技术文章~
01-30 480
编译器会创建一个新的对象，并使用返回的引用来初始化这个新的对象。这个新的对象将拥有与原始对象相同的值，但是它是一个独立的对象，与原始对象没有直接关联。在C++中，当一个函数返回一个对象的引用时，这意味着函数返回的是对某个对象的引用，而不是一个新的对象。如果调用方使用引用来接收返回值，那么它将直接引用原始对象，对原始对象的任何修改都会反映在原始对象上。如果一个C++函数返回一个对象的引用，但是调用方并没有使用引用来接收返回值，那么返回的引用将会被拷贝给调用方，从而创建一个新的对象。
Java反射初探 ——“当类也学会照镜子”
Java团长
09-23 470
正文 反射的作用   开门见山地说说反射的作用   1.为我们提供了全面的分析类信息的能力 2.动态加载类   我理解的“反射”的意义 （仅个人理解哈）   我理解的java反射机制就是： 提供一套完善而强大的API“反射“类的结构。 打个比方，反射机制就像是一面镜子，而类就像是一个在照着镜子的人。 镜子（反射机制）照出（反射）了人的全貌（类的全方位的信息，例如方法，
C++的面向对象学习(5)：对象的重要特性:对象的成员变量和成员函数深入研究
qq_53092944的博客
12-22 470
使用公有成员函数：在类中定义公有成员函数，通过这些函数来访问和修改私有成员变量。这种方法可以提供对私有成员变量的控制和封装。使用友元函数：在类中声明友元函数，使其能够访问类的私有成员变量。友元函数可以是全局函数，也可以是其他类的成员函数。友元函数可以直接访问类的私有成员变量，但会破坏封装性。使用友元类：在类中声明友元类，使其能够访问类的私有成员变量。友元类的所有成员函数都可以访问类的私有成员变量。友元类可以提供更多的灵活性和控制，但同样会破坏封装性。
【C++】C++11介绍
ZHENGZJM的博客
04-12 2320
简单介绍一下C++11
explicit关键字详解
weixin_40026739的博客
03-11 383
在C++中，explicit关键字用于声明只能通过显式调用来调用的单参数构造函数（即只接受一个参数的构造函数）。这样的构造函数默认可以用于隐式类型转换，但使用了explicit关键字后，禁止了隐式转换，只能通过显式调用来使用。
计算机考试c++语言程序设计,2014年3月计算机二级考试真题：C++语言程序设计（网友版）...
weixin_30019517的博客
05-17 239
全国计算机等级考试热点-备考方案不断更新中......敬请期待！！无忧考网计算机等级考试频道2．下列叙述中正确的是(　)。A．一个逻辑数据结构只能有一种存储结构B．逻辑结构属于线性结构，存储结构属于非线性结构C．一个逻辑数据结构可以有多种存储结构，且各种存储结构不影响数据处理的效率D．一个逻辑数据结构可以有多种存储结构，且各种存储结构影响数据处理的效率3．下列叙述中正确的是(　)。A．一个算法的空...
ArcEngine C# 二次开发技术笔记——64页精华
"这是一份关于ArcEngine+C#二次开发的技术笔记，总计64页，内容涵盖丰富的ArcGIS开发知识，对于学习者来说非常有价值。笔记中涉及到如何创建或打开shapefile，以及与之相关的接口和类的使用，如IWorkspace、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值