属性_属性选择器 - CSDN
精华内容
参与话题
  • C#中的属性

    千次阅读 2019-09-03 10:13:17
    一:字段与属性的概念 字段: 又称为成员变量,一般在类的内部做数据交互使用,一般使用private作修饰 但在一些情况下,我们需要限制字段的赋值范围,或是要求字段只读或只写,或是在改变字段时希望改变对象的其他...

    一:字段与属性的概念

    字段:
    又称为成员变量,一般在类的内部做数据交互使用,一般使用private作修饰
    但在一些情况下,我们需要限制字段的赋值范围,或是要求字段只读或只写,或是在改变字段时希望改变对象的其他一些字段值,这些单靠字段是无法做到的,于是就有了属性,属性中包含两个块,set块和get块,set块负责属性的写入工作,get块负责属性的读取工作

     


    属性:
    ——外界访问私有字段的入口。属性本身不保存任何数据,在对属性赋值和读取的时候其实操作的是对应的私有字段,实现了面向对象的封装特点
    ——属性本质其实就是一个方法,通过get和set方法来操作对应的字段

     

    二:属性的使用

    ——自动属性
    编译器会自动提示一个字段去存储Name

     


    ——限制字段的赋值范围
    很多时候,我们定义的变量需要有一个赋值范围,例如血量,等级,物品数量等等。
    对于血量,如果不使用属性的话我们需要在每次扣血时候进行一次判断血量是否小于等于0的逻辑判断,但是使用属性会简单很多

     


    ——限制属性只读或只写
         

     


    ——属性的访问修饰符

     

     

     

    展开全文
  • 属性

    2019-10-01 14:58:47
    字段和属性的选择原则 1.字段和属性的使用形式仅能是下面两种形式  (1)使用自动属性,无字段  (2)显示定义支持字段,并为该字段提供带逻辑代码的属性. 2.字段的访问性肯定是private 3.仅仅当set和get访问器里面...

    字段和属性的选择原则

    1.字段和属性的使用形式仅能是下面两种形式

      (1)使用自动属性,无字段

      (2)显示定义支持字段,并为该字段提供带逻辑代码的属性.

    2.字段的访问性肯定是private

    3.仅仅当set和get访问器里面包含逻辑代码时,才会使用字段.

    自动属性

    public string Name { get; set; }
    public int Age { get; set; }

    C#编译器会自动创建字段,且提供默认值:0,“”, null,false。

    访问级别不对等的get,set

    public string Name { get; private set; }

    我们可以在这个类的构造函数等其他函数中赋值或获取Name。在外界只能使用get。

    只读属性

    public string Name { get;}

    只能在构造函数中为其赋值,类的其他函数只能get之。  在外界只能使用get。

    接口属性

    public interface ISampleInterface
    {
        // Property declaration:
        string Name
        {
            get;
            set;
        }
    }

    接口属性的访问器没有正文。 因此,访问器的用途是指示属性为读写、只读还是只写。

    属性的访问修饰符

    对属性或索引器使用访问修饰符受以下条件的制约:

    • 不能对接口或显式接口成员实现使用访问器修饰符。

    • 仅当属性或索引器同时具有 set 和 get 访问器时,才能使用访问器修饰符。 这种情况下,只允许对其中一个访问器使用修饰符。

    • 如果属性或索引器具有 override 修饰符,则访问器修饰符必须与重写的访问器的访问器(如有)匹配。

    • 访问器的可访问性级别必须比属性或索引器本身的可访问性级别具有更严格的限制。

    重写属性或索引器时,被重写的访问器对重写代码而言必须是可访问的。 此外,属性/索引器及其访问器的可访问性都必须与相应的被重写属性/索引器及其访问器匹配。

     

     

    将不带 set 访问器的属性视为只读。 将不带 get 访问器的属性视为只写。 将具有以上两个访问器的属性视为读写。

    与字段不同,属性不会被归类为变量。 因此,不能将属性作为 ref 或 out 参数传递。

    属性可以是读-写属性(既有 get 访问器又有 set 访问器)、只读属性(有 get 访问器,但没有 set 访问器)或只写访问器(有 set 访问器,但没有 get 访问器)。 只写属性很少出现,常用于限制对敏感数据的访问。

    get 访问器必须以 return 或 throw 语句结尾,且控件不能超出访问器正文。

     

    属性具有许多用途:它们可以先验证数据,再允许进行更改;可以在类上透明地公开数据,其中数据实际是从某个其他源(如数据库)检索到的;可以在数据发生更改时采取措施,例如引发事件或更改其他字段的值。

    可以通过使用 static 关键字将属性声明为静态属性。 这使属性可供调用方在任何时候使用,即使不存在类的任何实例。

    转载于:https://www.cnblogs.com/zhenguan/p/11309386.html

    展开全文
  • 类的属性和方法(内置方法)

    千次阅读 2018-01-10 23:18:43
    一、类的属性 1.类的组成由属性和方法组成,属性可以称为成员变量,方法可以称为成员函数。 2.对象的创建,创建对象的过程称之为实例化。当一个对象被创建后,包含三个方面的特性:1.对象句柄 2.属性 3.方法。...
    一、类的属性
    1.类的组成由属性和方法组成,属性可以称为成员变量,方法可以称为成员函数。
    2.对象的创建,创建对象的过程称之为实例化。当一个对象被创建后,包含三个方面的特性:1.对象句柄 2.属性 3.方法。
    句柄:用于区分不同的对象。
    对象的属性和方法与类中的成员变量和成员函数对应。
    在类里面的属性和方法叫做成员变量和成员函数,在实例化后,调用这些变量和函数,就叫做对象属性和对象方法。
    3.类的属性,类的属性按使用范微分为公有属性和私有属性,类的属性范围取决于属性的名称。
    公有属性:在类中和类外都能调用的属性。
    私有属性:不能在类外以及类以外的函数调用。
    私有属性的定义方式:以__双下划线开始的成员变量就是私有属性,可以通过instance.classname_attribute方式访问。
    内置属性:由系统在定义类的伤害默认添加的,有前后双下划线构成,__dict__, __module__。
    比如:
    class People(object):
        color = 'yellow'  #这就是一个公有属性,可以在类里和类外调用
        __age = 30       #这就是一个私有属性,只能在类里调用。
        def think(self):   
            self.color = "black"    
            print "i am a %s" % self.color
            print "i am a thinker"
      print(self.__age)    #调用age
    ren = People()
    print ren.color
    ren.think() 
    print(ren.__age)
    可以看到在类里调用的__age成员变量可以调用出来,但是在类外就不行了。
    如果想在外面看到的话可以这么看。但是不一般不建议这么做,在调试的时候可以用。
    class People(object):
           color = 'yellow'
         __age = 30
        def think(self):
            self.color = 'black'
            print(self.color)
    ren = People()
    print ren.color
    ren.think()
    print ren.__age
    print ren._People__age  #这就可以看到内部的属性。还是建议放在成员函数里使用。

    使用内部属性这么做直接使用对象属性的方式调用。
    print ren.__dict__ 是属性所以没有括号。

    把公有属性分成字典的类型了。
    我们不光可以使用对象来访问类的属性,还可以通过类来访问类的属性。但是只能访问公有属性。
    print people.color

    4.对象属性修改。
    class People(object):
           color = 'yellow'
         __age = 30
        def think(self):
            self.color = 'black'
            print(self.color)
    ren = People()
    ren.color = “白色人”   #通过对象属性修改color的值
    print ren.color
    ren.think()
    print ren._People__age


    可以发现,对象属性的值得变了,但是在类中的的属性的值没有改变还是yellow。
    通过类名去访问内置属性
    print People.__dict__

    可以发现打印出了类里的所有属性对应的值。

    二、类的方法
    1.类的方法的定义和定义函数一样,但是需要self作为第一个参数,这个是必须要有的。self方法就是用来区分函数和类方法的。
    类的方法分为:1.公有方法 2.私有方法 3.类方法 4.静态方法
    公有方法:在类中和类外都可以调用的方法。和公有属性一样
    私有方法:不能被类外部调用,在方法前面加上__双下划线就是私有方法。和私有属性一样。
    类方法:被classmethod()函数处理过的函数,能被类所调用,也能被对象所调用(是继承的关系)
    静态方法:相当于“全局函数”,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义,静态方法没有self参数。
    2.可不可以通过类名调用方法呢?直接使用时不行的。必须要使用对象来调用。
    People.think()

    3.如果要把方法变成一个类方法我们需要使用一个函数来处理一下

    使用classmethod()函数来处理一下,我们需要通过一个变量来接收一下,这样就可以访问test方法了。只要方法名字就可以了,不用加括号。
    其实这种方式,我们还可以理解为动态方法,因为在调用的时候没有去加载其他方法出来。只有我们在调用的方法中,调用了其他方法才开会去加载。所以说是个动态,通过类来访问方法,加载的资源很少。
    4.静态方法的定义。
    如果我们直接写一个不加self的方法,是不行会报错,会当成类方法,提示你需要有一个参数。
    def test():
    print "test"

    直接用类去调用也是不行。

    我们需要一个函数去处理一下。
    sm = staticmethod(test) 调用的时候也是通过这个接收的变量名去访问,

    虽然看上去定义的方式差不多,但是运行机制是不一样的,静态方法调用的伤害,因为没有self这个参数,所以会把类里的所有变量都加载进内存。
    但是运行速度要比动态的快。
    那么静态方法如何去访问类里的成员变量呢?
    如果使用self.color是不行的会报错。使用类名.属性的方式访问。
    def test():
    print People.color

    因为self 就代表类的本身,静态方法没有self 这个参数,就使用类名来访问。
    5.其实还有一种方式可以去访问类方法和静态方法。使用装饰器。
    装饰器如何使用?
    @staticmethod
    def test():
    print "this is a static method"
    People.test()

    装饰器就是@后面加处理的函数名,在方法的上方加装饰器,只对装饰器下面的这一个函数起作用。

    这种方式就比较简便。

    三、Python的内部类
    1.所谓内部类,就是类的嵌套,就是在类的内部在定义类。主要目的是为了更好的抽象现实世界。
    就像os模块,os.path.altsep 这就想内部类,通过OS的外部类.path内部类.去调用属性和方法:
    2.定义内部类和使用内部类
    第一种方式:直接使用外部类调用内部类:
    class People(object):
        color = 'yellow'
        __age = 30
        class chinese(object):   #定义了一个内部类
            print "i am chinese"
            
        def think(self):
            self.color = 'black'
            print(self.color)
        def test():
            print 'Testing...'
        sm = staticmethod(test)
    jack = People.chinese()   #第一种方式实例化内部类。
    在内部类定义一个属性,如何访问呢。
    name = "i am a chinese"

    直接使用对象属性来访问。
    但是这种方式外部类的属性和访问就调用不了了。
    第二种方式:先对外部类进行实例化,然后再实例化内部类。
    class People(object):
        color = 'yellow'
        __age = 30
        class chinese(object):   #定义了一个内部类
            print "i am chinese"
            
        def think(self):
            self.color = 'black'
            print(self.color)
        def test():
            print 'Testing...'
        sm = staticmethod(test)
    ren = People()  #先实例化外部类
    jack = ren.Chinese()  #在实例化内部类,实例化内部类需要加上“外部类名字.内部类名字”
    print jack.name
    

    这样就是可以调用内部类的属性和方法和外部类的属性和方法了。
    第三种方式:直接使用外部类加内部类加内部类属性来访问
    class People(object):
        color = 'yellow'
        __age = 30
        class chinese(object):   #定义了一个内部类
            print "i am chinese"
            
        def think(self):
            self.color = 'black'
            print(self.color)
        def test():
            print 'Testing...'
        sm = staticmethod(test)
    print People.Chinese.name  #使用类的方法来访问。
    print People.Chinese().name  #使用对象的方法来访问,其实这就是第一种方式的实例化内部类了。

    3.类的内置方法,又称魔术方法
    1.__str__(self)内置方法
    先看实例化后对象的返回结果。
    class People(object):
            color = 'yellow'
            __age = 30
            class Chinese(object):
                name = "i am a chinese"
            def __str__(self):
               return "This is a People object"
            def think(self):
                   self.color = 'black'
                   print(self.color)
               # print(self.__age)
             @classmethod
              def test1(self):
                   print("this is a class method")
              @staticmethod
               def test():
                   print "this is static method"
       ren = People()
       print ren

    使用__str__方法后的结果

    可以看到输出变了。而且不用去调用__str__内置方法。在运行的时候就直接加载了。__str__内置方法只能用给return ,不能用print。
    2.构造函数和析构函数
    构造函数:用于初始化类的内部状态,Python中提供的构造函数是__init__()
    析构函数:用于释放对象占用的资源,Python中提供析构函数的是__del__()
    首先来看下构造函数。
     class People(object):
            color = 'yellow'
            __age = 30
            class Chinese(object):
                name = "i am a chinese"
            def __str__(self):
                return "This is a People object"
      def __init__(self):
     self.color = 'red'
            def think(self):
                   self.color = 'black'
                   print(self.color)
               # print(self.__age)
             @classmethod
              def test1(self):
                   print("this is a class method")
              @staticmethod
               def test():
                   print "this is static method"
       ren = People()
       print ren.color   #通过对象访问就变成了red
       print People.color  #通过类属性访问还是没变。

    这个函数也是自动执行,当我们实例化类的时候就会自动执行。
    通常我们用这个构造方法来修改参数。通过对象访问的属性会根据我们传的值不同属性会改变。而根据类的这种方式是不变的。
    构造函数可以放属性和方法,而且不需要调用就可以加载出来。
    class People(object):
            color = 'yellow'
            __age = 30
            class Chinese(object):
                name = "i am a chinese"
            def __str__(self):
                return "This is a People object"
      def __init__(self,c='green'):
     self.color = c
     self.think()
            def think(self):
                   self.color = 'black'
                   print(self.color)
               # print(self.__age)
             @classmethod
              def test1(self):
                   print("this is a class method")
              @staticmethod
               def test():
                   print "this is static method"
       ren = People()
       print ren.color   
       print People.color  
    析构函数:在脚本执行的最后来执行__del__内置方法。用于结束占用的资源
    class People(object):
        color = 'yellow'
        __age = 30
        class Chinese(object):
            name = "i am a chinese"
        def __str__(self):
            return "This is a People object"
        def __init__(self):
            print "init...."
            self.fd = open('1.txt')  #打开一个文件
            self.think()
        def think(self):
            self.color = 'black'
            print(self.color)
        @classmethod
        def test1(self):
            print("this is a class method")
        @staticmethod
        def test():
            print "this is static method"
        def __del__(self):
            print "del...."
            self.fd.close()  #关闭回收
    ren = People()
    print ren.color
    print People.color
    print "Main end" 

    可以看到del这个内置方法是在脚本结束后才执行的。
    3.其实在Python中del这个内置方法是可选的。如果不提供,Python会在后台提供默认的析构函数。
    Python有一个垃圾回收机制,使用gc模块释放不在使用的对象。采用引用计数的算法方式来处理回收。可以使用gc.collect()方法一次性收集所有待处理的对象。

    展开全文
  • C#中属性的定义

    千次阅读 2018-04-03 21:44:09
    属性的定义 定义结构: public int MyIntProp{ get{ //get code } set{ //set code } } 定义属性需要名字和类型。 属性包含两个块:get块和set块。 访问属性和访问字段一样,当取得属性的值得时候,就会...

    属性的定义

    定义结构:

    public int MyIntProp{
        get{
                //get code
            }
        set{
                //set code
            }
        }
    1. 定义属性需要名字类型
    2. 属性包含两个块:get块set块
    3. 访问属性和访问字段一样,当取得属性的值得时候,就会调用属性中的get块,因此get块需要返回值,其返回值类型就是属性的类型;当我们去给属性设置值得时候,就会调用属性中的set块,以此可以在set块中通过value访问到我们所设置的值。

    eg:

    //跟访问字段的方式一样
    v1.MyIntProperty = 600; //对属性设置值,自动调用set块
    int temp = v1.MyIntProperty //对属性取值,自动调用get块

    需要注意的是,set方法和get方法可以不同时存在。
    但是如果没有get块,就不可以获得取值;如果没有set块,就不能进行设置值。

    通过属性访问字段
    一般而言,习惯于将字段设置为private,这样外界就不能修改字段的值。这是我们可以通过定义属性来设置字段和获取字段的值。
    eg:

    private int age;
    public int Age{ //习惯字段小写,属性大写
        set{
            if(value<0) return;   //通过set值进行一些校验的工作
            age = value;
            }
        get{
            return age;
            }
        }
    • 设置属性的只读或者只写

    只读

    private string name;
    public string Name{
        get{
                return name;
            }

    只写

    private string name;
    public string Name{
        set{
                name = value;
            }
    • 属性的访问修饰符
    //如果在get或set块钱加上private,表示这个块只能在类内进行调用
    public float X{
        private set { x = value;}  
        get { return x;}
    
    public float X{
        set { x = value;}  
        private  get { return x;}  
    • 自动实现的属性
    public int Age{set;get;}    //编译器会自动提供字段来存储age
    
    -->等价于
    
    public int Age{
        set{ age = value;}
        get{ return age;}

    总结一下,属性就相当于是一种带有set和get方法的一个方法,而它与类中的字段的赋值和取值又是息息相关的。

    展开全文
  • 系统属性笔记

    2020-03-09 20:32:36
    以ro开头的属性都是只读属性,所以不可被改变 以persist开头的属性,从名字看可以知道这类属性是可持续性的,即修改之后即使重启之后,也不会变成初始值 其他类型的属性,可以被读写,但是在重启之后会被重新赋初始值 ...
  • property属性

    千次阅读 2018-09-16 20:48:03
    property属性; a.一种用起来像实例属性一样的特殊属性,可以对应于某些方法,property的本质还是方法 1.property属性的定义和调用要注意几点: 1.定义时,在实例方法的基础上添加@property装饰器, 2.并且方法...
  • JS标签属性

    千次阅读 2019-04-29 16:42:14
    标签属性 1、获取和修改标签属性 可读可写 .style 获取的是行内样式 通过.的方式这能获取合法的标签属性(就是不能获取系统自带的方法属性),需要通过特定的方法来获取 <body> <img src="" alt=...
  • C3新增的一些属性总结

    千次阅读 2018-06-06 10:07:29
    C3的选择器: 1.关系选择器:ul&gt;li子代选择器 ul li后代选择器 .now+li后一个兄弟为li的...2.属性选择器:li[属性||自定义属性 ='值'] li里面属性或者自定义属性=值的元素 li[属性] 所有有此属性的元素 ...
  • HTML常用标签和属性大全

    万次阅读 多人点赞 2018-08-18 09:52:04
    目录 ...lt;... align 属性 列表  1无序列表又称符号列表 2有序列表 3定义列表 name 连接名称 target目标窗口语法格式: 图像 语法格式: font元素 表格语法格式: tr元素 ...
  • 什么是属性 属性是一个数据字段,表示数据对象的一个特征。一个属性的类型由该属性可能具有的值的集合决定。 标称属性 标称意味着“与名称有关”,标称属性的值是一些符号或者是事物的名称。每个值代表某种类别、...
  • 多值属性、复合属性等概念

    千次阅读 2020-05-16 11:23:22
    多值属性、符合属性等概念 1).简单属性:不能再划分为更小部分的属性。 2).复合属性:可以再划分为更小的部分,也就是能再划分为一些其他属性属性。 比如说:name属性可被设计为一个包括first_name,middle_name,...
  • js获取、设置元素属性

    千次阅读 2019-07-25 18:52:01
    文章目录...属性名` 网页css和样式结构 #box{ width:100px; height:100px; } <div id="box" style="background:red;"></div> setAttribute 元素...
  • JS获取元素属性和自定义属性

    万次阅读 2019-05-07 21:21:19
    获取元素的属性分为两种类型:1-获取元素常见的属性(class,id,type,value……)2-获取自定义的元素的属性(data-value,data-mess…….)获取元素的属性,设置元素的属性: 1-原生JS** 设置属性 .setAttribute(...
  • Spring Boot 属性配置和使用

    万次阅读 多人点赞 2017-04-23 13:19:36
    Spring Boot 属性配置和使用Spring Boot 允许通过外部配置让你在不同的环境使用同一应用程序的代码,简单说就是可以通过配置文件来注入属性或者修改默认的配置。Spring Boot 入门 请看:...
  • 只是大概的说明一下属性关键字的意思,详细的介绍,那需要你到网上具体查找,这里简单介绍,主要还是怎么使用这几个关键字,定义一些属性字段,需要使用哪些关键字,下面说的很明确,我们常用的几个。 ...
  • 一、讲解 首先说明 键字=码字,所以 主键=主码=主关键字,候选键=候选码=候选关键字... ... 1、码=超键:能够唯一标识一条记录的属性属性集。 标识性:一个数据表的所有记录都具有不同的超键 非空性:...
  • jQuery之属性过滤选择器

    万次阅读 2012-03-11 19:40:49
    查询到的元素进行过滤,属性过滤选择器包含了在中括号"[]"中,而不是以冒号开头,通常使用"选择器[属性过滤选择器]"语法格式,可以根据是否包含指定属性或者 根据属性值从查询到的元素中进行筛选。
  • 在JS中设置节点的属性属性值用到setAttribute(),获得节点的属性属性值用到getAttribute(),而在jquery中,只需要用到attr()这个函数就可以了。attr是attribute(属性)的缩写。 语法: 1、attr(“属性名”); /...
  • 根据属性获得元素 1.比如要获取页面p标签中属性有id的元素 复制代码代码如下:$("p[id]").css("color","red"); 根据属性值获得元素 1.$。在jQuery 中$("&lt;span&gt;...
  • Android 深入理解Android中的自定义属性

    万次阅读 多人点赞 2015-04-13 10:41:30
    对于自定义属性,大家肯定都不陌生,遵循以下几步,就可以实现: 自定义一个CustomView(extends View )类 编写values/attrs.xml,在其中编写styleable和item等标签元素 在布局文件中CustomView使用自定义的属性...
1 2 3 4 5 ... 20
收藏数 5,315,963
精华内容 2,126,385
关键字:

属性