day6 - 面向对象学习

面向对象介绍

特性

class

object

封装

继承

https://segmentfault.com/a/1190000002685939

python2 经典类是按照深度优先来继承的；新式类是按照广度优先继承的。

python3经典类，新式类都是按照广度优先来继承的

多态

语法

属性

方法

构造函数

析构函授

私有方法，私有属性

类变量

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的几个核心特性如下

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象 
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态
态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

无论用什么形式来编程，我们都要明确记住以下原则：

  1. 写重复代码是非常不好的低级行为
  2. 你写的代码需要经常变更 

cs代码

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC

class Role(object):#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写
    n = 123#类变量
    name = "rose"
    def __init__(self, name, role, weapon, life_value=100, money=15000):#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.name = name #实例变量（静态属性），作用域：实例本身
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    def shot(self): #类的方法（动态属性）
        print("shooting...")
    def got_shot(self):
        print("ah...,%s got shot..."% (self.name))
    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name))

print(Role.n) #调用类变量，全局的
#生成两个实例
r1 = Role(‘Alex‘, ‘police‘, ‘AK47‘) #生成一个r1角色  Role类的实例
r2 = Role(‘Jack‘, ‘terrorist‘, ‘B22‘)  #生成一个r2角色

print(r1.n,r1.name)  #实例以后，先调用实例变量，如果没有才找类变量
r1.name = "AAAAAA" #修改实例面变量
print(r1.n,r1.name)

r1.bullet_prove = True #给实例添加新属性
print(r1.name,r1.role,r1.bullet_prove,r1.weapon)

del r1.weapon #删除一个属性
#print(r1.name,r1.role,r1.bullet_prove,r1.weapon) #缺少weapon，报错
print(r1.name,r1.role,r1.bullet_prove)

r1.n = "改变类变量" #只改变实例r1中的n
print("r1",r1.role,r1.n)
print("r2",r2.role,r2.n)

Role.n = "ABC"
print(r1.n,r2.n) #r1.n不变，r2.n变

# r1.got_shot()
# r1.buy_gun("AA")
# print(r1.name)

面向对象的特性：

封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
#学校，讲师，学员
class School(object):
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.teachers = []
        self.staffs = []
    def enroll(self,stu_obj):
        print("%s 办理手续" % stu_obj.name)
        self.students.append(stu_obj)
    def hire(self,staff_obj):
        self.teachers.append(staff_obj)
        print("雇佣新老师%s"% staff_obj.name)
    def all_memeber(self,all_obj):
        self.staffs.append(all_obj.name)

class SchoolMemeber(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        pass

class Teacher(SchoolMemeber):
    def __init__(self,name,age,sex,salary,course):
        super(Teacher,self).__init__(name,age,sex)
        self.salary = salary
        self.course = course
    def tell(self):
        print(‘‘‘
            ------info of Teacher:%s-----
            Nmae:%s
            Age:%s
            Sex:%s
            Salary:%s
            Course:%s‘‘‘ % (self.name,self.name, self.age, self.sex, self.salary,self.course))

    def teach(self):
        print("%s is teaching course [%s]"% (self.name,self.course))

class Student(SchoolMemeber):
    def __init__(self,name,age,sex,stu_id,grade):
        super(Student,self).__init__(name,age,sex)
        self.stu_id = stu_id
        self.grade = grade
    def tell(self):
        print(‘‘‘
            ------info of Student:%s-----
            Nmae:%s
            Age:%s
            Sex:%s
            Stu_id:%s
            Grade:%s‘‘‘ % (self.name,self.name,self.age,self.sex,self.stu_id,self.grade))

    def pay_tuition(self,amount):
        print("%s has paid tution for $%s"% (self.name,amount))

#创建实例
school = School("老男孩","沙河")

t1 = Teacher("Oldboy",56,"MF","200000","Linux")
t2 = Teacher("Alex",22,"M","20000","python")

s1 = Student("DCC",36,"F",1001,"python3")
s2 = Student("DCC2",36,"F",1002,"Linux2")

# t1.tell()
# t2.tell()
# s1.tell()
# s2.tell()
school.hire(t1)
school.hire(t2)
school.enroll(s1)
school.enroll(s2)
school.all_memeber(t1)
school.all_memeber(t2)
school.all_memeber(s1)
school.all_memeber(s2)
print("===========")
print(school.students)
print(school.teachers)
print(school.staffs)
print("===========")
school.teachers[0].teach()

for stu in school.students:
    stu.pay_tuition(5000)

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 

Pyhon不直接支持多态，但可以间接实现

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return ‘Meow!‘

class Dog(Animal):
    def talk(self):
        return ‘Woof! Woof!‘

animals = [Cat(‘Missy‘),
           Dog(‘Lassie‘)]

for animal in animals:
    print animal.name + ‘: ‘ + animal.talk()

析构函数

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC

#析构函数，在实例释放 销毁的时候，就会自动执行。通常用于一个收尾工作，如关闭一些打开的文件或数据库连接
class Role(object):#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写
    n = 123#类变量
    name = "rose"
    def __init__(self, name, role, weapon, life_value=100, money=15000):#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.name = name #实例变量（静态属性），作用域：实例本身
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value #私有属性，将这个变量隐藏了，外部打印不可见
        self.money = money
    def shot(self): #类的方法（动态属性）
        print("shooting...")
    def got_shot(self):
        print("ah...,%s got shot..."% (self.name))
    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name))
    def __del__(self): #析构函数，
        print("%s 彻底死了。。。。" % self.name)

    def show_life_value(self): #查看私有属性的方法。
        print("name:%s weapon:%s life_walue:%s" %(self.name,self.weapon,self.__life_value))

r1 = Role(‘Alex‘, ‘police‘, ‘AK47‘)
r1.buy_gun("AKAK")
r1.got_shot()
del r1 #删除实例
r2 = Role(‘Jack‘, ‘terrorist‘, ‘B22‘)
r2.got_shot()
#print(r1.__life.value) #私有属性报错，不可直接打印
print(r2.show_life_value()) #如果想要查看私有属性，需要定义一个方法。

#私有方法/私有属性，名字前加“__”
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
#继承/多态

#class People: #经典类
class People(object):#新式类

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating" % self.name)
    def sleep(self):
        print("%s is sleeping" % self.name)
    def talk(self):
        print("%s is talking" % self.name)

class Renlation(object):
    def make_friends(self,obj):
        print("%s is make friend with %s" % (self.name,obj.name))

class man(People,Renlation):
    def __init__(self,name,age,money): #增加新属性
        People.__init__(self,name,age)
        #super(man,self).__init__(name,age) #另外一种写法。新式类使用
        self.money = money
        print("%s 出生就有 %s 钱" % (self.name,self.money))
    def piao(self):
        print("%s is piaoing" % self.name)
    def sleep(self):
        # 重构父类方法
        People.sleep(self)
        print("man %s is piaoing" % self.name )

m1 = man("name1","22","100")
# m1.eat()
# m1.piao()
# m1.sleep()

print("================")
class woman(People,Renlation):
    def get_birth(self,haha):
        print("%s is birthing baby.." % self.name)
        print("%s is birthing baby.." % haha)
w1 = woman("name2","23")

w1.get_birth("AAA")
#w1.name = "BBBB"
m1.make_friends(w1)
时间： 2024-12-28 11:51:51

day6 - 面向对象学习的相关文章

Python之路,Day6 - 面向对象学习

面向过程 VS 面向对象 编程范式 编程是 程序 员 用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 , 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式有很多种不同的方式, 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式. 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路, 大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式. 两种最重要的编程范式分别是面向过

python Day6 面向对象学习

面向过程 VS 面向对象 编程范式 编程是 程序 员 用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 , 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式有很多种不同的方式, 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式. 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路, 大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式. 两种最重要的编程范式分别是面向过

面向对象学习笔记

abstract:抽象类或方法的关键字注意事项:一个类中至少有一个抽象方法不允许有大括号主要意义就是规范方法,要求必须按照抽象中的方法来写继承抽象类的类,必须重载完全抽象类的方法抽象类是不能被实例化的,因为本身没有意义 extends 继承的关键字 类中常用的关键字:final 被定义的类不能被继承,该类的方法不能被继承,相当于一个锁的功能self self::静态成员,相当于类名称::静态成员,和this是有区别的,$this访问类中的内容必须实例化,而self是直接可以访问类中的内容的,多用

php面向对象学习

php面向对象学习 近期跟着别人开发一套php程序,深感自己面向对象很白痴,于是再次巩固了一下面向对象的学习,自己整理了一下这几天面向对象的东西,给大家分享!! 面向对象的三大特性: 封装 -- 隐藏内部实现,稳定外部接口 继承 -- 子类继承父类成员,实现代码复用 多态 -- 不同子类对同一消息做出不同的反映 一.接口 -- 是一套规范,遵守这个规范就可以实现功能 在PHP中,接口同样是一种规范和标准,可以约束类的行为,定义一个接口不指定具体的实现. 接口是把隐式公共方法和属性组合起来,以封装

面向对象学习【类-匿名类】

匿名类是就就像这个词一样,是一个没有名字的类,看到这个匿名类有点迷糊了,如果大家想想一个类没有名称的话那么我们如何来使用他创建实例呢?答案就是我们可以使用 var 来声明一个匿名的类,创建的格式为: new anonymousClassName{字段1,字段2,........} 说明: 匿名类当中的字段都全部都是public类型的,这就意味着我们可以在外部随意有访问这个所谓的匿名类: 看着这么爽其实这个匿名类还有很多的限制如: 1.使用匿名类时,必须对其初始化: 2.只能包含public字段;

面向对象学习【类-静态类】

静态类只能包含静态成员(使用该类创建的所有对象将共享这些成员的同一个副本).静态类纯粹作为工具方法和字段的一个容器来使用.静态类不能包含任何实例数据或方法.另外,使用new操作符来创建静态类的一个对象是没有意义的.如果坚持这样做,编译器会报错.如果需要执行任何初始化,那么static类可以包含一个默认的构造器,前提是该构造器也被声明为static.其他任何类型的构造器都是非法的,编译器会报错: 比如自己定义一个Math类,其中只包含静态成员,那么应该像下面这样写: public static c

Delphi面向对象学习(-)

Delphi面向对象学习随笔一:类与对象的关系作者:巴哈姆特http://www.cnpack.org(转载请注明出处并保持完整)工作几年了,总想做点总结,于是有了这篇东西,叫随笔吧呵    本文只是写写我对对象化的理解,主观成分很多,或许有错误,希望大家指正^_^    PS: 本文的演示代码均以Delphi 的Object Pascal语法为准. 类与对象的关系    要讨论类与对象的关系,需要先说一下什么是类,什么是对象. 类:    类.我认为是一个集合,和数学中的集合一样,是一类事物的

Php面向对象学习笔记 – 构造、析构、对象赋值、克隆

Php面向对象学习笔记 – 构造.析构.对象赋值.克隆 class student { public  $stu_id;       // 定义成员变量 public  $stu_name; public  function sayName()   // 成员函数 { echo $this->stu_name;   // $this  访问该对象的成员变量 } } $stu = new  Student;      // 创建对象 $stu->stu_id = '0607001'; $stu-

js面向对象学习 - 对象概念及创建对象

原文地址:js面向对象学习笔记 一.对象概念 对象是什么?对象是“无序属性的集合,其属性可以包括基本值,对象或者函数”.也就是一组名值对的无序集合. 对象的特性(不可直接访问),也就是属性包含两种,数据属性和访问器属性. 1.数据属性又包含 Configurable //表示能否通过delete删除,默认为true: Enumerable //表示能否通过for-in循环返回属性,默认为true; Writable  //表示能否修改属性的值,默认为true; Value