威尼斯人线上娱乐

【威尼斯人线上娱乐】品质和字段的驾驭,密封属性

2 5月 , 2019  

1、始终使用品质(Property),而不是字段(Data Member)

  C#
属性已经提高为一等国民,假若你的类中还有public的字段,Stop。访问属性和字段的艺术是一致的,可是属性是用艺术(methods)完结的。

当有新的须求,通过修改属性来完成比在先后里面修改全体的public字段来落成要求,轻松太多。

因为属性是措施达成的,所以属性具有方法所负有的凡事,能够固定为virtual:,能够扩张为 abstract,和 interface
的1有的,还足以定义差别的造访等级,来更加好的调整类的分子的访问

  举个例子定义了三个类 customer,你发觉没有检查 customer
姓名不能够为空。假诺选择了性能能够很轻巧的丰盛查询姓名无法为空。如下:

 public class customer
    {
        public int customerId { get; set; }

        private string _customerName;
        public string customerName
        {
            get
            {
                return _customerName;
            }
            set
            {
                if ((value == null) || (value.Length == 0))
                {
                    throw new ArgumentException("客户名称不能为空", "customerName");
                }
                _customerName = value;
            }
        }

   

  举例要兑现同步访问,能够:

 public class customer
    {
        private int _customerId;
        public int customerId
        {
            get
            {
                lock (this)
                {
                    return _customerId;
                }
            }
            set
            {
                lock (this)
                {
                    _customerId = value;
                }
            }
        }
}

    总计:使用性质对于急需调换有越来越强的适应性,更方便的改变完结方式。

 

网络采撷的这几个,认为还能够
函数等联谊在一个个的单元中(大家称之为类)。被打包的目标经常被誉为抽象数据类型。在本文中,我们将详细学习属性的特点。
装进的概念
能够把程序按某种规则分成大多“块“,块与块之间或然会有关联,每一个块都有三个可变部分和1个平安无事的一对。大家供给把可变的一些和平安的部分分离出来,将牢固的有个别揭破给其它块,而将可变的有的隐藏起来,以便于随时能够让它修改。那项职业正是封装.
诸如:在用类落成有个别逻辑的时候,类就是上述所说的块,达成效益的实际代码正是可变的有个别,而public的主意大概性质则是安静的局地。
打包的意思

网络搜集的那个,认为还不易
函数等聚焦在一个个的单元中(大家称之为类)。被卷入的对象一般被叫作抽象数据类型。在本文中,大家将详细学习属性的天性。
包裹的概念
能够把程序按某种规则分成繁多“块“,块与块之间或者会有牵连,每一个块都有贰个可变部分和3个平安的一对。大家须求把可变的一些和安乐的部分分离出来,将平稳的有个别揭露给其余块,而将可变的有的隐藏起来,以便于随时可以让它修改。那项专门的职业正是封装.
比如说:在用类落成有些逻辑的时候,类正是以上所说的块,达成效益的现实代码便是可变的部分,而public的主意依然性质则是平静的有的。
卷入的含义

1.属性和字段的精通:

大家了解,类成员包涵变量和章程。固然希望别的类能够访问成员变量的值,就非得定义成公有的,而将变量设为公有public,那这一个成员变量的就足以被轻松拜访(包罗修改,读取),这样不便宜数据安全。
C#经过品质天性读取和写入字段(成员变量),而不直接直接读取和写入,以此来提供对类中字段的保卫安全。属性可用于类内部封装字段。属性是C#面向对象才干中封装性的反映。

只顾:字段正是类的积极分子变量,为合作属性而这么称呼的。

封装的意义在于保护或者防止代码(数据)被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的原素并且和使用它的函数结合的很密切,从而保护它不被其它的函数意外的修改。
封装提供了一个有效的途径来保护数据不被意外的破坏。相比我们将数据(用域来实现)在程序中定义为公用的(public)我们将它们(fields)定义为私有的(privat)在很多方面会更好。
私有的数据可以用两种方式来间接的控制。下面我们看一些c#例子来学习这两种方法用以封装数据。第一种方法,我们使用传统的存、取方法。第二种方法我们用属性(property)。无论我们使用哪种的方法,我们的目标是在使用数据的同时不能使它受到任何的破坏和改变。有如下好处

其一: 使用者只需要了解如何通过类的接口使用类,而不用关心类的内部数据结构和数据组织方法。
其二:高内聚,低耦合一直是我们所追求的,用好封装恰恰可以减少耦合
其三:只要对外接口不改变,可以任意修改内部实现,这个可以很好的应对变化
其四:类具有了简洁清晰的对外接口,降低了使用者的学习过程
用传统的读、写方法封装

让我们来看一个例子有一个类Department,为了操纵这个类中的数据(string departname)我们定义了一个读方法和一个写方法。
using system;
public class Department
{
private string departname;
.......
// 读方法
public string GetDepartname()
{
return departname;
}
//写方法
public void SetDepartname( string a)
{
departname=a;
}
}
通过上面的方法,我们可以保护私有数据不被外部程序所破坏。

常用的是使用这个!!!!
c#使用属性封装 
1、使用属性封装方法
2、AccessModifer Type PropertyName
{get{...}set{...}
}
public int {get{ return this.X}set{this.x=rangeCheckX(value)}
}
2、属性对某个字段封装时,命名规则,首字母大写
private int employeeID;public int EmployeeID
{get{return this.EmployeeID;};set{this.EmployeeID=value}
}
3、接口中定义属性
interface IScreenPosition
{
int X{get;set;}
int Y{get;set;}
}


4、实例化同时赋值
static void DoWork()
        {
            Polygon square = new Polygon();
            Polygon triangle = new Polygon { NumSides = 3 };
            Polygon pentagon = new Polygon { SideLength = 15.5, NumSides = 5 };

            Console.WriteLine("Square: number of sides is {0}, length of each side is {1}", 
                square.NumSides, square.SideLength);
            Console.WriteLine("Triangle: number of sides is {0}, length of each side is {1}", 
                triangle.NumSides, triangle.SideLength);
            Console.WriteLine("Pentagon: number of sides is {0}, length of each side is {1}", 
                pentagon.NumSides, pentagon.SideLength);
        }



详细请看它::::
c#中的属性 
封装的意义在于保护或者防止代码(数据)被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的原素并且和使用它的函数结合的很密切,从而保护它不被其它的函数意外的修改。
封装提供了一个有效的途径来保护数据不被意外的破坏。相比我们将数据(用域来实现)在程序中定义为公用的(public)我们将它们(fields)定义为私有的(privat)在很多方面会更好。
私有的数据可以用两种方式来间接的控制。下面我们看一些c#例子来学习这两种方法用以封装数据。第一种方法,我们使用传统的存、取方法。第二种方法我们用属性(property)。无论我们使用哪种的方法,我们的目标是在使用数据的同时不能使它受到任何的破坏和改变。有如下好处

其一: 使用者只需要了解如何通过类的接口使用类,而不用关心类的内部数据结构和数据组织方法。
其二:高内聚,低耦合一直是我们所追求的,用好封装恰恰可以减少耦合
其三:只要对外接口不改变,可以任意修改内部实现,这个可以很好的应对变化
其四:类具有了简洁清晰的对外接口,降低了使用者的学习过程
用传统的读、写方法封装

让我们来看一个例子有一个类Department,为了操纵这个类中的数据(string departname)我们定义了一个读方法和一个写方法。
using system;
public class Department
{
private string departname;
.......
// 读方法
public string GetDepartname()
{
return departname;
}
//写方法
public void SetDepartname( string a)
{
departname=a;
}
}
通过上面的方法,我们可以保护私有数据不被外部程序所破坏。

常用的是使用这个!!!!
c#使用属性封装 
1、使用属性封装方法
2、AccessModifer Type PropertyName
{get{...}set{...}
}
public int {get{ return this.X}set{this.x=rangeCheckX(value)}
}
2、属性对某个字段封装时,命名规则,首字母大写
private int employeeID;public int EmployeeID
{get{return this.EmployeeID;};set{this.EmployeeID=value}
}
3、接口中定义属性
interface IScreenPosition
{
int X{get;set;}
int Y{get;set;}
}


4、实例化同时赋值
static void DoWork()
        {
            Polygon square = new Polygon();
            Polygon triangle = new Polygon { NumSides = 3 };
            Polygon pentagon = new Polygon { SideLength = 15.5, NumSides = 5 };

            Console.WriteLine("Square: number of sides is {0}, length of each side is {1}", 
                square.NumSides, square.SideLength);
            Console.WriteLine("Triangle: number of sides is {0}, length of each side is {1}", 
                triangle.NumSides, triangle.SideLength);
            Console.WriteLine("Pentagon: number of sides is {0}, length of each side is {1}", 
                pentagon.NumSides, pentagon.SideLength);
        }



详细请看它::::
c#中的属性 

贰.属性和字段的分别

品质是逻辑字段;属性是字段的增加,源于字段;

质量并不占用实际的内部存款和储蓄器,字段占内部存款和储蓄器地方及空间。

质量能够被其它类访问,而多数字段不能够一向访问。

品质能够对抽出的数目范围作限定,而字段不能够。

质量与字段都可在目的中存储和寻觅新闻。

在以下情状下采纳品质进度:
1.
急需调节装置或检索值的流年和艺术时。
2.
性质有定义完善的一组值须要开始展览求证时。
三.
设置值导致对象的意况产生一些鲜明的变迁(如 IsVisible 属性)。
4.
安装属性会招致更动别的中间变量或其余质量的值时。
伍.无法不先进行1组步骤,然后技巧安装或探索属性时。
在以下意况下选择字段:

  1. 值为自验证类型时。举例,假使将 True 或 False
    以外的值赋给 Boolean 变量,就能够发出错误或自行数据转变。
  2. 在数据类型所支撑范围内的其他值均有效时。Single
    或 Double 类型的许多属性属于那种情景。
  3. 质量是 String
    数据类型,且对于字符串的尺寸或值未有别的约束时

总的说来,(也正是扩展了数量的安全性)最直白的说:属性是被“外部使用”,字段是被“内部使用”。

 

引进属性的独到之处

1.保卫安全个人字段(保障类的封装性)

二.可决定访问(只读/只写,确认保障赋值的不易等)

三.不用重视细节(直接运用,无需思量复杂的拍卖代码)

如何意况下抉择采用字段照旧属性?


例子中可看到属性其实正是对私有字段的读取和写入,以便做些公有字段不可能到位的任务,他的施用办法和国有字段完全一样,所以能够驾驭成属性是为了满意对公
有字段的非正规需要而发出的附属品。由此当大家挑选采用性质仍旧使用字段时,主要看需要,要是不需安装访问权限、不需在赋值时检查评定值是不是满足供给、无需在
赋值时修改对象其余一些情景等卓绝的须求时,使用国有字段就可以,不然就动用性质。

1.
假若类中的字段不被外面访问,仅在类的中间接选举择,那么就向来定义成字段

2.威尼斯人线上娱乐
借使类中的字段或许被外边访问并且操作,那么就将字段定义成属性

  
在C#中大家能够很随便的走访共有字段,但神蹟大家大概要求某字段只可以读可能写,或在改造字段值得时候做一些其余作业,鲜明那几个但是重视字段是无法落到实处的,于是便有了质量。 
   壹、基本用法
  
c#中的属性由属性功效域中定义的get功能域(访问方法)和set功效域(访问方法)构成。
class Test
{
private int number;

  
在C#中大家得以很轻巧的拜访共有字段,但偶尔我们或然须要某字段只可以读或然写,或在转移字段值得时候做一些别的职业,显明那一个只是信赖字段是无能为力得以实现的,于是便有了品质。 
   一、基本用法
  
c#中的属性由属性成效域中定义的get功用域(访问方法)和set成效域(访问方法)构成。
class Test
{
private int number;

三.属性和字段的选取

  1. 字段:

class Card

   private string Name;
}

  1. 属性:

属性中隐含几个模块:set和get,set模块担当属性的写入专业,get模块担当属性的读取专门的学业。在八个模块中都能够做一些别样操作,如在set中验证赋的值是或不是符合供给并垄断(monopoly)是不是开始展览赋值。

class Card
{
    private string name;
    public string Name
    {
【威尼斯人线上娱乐】品质和字段的驾驭,密封属性。        get { return
this.name;}
        set {
this.name=value;}
     }

例:

class Product   //商品类

    {

        //私有字段

        private string _Pname;    //商品名称

        private bool _IsNoEmperty;//是或不是有仓库储存

        private float _Price;     //商品单价

        private int _PCount;      //商品数量

        //属性:

        //可读写

        public string Pname

        {

            set { _Pname = value; }

            get { return _Pname; }

        }

        //只读

        public bool IsNoEmperty

        {

            get { return _IsNoEmperty; }

        }

        //可检查测试赋值是或不是精确

        public float Price

        {

            set

            {

                if (value >= 0)

                    _Price = value;

                else

                    throw new Exception(“Price的赋值范围”);

            }

            get

            {

                return _Price;

            }

        }

        //赋值时改动其余情况

        public int PCount

        {

            set

            {

                _PCount = value;

                _IsNoEmperty = true;   //改变了_IsNoEmperty字段的值

            }

            get { return _PCount; }

        }

        public void Print()

        {

            Console.WriteLine(“产品新闻如下:”);

            Console.WriteLine(“产品名称:{0}”,_Pname);

            Console.WriteLine(“产品价格:{0}”, _Price);

            Console.WriteLine(“仓库储存数据:{0}”, _PCount);

Console.ReadLine();

        }

        static void Main(string[] args)

        {

            Product P1=new Product();

            P一.Pname=”黄种人牙膏(克)”;

            P1.Price=5;

            P1.PCount=20;

            P1.Print();

        }

 

例:
//有个网址,每当有新用户注册的时候,大家须要记录那几个用户的音讯   
class User   
{   
    //姓名,性别   
    public string name;   
    public string sex;   
}   
//声飞鹤个类去行使User类   
class Property   
{   
    static void Main()   
    {   
        //实例化多个User对象   
        User zs = new User();   
        //对其赋值   
        zs.name = “张三”;   
        zs.sex = “男”;   
        Console.WriteLine(“姓名:” + zs.name + ” 性别:” + zs.sex);   
    }   
}

通过编写翻译实施,那段代码平常运作,可是仔细分析,就能够开采:全体字段都以国有的,不便利字段的保卫安全,只要实例化了那些类,都得以修改个中的值。假诺性别输入了孩子之外的字符,系统是不会识其余。比方把zs.sex
= “男”;改成zs.sex
= “牛”;。运行代码结果自然张三的性别成牛了…那个时候就不合逻辑了。修改为:
class User   
{   
    public string name;   
    public string sex;   
    //SetSex方法   
    public void SetSex(string values)   
    {   
        if (values == “男” || values == “女”)   
        {   
            sex = values;   
        }   
        else 
        {   
            Console.WriteLine(“性别只可以为“男”或“女””);   
        }   
    }   
}   
class Property   
{   
    static void Main()   
    {   
        User zs = new User();   
        zs.name = “张三”;   
        //直接调用SetSex赋值   
        zs.SetSex(“牛”);   
        Console.WriteLine(“姓名:” + zs.name + ” 性别:” + zs.sex);   
    }   
}

SetSex这几个情势乍1看仍是能够,不过不用遗忘name和sex字段依然public属性,我们照例能够向来去调用它,也许说去修改它,一样能够把sex设为“牛”。给类的字段设置为public意味着破坏了类的包裹,那样啊会存在潜在的险恶。所以呢要设为private,这一年就各自证明方法去读取和设置那贰个字段,修改如下:

using System;   
class User   
{   
    //设为民用的   
    private string name;   
    private string sex;   
    //设置   
    public void SetName(string values)   
    {   
        name = values;   
    }   
    //读取   
    public string GetName()   
    {   
        return name;   
    }   
    public void SetSex(string values)   
    {   
        if (values == “男” || values == “女”)   
        {   
            sex = values;   
        }   
        else 
        {   
            Console.WriteLine(“性别只可以为“男”或“女””);   
        }   
    }   
    public string GetSex()   
    {   
        return sex;   
    }   
}   
class Property   
{   
    static void Main()   
    {   
        User zs = new User();   
        zs.SetName(“张三”);   
        zs.SetSex(“牛”);   
        Console.WriteLine(“姓名:” + zs.GetName() + ” 性别:” + zs.GetSex());   
    }   
}

到现在以此类的规划就相比较合理了,大家看name和sex它们是private字段,也便是说在类的表面是不能访问的,那样吧就确认保证了它的安全性。当用户想给性别字段增多违法字段的时候,SetSex方法内会对这些增加的值实行剖断,借使不为男或女,值就不会被拉长。通过艺术固然减轻了上边的标题,不过每创制3个目的,输入字段值时就非得调用上面方法。假若不知晓,就不能调用。为了拉长多少安全性,并且有效减轻地点的难点,C#推出了质量。能够创制属性,将字段和质量封装在一同。通过质量能够像访问字段同样访问数据成员,完毕数量的包裹,防止接纳私下数据赋值,保障数据完整性,同时类内部发生修改时,制止一切程序的更动。

 

 

    //int表示该属性所封装的数据类型
    //数据类型必须与相应的字段(number)相同   
    public int Num
    {
        get{return number;}
        set{number=value;}
    }
}
    //int表示该属性所封装的数据类型
    //数据类型必须与相应的字段(number)相同   
    public int Num
    {
        get{return number;}
        set{number=value;}
    }
}

悍然外露:

 

  
当封装数据时,大概希望配置1个只读属性。为此,能够忽略set块。类似,如若想具备三个只读属性,就忽略get块。 
   二、静态属性  
  
C#静态属性可以是读写属性,只读属性,只写属性中的任性一种。静态访问器适用于全部类,而不是类的实例。静态属性中的set,get访问器只可以访问类的静态成员。静态属性可以经过类名访问,不能够动用实例调用,那与静态方法同样。
//轻松的积蓄账户类
class SavingAccount
{
//实例等第的数目
public double currBalance;

  
当封装数据时,恐怕希望配置三个只读属性。为此,能够忽略set块。类似,要是想有所二个只读属性,就大要get块。 
   二、静态属性  
  
C#静态属性能够是读写属性,只读属性,只写属性中的自便一种。静态访问器适用于壹体类,而不是类的实例。静态属性中的set,get访问器只好访问类的静态成员。静态属性能够由此类名访问,无法应用实例调用,那与静态方法一样。
//轻松的积蓄账户类
class SavingAccount
{
//实例品级的数量
public double currBalance;

   //静态数据点 
   private static double currInterestRate = 0.04; 

   //静态属性
   public static double InterestRate
   {
     get{return currInterestRate;}
     set{currInterestRate=value;}
   }                    
 }
   //静态数据点 
   private static double currInterestRate = 0.04; 

   //静态属性
   public static double InterestRate
   {
     get{return currInterestRate;}
     set{currInterestRate=value;}
   }                    
 }

 
   三、自动属性
  
自动属性可以简化封装数据字段的历程,缓和了概念私有重临字段和连锁c#质量成员的干活。在概念自动属性时,只钦定访问修饰符、实际的数据类型、属性名称和空的get/set功效域。在编写翻译时,编译器为项目自动生成了民用重临字段和适用的get/set完毕逻辑。
class Enemy
{
//自动属性
public string Name{get;set;}
public int Life{get;set;}
public float Attack{get;set;}

 
   三、自动属性
  
自动属性能够简化封装数据字段的长河,缓和了定义私有重返字段和有关c#属性成员的行事。在概念自动属性时,只内定访问修饰符、实际的数据类型、属性名称和空的get/set功效域。在编写翻译时,编写翻译器为品种自动生成了个体重临字段和适合的get/set达成逻辑。
class Enemy
{
//自动属性
public string Name{get;set;}
public int Life{get;set;}
public float Attack{get;set;}

 }
 }

  
注意:与价值观的性质分化的是,分化意构建只读或只写的自发性属性,自动属性定义是必须同时支持读写功用。但是定义更严厉的get或set是足以的
 
   肆、关于机关属性和暗中认可值
  
能够直接在代码中接纳封装了数字或布尔数据的机动属性,因为隐藏的回来字段将安装三个方可平素动用的景德镇的暗中认可值。但若是自动属性封装了另一个类变量,隐藏的私有引用类型的暗许值将设为null。
   比方上面包车型大巴类spawn,使用了七个机关属性
class Spawn
{
//隐藏的int字段暗中同意值为0
public int numbers{get;set;}
//隐藏的Enemy重回字段为null
public Enemy MyEnemy{get;set;}
}
  
当直接调用MyEnemy时,将会在运行时取得空引用卓殊,因为从没为后台使用的Enemy成员变量设置新的目的。
  
由于个体的回到字段是在编写翻译时创造的,所以无法平昔利用new关键字直接分配引用类型,必须在类的构造函数内部举行,以确定保障目的以安全方式诞生。
class Spawn
{
//隐藏的int字段暗许值为0
public int numbers{get;set;}
//隐藏的Enemy重临字段为null
public Enemy MyEnemy{get;set;}

  
注意:与理念的性质不相同的是,不容许营造只读或只写的自发性属性,自动属性定义是必须同时匡助读写功用。可是定义更严俊的get或set是足以的
 
   四、关于机关属性和暗中认可值
  
能够平素在代码中选用封装了数字或布尔数据的机动属性,因为隐藏的归来字段将设置一个方可一直选用的达州的默许值。但如果自动属性封装了另三个类变量,隐藏的民用引用类型的暗中认可值将设为null。
   举个例子上边包车型客车类spawn,使用了四个活动属性
class Spawn
{
//隐藏的int字段私下认可值为0
public int numbers{get;set;}
//隐藏的Enemy再次来到字段为null
public Enemy MyEnemy{get;set;}
}
  
当直接调用MyEnemy时,将会在运作时获得空引用尤其,因为未有为后台使用的Enemy成员变量设置新的靶子。
  
由于个人的归来字段是在编写翻译时创立的,所以不能够直接动用new关键字直接分配引用类型,必须在类的构造函数内部实践,以有限扶助目的以安全格局诞生。
class Spawn
{
//隐藏的int字段私下认可值为0
public int numbers{get;set;}
//隐藏的Enemy重回字段为null
public Enemy MyEnemy{get;set;}

      //必须用构造函数重写分配给隐藏返回字段的默认值 
      public Spawn()
      {
         MyEnemy = new Enemy();
         numbers = 1;
      }

      public Spawn(Enemy enemy, int num)
      {
         MyEnemy = enemy;
         numbers = num;
      }
 }
      //必须用构造函数重写分配给隐藏返回字段的默认值 
      public Spawn()
      {
         MyEnemy = new Enemy();
         numbers = 1;
      }

      public Spawn(Enemy enemy, int num)
      {
         MyEnemy = enemy;
         numbers = num;
      }
 }


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图