精华内容
下载资源
问答
  • Python3 面向对象 ——————————————————————————– 一丶面向对象技术简介 •(Class): 用来描述具有相同的属性和方法的对象的集合。...•局部变量:定义在方法中的变量,
  • 一、 Python面向对象编程 二、 python之定义并创建实例 三、 Python通过 class 关键字定义。以 Person 为例,定义一个Person如下: 四、 class Person(object): 五、 pass 六、 按照...

    一、       Python面向对象编程

    二、       python之定义类并创建实例

    三、 在Python中,类通过 class 关键字定义。以 Person 为例,定义一个Person类如下:

    四、 class Person(object):

    五、     pass

    六、 按照 Python 的编程习惯,类名以大写字母开头,紧接着是(object),表示该类是从哪个类继承下来的。类的继承将在后面的章节讲解,现在我们只需要简单地从object类继承。

    七、 有了Person类的定义,就可以创建出具体的xiaoming、xiaohong等实例。创建实例使用 类名+(),类似函数调用的形式创建:

    八、 xiaoming = Person()

    九、 xiaohong = Person()

    十、       任务

    十一、       请练习定义Person类,并创建出两个实例,打印实例,再比较两个实例是否相等。

    class Person(object):

       pass

     

    xiaoming = Person()

    xiaohong = Person()

     

    print xiaoming

    print xiaohong

    print xiaoming==xiaohong

     

     

    三、python中创建实例属性

    虽然可以通过Person类创建出xiaoming、xiaohong等实例,但是这些实例看上除了地址不同外,没有什么其他不同。在现实世界中,区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。

    如何让每个实例拥有各自不同的属性?由于Python是动态语言,对每一个实例,都可以直接给他们的属性赋值,例如,给xiaoming这个实例加上name、genderbirth属性:

    xiaoming = Person()
    xiaoming.name = 'Xiao Ming'
    xiaoming.gender = 'Male'
    xiaoming.birth = '1990-1-1'

    xiaohong加上的属性不一定要和xiaoming相同:

    xiaohong = Person()
    xiaohong.name = 'Xiao Hong'
    xiaohong.school = 'No. 1 High School'
    xiaohong.grade = 2

    实例的属性可以像普通变量一样进行操作:

    xiaohong.grade = xiaohong.grade + 1

    任务

    请创建包含两个 Person 类的实例的 list,并给两个实例的 name 赋值,然后按照 name 进行排序。

    class Person(object):

       pass

    p1 = Person()

    p1.name = 'Bart'

     

    p2 = Person()

    p2.name = 'Adam'

     

    p3 = Person()

    p3.name = 'Lisa'

     

    L1 = [p1, p2, p3]

    L2 = sorted(L1, lambda p1, p2: cmp(p1.name,p2.name))

     

    print L2[0].name

    print L2[1].name

    print L2[2].name

     

     

    四、python中初始化实例属性

    虽然我们可以自由地给一个实例绑定各种属性,但是,现实世界中,一种类型的实例应该拥有相同名字的属性。例如,Person类应该在创建的时候就拥有 name、gender 和 birth 属性,怎么办?

    在定义 Person 类时,可以为Person类添加一个特殊的__init__()方法,当创建实例时,__init__()方法被自动调用,我们就能在此为每个实例都统一加上以下属性:

    class Person(object):
        def __init__(self, name, gender, birth):
            self.name = name
            self.gender = gender
            self.birth = birth

    __init__() 方法的第一个参数必须是 self(也可以用别的名字,但建议使用习惯用法),后续参数则可以自由指定,和定义函数没有任何区别。

    相应地,创建实例时,就必须要提供除 self 以外的参数:

    xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
    xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')

    有了__init__()方法,每个Person实例在创建时,都会有 name、gender 和 birth 这3个属性,并且,被赋予不同的属性值,访问属性使用.操作符:

    print xiaoming.name
    # 输出 'Xiao Ming'
    print xiaohong.birth
    # 输出 '1992-2-2'

    要特别注意的是,初学者定义__init__()方法常常忘记了 self 参数:

    >>> class Person(object):
    ...     def __init__(name, gender, birth):
    ...         pass
    ... 
    >>> xiaoming = Person('Xiao Ming', 'Male', '1990-1-1')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: __init__() takes exactly 3 arguments (4 given)

    这会导致创建失败或运行不正常,因为第一个参数name被Python解释器传入了实例的引用,从而导致整个方法的调用参数位置全部没有对上。

    任务

    请定义Person类的__init__方法,除了接受 name、gender 和 birth 外,还可接受任意关键字参数,并把他们都作为属性赋值给实例。

     

    class Person(object):

       def __init__(self, name, gender, birth, **kw):

           self.name = name

           self.gender = gender

           self.birth = birth

           for k, v in kw.iteritems():

               setattr(self, k, v)

    xiaoming = Person('Xiao Ming', 'Male','1990-1-1', job='Student')

    print xiaoming.name

    print xiaoming.job

     

    五、python中访问限制

    我们可以给一个实例绑定很多属性,如果有些属性不希望被外部访问到怎么办?

    Python对属性权限的控制是通过属性名来实现的,如果一个属性由双下划线开头(__),该属性就无法被外部访问。看例子:

    class Person(object):
        def __init__(self, name):
            self.name = name
            self._title = 'Mr'
            self.__job = 'Student'
    p = Person('Bob')
    print p.name
    # => Bob
    print p._title
    # => Mr
    print p.__job
    # => Error
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'Person' object has no attribute '__job'

    可见,只有以双下划线开头的"__job"不能直接被外部访问。

    但是,如果一个属性以"__xxx__"的形式定义,那它又可以被外部访问了,以"__xxx__"定义的属性在Python的类中被称为特殊属性,有很多预定义的特殊属性可以使用,通常我们不要把普通属性用"__xxx__"定义。

    单下划线开头的属性"_xxx"虽然也可以被外部访问,但是,按照习惯,他们不应该被外部访问。

    任务

    请给Person类的__init__方法中添加namescore参数,并把score绑定到__score属性上,看看外部是否能访问到。

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.__score = score
     
    p = Person('Bob', 59)
     
    print p.name
    print p.__score

     

     

    六、python中创建类属性

    类是模板,而实例则是根据类创建的对象。

    绑定在一个实例上的属性不会影响其他实例,但是,类本身也是一个对象,如果在类上绑定一个属性,则所有实例都可以访问类的属性,并且,所有实例访问的类属性都是同一个!也就是说,实例属性每个实例各自拥有,互相独立,而类属性有且只有一份。

    定义类属性可以直接在 class 中定义:

    class Person(object):
        address = 'Earth'
        def __init__(self, name):
            self.name = name

    因为类属性是直接绑定在类上的,所以,访问类属性不需要创建实例,就可以直接访问:

    print Person.address
    # => Earth

    对一个实例调用类的属性也是可以访问的,所有实例都可以访问到它所属的类的属性:

    p1 = Person('Bob')
    p2 = Person('Alice')
    print p1.address
    # => Earth
    print p2.address
    # => Earth

    由于Python是动态语言,类属性也是可以动态添加和修改的:

    Person.address = 'China'
    print p1.address
    # => 'China'
    print p2.address
    # => 'China'

    因为类属性只有一份,所以,当Person类的address改变时,所有实例访问到的类属性都改变了。

    任务

    请给 Person 类添加一个类属性 count,每创建一个实例,count 属性就加 1,这样就可以统计出一共创建了多少个 Person 的实例。

    class Person(object):

       count = 0

       def __init__(self,name):

           self.name = name

           Person.count += 1#注意不能直接使用count

     

    p1 = Person('Bob')

    print Person.count

     

    p2 = Person('Alice')

    print Person.count

     

    p3 = Person('Tim')

    print Person.count

     

    七、python中类属性和实例属性名字冲突怎么办

    修改类属性会导致所有实例访问到的类属性全部都受影响,但是,如果在实例变量上修改类属性会发生什么问题呢?

    class Person(object):
        address = 'Earth'
        def __init__(self, name):
            self.name = name
     
    p1 = Person('Bob')
    p2 = Person('Alice')
     
    print 'Person.address = ' + Person.address
     
    p1.address = 'China'
    print 'p1.address = ' + p1.address
     
    print 'Person.address = ' + Person.address
    print 'p2.address = ' + p2.address

    结果如下:

    Person.address = Earth
    p1.address = China
    Person.address = Earth
    p2.address = Earth

    我们发现,在设置了 p1.address = 'China' 后,p1访问 address 确实变成了'China',但是,Person.address和p2.address仍然是'Earch',怎么回事?

    原因是 p1.address = 'China'并没有改变 Person 的 address,而是给 p1这个实例绑定了实例属性address ,对p1来说,它有一个实例属性address(值是'China'),而它所属的类Person也有一个类属性address,所以:

    访问 p1.address ,优先查找实例属性,返回'China'

    访问 p2.address ,p2没有实例属性address,但是有类属性address,因此返回'Earth'。

    可见,当实例属性和类属性重名时,实例属性优先级高,它将屏蔽掉对类属性的访问。

    当我们把 p1 的 address 实例属性删除后,访问 p1.address 就又返回类属性的值 'Earth'了:

    del p1.address
    print p1.address
    # => Earth

    可见,千万不要在实例上修改类属性,它实际上并没有修改类属性,而是给实例绑定了一个实例属性。

    任务

    请把上节的 Person 类属性 count 改为 __count,再试试能否从实例和类访问该属性。

    class Person(object):

       __count = 0

       def __init__(self, name):

           Person.__count = Person.__count + 1

           self.name = name

           print Person.__count

     

    p1 = Person('Bob')

    p2 = Person('Alice')

     

    print Person.__count

     

     

    八、python中定义实例方法

    一个实例的私有属性就是以__开头的属性,无法被外部访问,那这些属性定义有什么用?

    虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外,还可以定义实例的方法。

    实例的方法就是在类中定义的函数,它的第一个参数永远是 self,指向调用该方法的实例本身,其他参数和一个普通函数是完全一样的:

    class Person(object):
     
        def __init__(self, name):
            self.__name = name
     
        def get_name(self):
            return self.__name

    get_name(self) 就是一个实例方法,它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。

    调用实例方法必须在实例上调用:

    p1 = Person('Bob')
    print p1.get_name()  # self不需要显式传入
    # => Bob

    在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

    任务

    请给 Person 类增加一个私有属性 __score,表示分数,再增加一个实例方法 get_grade(),能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。

    class Person(object):

     

       def __init__(self, name, score):

           self.name = name

           self.__score = score

     

       def get_grade(self):

           if self.__score>=90 :

               return 'A'

           elif self.__score>=60 :

               return 'B'

           else :

               return 'C'

               

    p1 = Person('Bob', 90)

    p2 = Person('Alice', 65)

    p3 = Person('Tim', 48)

     

    print p1.get_grade()

    print p2.get_grade()

    print p3.get_grade()

     

     

    九、python中方法也是属性

    我们在 class 中定义的实例方法其实也是属性,它实际上是一个函数对象:

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
        def get_grade(self):
            return 'A'
     
    p1 = Person('Bob', 90)
    print p1.get_grade
    # => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
    print p1.get_grade()
    # => A

    也就是说,p1.get_grade 返回的是一个函数对象,但这个函数是一个绑定到实例的函数,p1.get_grade() 才是方法调用。

    因为方法也是一个属性,所以,它也可以动态地添加到实例上,只是需要用 types.MethodType() 把一个函数变为一个方法:

    import types
    def fn_get_grade(self):
        if self.score >= 80:
            return 'A'
        if self.score >= 60:
            return 'B'
        return 'C'
     
    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
     
    p1 = Person('Bob', 90)
    p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
    print p1.get_grade()
    # => A
    p2 = Person('Alice', 65)
    print p2.get_grade()
    # ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
    # 因为p2实例并没有绑定get_grade

    给一个实例动态添加方法并不常见,直接在class中定义要更直观。

    任务

    由于属性可以是普通的值对象,如 str,int 等,也可以是方法,还可以是函数,大家看看下面代码的运行结果,请想一想 p1.get_grade 为什么是函数而不是方法:

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
            self.get_grade = lambda: 'A'
     
    p1 = Person('Bob', 90)
    print p1.get_grade
    print p1.get_grade()

     

     

    十、python中定义类方法

    和属性类似,方法也分实例方法类方法

    class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。

    要在class中定义类方法,需要这么写:

    class Person(object):
        count = 0
        @classmethod
        def how_many(cls):
            return cls.count
        def __init__(self, name):
            self.name = name
            Person.count = Person.count + 1
     
    print Person.how_many()
    p1 = Person('Bob')
    print Person.how_many()

    通过标记一个 @classmethod,该方法将绑定到 Person 类上,而非类的实例。类方法的第一个参数将传入类本身,通常将参数名命名为 cls,上面的 cls.count 实际上相当于 Person.count

    因为是在类上调用,而非实例上调用,因此类方法无法获得任何实例变量,只能获得类的引用。

    任务

    如果将类属性 count 改为私有属性__count,则外部无法读取__score,但可以通过一个类方法获取,请编写类方法获得__count值。

    class Person(object):

     

       __count = 0

     

       @classmethod

       def how_many(cls):

           return cls.__count

           

       def __init__(self,name):

           self.name = name

           Person.__count += 1

       

     

    print Person.how_many()

     

    p1 = Person('Bob')

     

    print Person.how_many()

    展开全文
  • python实例中的变量称为域,实例中的函数称为方法,域和方法都是实例的属性。 的定义 定义或者它的函数的时候,如果没有参数的话,需要把参数写为self,这样外部调用的时候能清楚调用的是...
  • 【单选题】在类的继承关系,需要遵循以下哪个继承原则?【判断题】方法内部类中不能访问外部的成员变量。【多选题】使用this调用的构造方法,下面的说法正确的是?(多选)【判断题】声明构造方法时,不能使用private...

    【单选题】下面哪一个是正确的类的声明?

    【单选题】在类的继承关系中,需要遵循以下哪个继承原则?

    【判断题】方法内部类中不能访问外部类的成员变量。

    【多选题】使用this调用类的构造方法,下面的说法正确的是?(多选)

    【判断题】声明构造方法时,不能使用private关键字修饰。

    【填空题】所谓类的封装是指在定义一个类时,将类中的属性私有化,即使用______关键字来修饰。

    【填空题】Choose an appropriate verb form, giving two answers where possible. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( )

    【单选题】在Java语言中,以下哪个关键字用于在方法上声明抛出异常?

    【单选题】编译运行下面的程序,结果是什么? public class A { public static void main(String[] args) { B b = new B(); b.test(); } void test() { System.out.print("A"); } } class B extends A { void test() { super.test(); System.out.print("B"); } }

    【多选题】下面哪些可以使用static关键字修饰?

    【简答题】请列举Java语言中的八种基本数据类型,并说明每种数据类型所占用的空间大小。

    【填空题】定义在类中的变量被称为______,定义在方法中的变量被称为______

    【单选题】类的定义必须包含在以下哪种符号之间?

    【多选题】关于内部类,下面说法正确的是?(多选)

    【填空题】在Java中,可以使用关键字______来创建类的实例对象。

    【填空题】面向对象的三大特征是______、______和______。

    【填空题】Choose an acceptable verb form from the two given in brackets according to the standard of formal writing. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( ) 21.( ) 22.( ) 23.( ) 24.( ) 25.( ) 26.( ) 27.( ) 28.( ) 29.( ) 30.( )

    【其它】通过课堂学习,了解自己的摄影器材 确定自己本学期采用的摄影器材(比如说:XXX 手机,镜头光圈 XXX,焦距XXX,CMOS尺寸是XXX) 2.根据本课学习的关于好照片的标准,从你的手机中,找出三张你自己拍摄的你最喜欢的好照片。(要求至少一张是人像照片)

    【填空题】Select an appropriate verb form from the two given in the brackets. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ; ; ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( ) 21.( ) 22.( ) 23.( ) 24.( ) 25.( ) 26.( ) 27.( ) 28.( ) 29.( ) 30.( ) 31.( ) 32.( ) 33.( ) 34.( ) 35.( ) 36.( ) 37.( ) 38.( ) 39.( ) 40.( ) 14.( ) 42.( ) 43.( ) 44.( ) 45.( ) 46.( ) 47.( ) 48.( ) 49.( ) 50.( )

    【简答题】单例设计模式具备哪些特点?

    【填空题】被static关键字修饰的成员变量被称为______,它可以被该类所有的实例对象共享。

    【简答题】简述&&与&的区别并举例说明。

    【填空题】在Java中,提供了一个______命令,用于将程序中的文档注释提取出来,生成HTML格式的帮助文档。

    【填空题】在一个类中,除了可以定义属性、方法,还可以定义类,这样的类被称为______。

    【其它】拍摄一组(3-5张,不同环境,不同机位)校园自然光人像照片,运用学习的各种摄影知识。

    【其它】定义一个Father和Child类,并进行测试。 1)Father类为外部类,类中定义一个私有的String类型的属性name,name的值为“zhangjun”。 2)Child类为Father类的内部类,其中定义一个introFather()方法,方法中调用Father类的name属性。 3)定义一个测试类Test,在Test类的main()方法中,创建Child对象,并调用introFather ()方法。

    【其它】根据授课内容,拍摄3种站姿和3种坐姿。

    【填空题】布尔常量即布尔类型的两个值,分别是______和______。

    【判断题】continue 语句只用于循环语句中,它的作用是跳出循环。

    【单选题】在以下什么情况下,构造方法会被调用?

    【单选题】类中的一个成员方法被下面哪个修饰符修饰,该方法只能在本类被访问?

    【多选题】以下说法哪些是正确的?

    【其它】请拍摄4张人像照片,分别为全身人像,半身人像,七分人像和特写。

    【多选题】下面对于单例设计模式的描述,正确的是?

    【其它】军训专题摄影 要求上交一组(5-10张)军训照片,表现学生军训的刻苦,坚韧的意志品质和精神面貌。 可以拍摄全景,特写,静物来表现军训的场景。

    【其它】根据之前胡秋季主题摄影方案策划进行拍摄,并进行作品的提交。 要求:组照(10张左右),每一张照片都要附上拍摄的位置信息,拍摄时的感想,并说明作品的优点和缺点。

    【多选题】关于super关键字以下说法哪些是正确的?

    【多选题】关于抽象类的说法哪些是正确的?

    【填空题】面向对象程序设计的重点是______的设计,______是用来创建对象的模板。

    【填空题】Java中的程序代码都必须在一个类中定义,类使用______关键字来定义。

    【填空题】当一个对象被当成垃圾从内存中释放时,它的______方法会被自动调用。

    【多选题】下面对于构造方法的描述,正确有哪些?(多选)

    【判断题】Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。

    【单选题】在Java中,要想让一个类继承另一个类,可以使用以下哪个关键字?

    【单选题】已知类的继承关系如下: class Employee; class Manager extends Employeer; class Director extends Employee; 则以下语句能通过编译的有哪些?

    【单选题】请先阅读下面的代码 public class Test { public Test(){ System.out.println("构造方法一被调用了"); } public Test(int x){ this(); System.out.println("构造方法二被调用了"); } public Test(boolean b){ this(1); System.out.println("构造方法三被调用了"); } public static void main(String[] args) { Test test = new Test(true); } } 上面程序的运行结果为下列哪一项?

    【判断题】类中static修饰的变量或方法,可以使用类名或对象的引用变量访问。

    【判断题】ava语言不区分大小写。

    【判断题】在定义一个类的时候,如果类的成员被private所修饰,该成员不能在类的外部被直接访问。

    【简答题】构造方法和普通的成员方法有什么区别?

    展开全文
  • 浅谈面向对象方法

    千次阅读 热门讨论 2020-05-15 18:00:32
    六、面向对象方法学的优点与缺点 优点 缺点 一、面向对象的基本概念 对象、实例、消息、方法 对象:对象能够表示现实或抽象的事物,具有良好定义的责任和良好定义的行为,以及良好 定义的接口。 对象具有...

    目录

    一、面向对象的基本概念

    对象、类、实例、消息、方法

    二、面向对象的基本特征

    封装、继承、多态

    三、面向对象的建模

    对象模型、动态模型、功能模型

    四、面向对象设计

    五、面向对象的实现

    设计风格

    测试策略

    六、面向对象方法学的优点与缺点

    优点

    缺点


    一、面向对象的基本概念

    对象、类、实例、消息、方法

    对象对象能够表示现实或抽象的事物,具有良好定义的责任和良好定义的行为,以及良好 定义的接口。

    对象具有封装性、自治性、通信性、被动性、暂存性、持久性

    类的定义是具有相同属性和务的一组对象的集合,它为属于该类的全部对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分

    实例每个对象都属于一个类,属于某个类的对象称为该类的一个实例,类和对象间具有 instance-of 关系。

    类是静态概念,对象是动态概念。类是 对象之上的抽象,有了类之后,对象则是类的具体化,是类的实例

    消息消息就是向对象发出的服务请求,它应含有提供服务的对象标识、服务标识、输入信息和回答信息。

    消息用来请求对象处理或回答某些信息的要求,消息统一了数据流和控制流。程序的执行是靠在对象间传递消息来完成的。

    方法方法(method)也称作行为(behavior),指定义于某一特定类上的操作与法则。

    面向对象的设计方法放弃了传统语言中控制结构的概念,以往的一切控制结构的功能都可以通过对象及其相互间传递消息来实现

    二、面向对象的基本特征

    封装、继承、多态

    封装:封装是面向对象方法的一个重要原则,它有两个含义:第一个含义是,把对象的全部 属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象);第二个含义也称作信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界,只保留有限的对外接口使之与外部发生联系。

    继承:继承是一种使用户得以在一个类的基础上建立新的类的技术。新的类自动继承旧类的属性和行为特征,并可具备某些附加的特征或某些限制。

    继承是面向对象语言中功能最强大、最有代表性的特性。首先,继承使新的类变得简洁明了;其次,通过继承可以重复使用和扩展那些经过测试的已有的类,实现重用。最后,是利用继承可以增强处理的一致性。

    多态:在收到消息时对象要予以响应,不同的对象收到同一消息可以产生完全不同的结果, 这一现象叫做多态。

    三、面向对象的建模

            所谓模型,就是为了理解事物而对事物做出的一种抽象,是对事物的一种无歧义的书 面描述。通常,模型由一组图示符号和组织这些符号的规则组成,利用它们来定义和描述 问题域中的术语和概念。更进一步讲,模型是一种思考工具,利用这种工具可以把知识规范地表示出来。

           面向对象的建模不仅仅是新的编程语言的汇总,而是一种新的思维方式,一种关于计 算和信息结构化的新思维。面向对象的建模,把系统看做是相互协作的对象,这些对象是结构和行为的封装,都属于某个类,那些类具有某种层次化的结构。系统的所有功能通过 对象之间相互发送消息来获得。面向对象的建模可以视作一个包含以下元素的概念框架: 抽象、封装、模块化、层次、分类、并行、稳定、可重用和可扩展性。

    对象模型、动态模型、功能模型

    对象模型:对象模型表示静态的、结构化的系统的“数据性质”。

    面向对象方法强调围绕对象而 不是围绕功能来构造系统。对象模型为建立动态模型和功能模型,提供了实质性的框架。

    动态模型:动态模型表示瞬时的、行为化的系统的“控制”性质,它规定了对象模型中的对象的合法变化序列通常,用状态图来描绘对象的状态、触发状态转换的事件以及对象的行为(对事件的响应)。

    功能模型:功能模型表示变化的系统的“功能”性质,它指明了系统应该“做什么”,因此更直接地反映了用户对目标系统的需求。 通常,功能模型由一组数据流图组成。

    三者之间的关系:它使用数据结构(对象模型),执行操作(动态模型),并且完成效据值的变化 (功能模型)。

    四、面向对象设计

    准则模块化、抽象化、信息隐藏和封装、对象的高内聚和弱耦合、可扩充性、可重用性。

    面向对象设计的内容

    五、面向对象的实现

    设计风格

    1. 提高可重用性
    2. 提高方法的内聚、降低耦合
    3. 减小方法的规模
    4. 保持方法的一致性
    5. 尽量做到全面覆盖  
    6. 分开策略方法和实现方法
    7. 利用继承机制
    8. 提高可扩充性
    9. 封装实现策略
    10. 慎用公有方法
    11. 控制方法的规模

    测试策略

    六、面向对象方法学的优点与缺点

    优点

    1.与人类习惯的思维方法一致

    2.稳定性好

    3.可重用性好

    4.可拓展性

    5.可维护性

    缺点

    1.面向对象需要更关注需求、分析和设计

    2.面向对象需要完全改变每一个人的思想

    3面向对象需要改变软件开发文化

    4.面向对象的许多优点是长期的

    5.面向对象要求先在培训、教育和工具上投资

    6.面向对象要求更多的测试工作

    7.面向对象技术不能保证能构造出正确的系统

    展开全文
  • 1.面向对象概念 1.面向对象编程:程序设计的范式,把程序当成不同对象的相互调用 ...3.数据封装 在类中封装每一个实例的属性,不同的实例有相同的数据类型,但是有不同的属性 2.python创建实例属性虽然可以通过Pe

    1.面向对象概念

    1.面向对象编程:程序设计的范式,把程序当成不同对象的相互调用
    2.基本思想:类与实例 类:class 定义抽象的数据类型 人 class person:
    实例 :根据类的定义创建出来的 林明道 = person()
    区分不同的类型和实体变量
    3.数据封装 在类中封装每一个实例的属性,不同的实例有相同的数据类型,但是有不同的属性

    2.python中创建实例属性

    虽然可以通过Person类创建出xiaoming、xiaohong等实例,但是这些实例看上除了地址不同外,没有什么其他不同。在现实世界中,区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。

    如何让每个实例拥有各自不同的属性?由于Python是动态语言,对每一个实例,都可以直接给他们的属性赋值,例如,给xiaoming这个实例加上name、genderbirth属性:

    xiaoming = Person()
    xiaoming.name = 'Xiao Ming'
    xiaoming.gender = 'Male'
    xiaoming.birth = '1990-1-1'

    xiaohong加上的属性不一定要和xiaoming相同:

    xiaohong = Person()
    xiaohong.name = 'Xiao Hong'
    xiaohong.school = 'No. 1 High School'
    xiaohong.grade = 2

    实例的属性可以像普通变量一样进行操作:

    xiaohong.grade = xiaohong.grade + 1

    3.python中初始化实例属性

    虽然我们可以自由地给一个实例绑定各种属性,但是,现实世界中,一种类型的实例应该拥有相同名字的属性。例如,Person类应该在创建的时候就拥有 name、gender 和 birth 属性,怎么办?

    在定义 Person 类时,可以为Person类添加一个特殊的__init__()方法,当创建实例时,__init__()方法被自动调用,我们就能在此为每个实例都统一加上以下属性:

    class Person(object):
        def __init__(self, name, gender, birth):
            self.name = name
            self.gender = gender
            self.birth = birth

    __init__() 方法的第一个参数必须是 self(也可以用别的名字,但建议使用习惯用法),后续参数则可以自由指定,和定义函数没有任何区别。

    相应地,创建实例时,就必须要提供除 self 以外的参数:

    xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
    xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')

    有了__init__()方法,每个Person实例在创建时,都会有 name、gender 和 birth 这3个属性,并且,被赋予不同的属性值,访问属性使用.操作符:

    print xiaoming.name
    # 输出 'Xiao Ming'
    print xiaohong.birth
    # 输出 '1992-2-2'

    要特别注意的是,初学者定义__init__()方法常常忘记了 self 参数:

    >>> class Person(object):
    ...     def __init__(name, gender, birth):
    ...         pass
    ... 
    >>> xiaoming = Person('Xiao Ming', 'Male', '1990-1-1')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: __init__() takes exactly 3 arguments (4 given)

    这会导致创建失败或运行不正常,因为第一个参数name被Python解释器传入了实例的引用,从而导致整个方法的调用参数位置全部没有对上。

    4.python中访问限制(__xxx)

    我们可以给一个实例绑定很多属性,如果有些属性不希望被外部访问到怎么办?

    Python对属性权限的控制是通过属性名来实现的,如果一个属性由双下划线开头(__),该属性就无法被外部访问。看例子:

    class Person(object):
        def __init__(self, name):
            self.name = name
            self._title = 'Mr'
            self.__job = 'Student'
    p = Person('Bob')
    print p.name
    # => Bob
    print p._title
    # => Mr
    print p.__job
    # => Error
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'Person' object has no attribute '__job'

    可见,只有以双下划线开头的"__job"不能直接被外部访问。

    但是,如果一个属性以"__xxx__"的形式定义,那它又可以被外部访问了,以"__xxx__"定义的属性在Python的类中被称为特殊属性,有很多预定义的特殊属性可以使用,通常我们不要把普通属性用"__xxx__"定义。

    单下划线开头的属性"_xxx"虽然也可以被外部访问,但是,按照习惯,他们不应该被外部访问。

    5.python中创建类属性

    类是模板,而实例则是根据类创建的对象。

    绑定在一个实例上的属性不会影响其他实例,但是,类本身也是一个对象,如果在类上绑定一个属性,则所有实例都可以访问类的属性,并且,所有实例访问的类属性都是同一个!也就是说,实例属性每个实例各自拥有,互相独立,而类属性有且只有一份。

    定义类属性可以直接在 class 中定义:

    class Person(object):
        address = 'Earth'
        def __init__(self, name):
            self.name = name

    因为类属性是直接绑定在类上的,所以,访问类属性不需要创建实例,就可以直接访问:

    print Person.address
    # => Earth

    对一个实例调用类的属性也是可以访问的,所有实例都可以访问到它所属的类的属性:

    p1 = Person('Bob')
    p2 = Person('Alice')
    print p1.address
    # => Earth
    print p2.address
    # => Earth

    由于Python是动态语言,类属性也是可以动态添加和修改的:

    Person.address = 'China'
    print p1.address
    # => 'China'
    print p2.address
    # => 'China'

    因为类属性只有一份,所以,当Person类的address改变时,所有实例访问到的类属性都改变了。

    6.python中类属性和实例属性名字冲突怎么办

    修改类属性会导致所有实例访问到的类属性全部都受影响,但是,如果在实例变量上修改类属性会发生什么问题呢?

    class Person(object):
        address = 'Earth'
        def __init__(self, name):
            self.name = name
    
    p1 = Person('Bob')
    p2 = Person('Alice')
    
    print 'Person.address = ' + Person.address
    
    p1.address = 'China'
    print 'p1.address = ' + p1.address
    
    print 'Person.address = ' + Person.address
    print 'p2.address = ' + p2.address

    结果如下:

    Person.address = Earth
    p1.address = China
    Person.address = Earth
    p2.address = Earth

    我们发现,在设置了 p1.address = 'China' 后,p1访问 address 确实变成了 'China',但是,Person.address和p2.address仍然是'Earch',怎么回事?

    原因是 p1.address = 'China'并没有改变 Person 的 address,而是给 p1这个实例绑定了实例属性address ,对p1来说,它有一个实例属性address(值是'China'),而它所属的类Person也有一个类属性address,所以:

    访问 p1.address ,优先查找实例属性,返回'China'。

    访问 p2.address ,p2没有实例属性address,但是有类属性address,因此返回'Earth'。

    可见,当实例属性和类属性重名时,实例属性优先级高,它将屏蔽掉对类属性的访问。

    当我们把 p1 的 address 实例属性删除后,访问 p1.address 就又返回类属性的值 'Earth'了:

    del p1.address
    print p1.address
    # => Earth

    可见,千万不要在实例上修改类属性,它实际上并没有修改类属性,而是给实例绑定了一个实例属性。

    7.python中定义实例方法

    一个实例的私有属性就是以__开头的属性,无法被外部访问,那这些属性定义有什么用?

    虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外,还可以定义实例的方法。

    实例的方法就是在类中定义的函数,它的第一个参数永远是 self,指向调用该方法的实例本身,其他参数和一个普通函数是完全一样的:

    class Person(object):
    
        def __init__(self, name):
            self.__name = name
    
        def get_name(self):
            return self.__name

    get_name(self) 就是一个实例方法,它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。

    调用实例方法必须在实例上调用:

    p1 = Person('Bob')
    print p1.get_name()  # self不需要显式传入
    # => Bob

    在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

    8.python中方法也是属性(给一个实例动态添加方法, types.MethodType())

    我们在 class 中定义的实例方法其实也是属性,它实际上是一个函数对象:

    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
        def get_grade(self):
            return 'A'
    
    p1 = Person('Bob', 90)
    print p1.get_grade
    # => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
    print p1.get_grade()
    # => A

    也就是说,p1.get_grade 返回的是一个函数对象,但这个函数是一个绑定到实例的函数,p1.get_grade() 才是方法调用。

    因为方法也是一个属性,所以,它也可以动态地添加到实例上,只是需要用 types.MethodType() 把一个函数变为一个方法:

    import types
    def fn_get_grade(self):
        if self.score >= 80:
            return 'A'
        if self.score >= 60:
            return 'B'
        return 'C'
    
    class Person(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
    
    p1 = Person('Bob', 90)
    p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
    print p1.get_grade()
    # => A
    p2 = Person('Alice', 65)
    print p2.get_grade()
    # ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
    # 因为p2实例并没有绑定get_grade

    给一个实例动态添加方法并不常见,直接在class中定义要更直观

    9.python中定义类方法(@classmethod

    和属性类似,方法也分实例方法类方法

    class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。

    要在class中定义类方法,需要这么写:

    class Person(object):
        count = 0
        @classmethod
        def how_many(cls):
            return cls.count
        def __init__(self, name):
            self.name = name
            Person.count = Person.count + 1
    
    print Person.how_many()
    p1 = Person('Bob')
    print Person.how_many()

    通过标记一个 @classmethod,该方法将绑定到 Person 类上,而非类的实例。类方法的第一个参数将传入类本身,通常将参数名命名为 cls,上面的 cls.count 实际上相当于 Person.count

    因为是在类上调用,而非实例上调用,因此类方法无法获得任何实例变量,只能获得类的引用。


    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
    展开全文
  • Python从设计之初就已经是一门面向对象的语言,正因为如此,Python创建一个和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些...
  • 软件工程之面向对象方法

    千次阅读 热门讨论 2019-11-17 20:16:50
    面向对象方法的基本思想是从现实世界客观存在的事物出发来构造软件系统,并系统构造尽可能运用人类的自然思维方式。 1、与人类习惯的思维方法一致 面向对象的软件技术是以对象为核心,用这种技术开发出的...
  • 什么是面向对象,以及什么是和对象

    千次阅读 多人点赞 2019-08-11 19:04:04
    什么是面向对象,以及什么是和对象 ​ 1.1面向过程与面向对象的区别 ​ 面向对象是一种现在最为流行的程序设计方法 。将面向过程与面向对象进行比较。 ​ 首先这两个种都是一种编程思维, 一些简单的动作...
  • JAVA中类实例与Class对象

    千次阅读 2019-03-22 14:29:41
    面向对象编程语言的一个重要概念,它是对一项事物的抽象概括,可以包含该事物的一些属性定义,以及操作属性的方法面向对象编程,我们都是以来编码。 实例 简单理解,就是new,就是对实例化,创建...
  • Python面向对象练习题汇总

    千次阅读 多人点赞 2020-07-29 17:34:32
    对象的抽象,对象实例。 2. python如何定义一个的格式 class 类名(object): 成员(方法) 3. (class)由哪三个部分构成 类名,属性,方法。 4. 类名的命名规则是什么 要遵循标识符的命名规范,尽量...
  • 【软件工程】第六章 面向对象方法

    万次阅读 2019-03-27 20:26:30
    6.1 面向对象方法的概念 6.1.2 主要特点 用对象作为对事物的抽象表示,并以此作为系统的基本构成单位。 事物的静态特征用对象的属性表示。 事物的动态特征(即事物的行为)用对象的操作表示。 对象的属性和操作...
  • 早期方法的不足: 早期的方法只使用一种系统的视角作为构造块,而没有容纳其他视角。 1、结构化分析和设计方法集中于将功能作为系统的构造块...为了克服传统开发方法的不足,面向对象方法解决问题的思路 是从现实世...
  • 面向对象名词简介 (Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合每个对象所共有的属性和方法。对象是实例方法类中定义的函数。 变量:变量整个实例化的对象是公用的...
  • 面向对象方法中的数据库设计

    千次阅读 2017-10-23 21:14:05
    在面向对象中,是没有数据流这一说法的。业务的完成是由对象及消息来完成的,只有“对象流”,没有数据流。
  • OOP面向对象——实例——电梯

    千次阅读 2016-08-11 23:40:53
    package 面向对象实例; //import java.util.Scanner; //面向对象的写法:oo(面向对象) //A不是基本数据类型,是8种基本数据类型之外的扩展类型,也叫类型 public class Print99 {//A封装了三个变量,原来...
  • 第四讲:面向对象程序设计方法、对象的概念  掌握:面向对象程序设计的方法及特点;的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;和对象的作用;面向对象和面向过程的程序...
  • 深入理解Python面向对象

    万次阅读 多人点赞 2017-06-12 06:42:41
    面向过程与面向对象的对比 id、type和value的讲解 和对象的概念 初始化构造函数__init__的作用 self关键字的使用 继承的概念 组合的概念 接口的概念 抽象的概念 1、面向过程与面向对象的对比面向过程的程序设计...
  • 面向对象的分析方法

    千次阅读 2015-05-11 21:55:16
    一个系统的开发过程进行了系统业务调查以后,按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是系统调查资料的基础上,针对OO方法所需要的素材进行的归类分析和整理,而不是对管理...
  • 本文实例讲述了Javascript面向对象程序设计单例模式原理与实现方法。分享给大家供大家参考,具体如下: 1.单例模式概述 源自百度百科对于单例模式的定义: 单例模式的意思就是只有一个实例。单例模式确保某一个...
  • java面向对象与对象

    千次阅读 2018-08-09 21:25:57
    所以面向对象程序设计的重点是的设计,而不是对象的设计。对事物的属性,也就是成员变量,操作属性的方法,也就是成员函数进行了封装,只要通过new关键字创建对象么就可以对对象的属性进行赋值,然后调用对象的...
  • JAVA 面向对象方法详解

    千次阅读 2016-07-17 23:08:29
    本页面更新日期: 2016年07... 方法在逻辑上要么属于, 要么属于对象. 方法的所属性 一旦将一个方法定义某个体内. 如果这个方法使用了static修饰符,则这个方法属于这个. 否则这个方法属于这个实例.
  • 面向对象的软件开发方法

    千次阅读 2020-03-04 13:04:09
    2、面向对象方法的解决思路是从现实世界的客观对象入手,尽量运用人类的自然思维方式来构造软件系统。是一种运用对象、、继承、封装、聚合、消息传送、多态性等概念来构造系统的软件开发方法。 3、面向对象方法...
  • 【软件工程】面向对象方法

    万次阅读 热门讨论 2018-03-09 15:46:33
    所谓面向对象就是基于对象概念,以对象为中心,以和继承为构造机制,来认识、理解、刻画客观世界和设计、构建相应的软件系统。20世纪80年代末以来,面向对象技术成为研究的热点,由于该方法能够提供更加清晰的需求...
  • Python从设计之初就已经是一门面向对象的语言,正因为如此,Python创建一个和对象是很容易的。 一、面向对象技术简介 (Class) : 用来描述具有相同的属性和方法的对象的集合。它定义了该集合每个对象所共有...
  • 文章目录类(Class)类的定义与使用类的构造方法类的属性与方法私有属性与私有方法类变量与实例变量静态方法与类方法继承与多态 类(Class) 类的定义与使用 类必须被定义后才能使用,定义一个类也就是定义这一类...
  • 【Java基础4】面向对象(上)

    千次阅读 2021-03-15 21:07:00
    3、 定义在类中的变量被称为______,定义在方法中的变量被称为______ 4、 面向对象程序设计的重点是______的设计,______是用来创建对象的模板。 5、 在非静态成员方法,可以使用关键字______访问的其它非静态...
  • 面向对象编程基本概念

    千次阅读 2018-04-18 15:41:53
    面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。由于C ++引入了OOP,因此用户体验已经...
  • C++基础---面向对象建模方法

    千次阅读 2015-09-13 17:41:38
    1. 面向对象的建模方法 1.1 OMT/Rumbaugh方法 OMT(Object Modeling Technique)方法: (1)OMT方法最早是由Loomis,Shan和Rumbaugh1987年提出的,曾扩展应用于关系数据库设计。Jim Rumbaugh1991年正式把OMT...
  • Python 面向对象

    千次阅读 2021-02-10 15:43:05
    Python 面向对象作者:杨梦鸽校对:翟舒青Python从设计之初就已经是一门面向对象的语言,正因为如此,Python创建一个和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,404
精华内容 73,761
关键字:

在面向对象方法中,类的实例称为