面向对象编程详解-优快云博客

面向过程
函数式编程
面向对象

面向过程

所谓过程就是我们解决问题的步骤，一步步按照流程走，有先后之分。

优缺点：

优点
- 复杂的问题流程化，将问题分解简化
缺点
- 拓展性不好，

面向对象

核心是对象。

正式的来说

对象是一个数据以及相关行为的集合
面向对象是功能上指向建模对象

通过数据和行为方式来描述交互对象的集合

在Python中，一切皆为对象

面向对象的优缺点

优点
- 解决程序的拓展性
缺点
- 复杂度高于面向过程
- 交互式解决问题，无法准确预测结果

类就是类别、种类

对象就是特征和技能的统一体

类则是着一系列相似对象的特征和技能的结合

对于现实世界，现有个体（即对象），才有类别；但对于程序，必须先有类，然后才有对象

面向对象编程

OOP（object oriented programing）

其实一种程序设计思想。OOP把对象作为程序的一个基本单元，一个对象就包含了数据的操作数据的函数

在Python中，所有数据类型都可以视为对象，同时，我们也可以自定义对象

自定义的对象的数据类型就是面向对象中类（class）的概念

Demo:

假如要处理我们的成绩。为了表示学生的成绩：

面向过程的方式

stu1 = ['name':'Tom', 'score':'99']
stu2 = ['name':'Jack', 'score':'66']

利用函数来实现

def find_score(stu):
    print(stu['name'], ':', stu['score'])
find_score(stu1)

面向对象

class Student:
    def __init__(self, name, score)：
        self.name = name
        self.score = score
    def find_score(self)：
        print(self.name, ':', self.score)
        
stu1 = Student('Tom', 99)
stu1.find_score()

常见的概念

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
**类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
**数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
**方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
**局部变量：**定义在方法中的变量，只作用于当前实例的类。
**实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
**继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
**实例化：**创建一个类的实例，类的具体对象。
**方法：**类中定义的函数。
**对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类的定义和使用

面向对象设计的思想，先抽象出类，再根据类创建出实例

类的定义

class ClassName(object):
    '''dicsting'''
    class_statement

创建一个类

类的命名，大驼峰式

变量名称的单词首字母大写

class MyFirstClass:
    pass

类的作用是一个模板。我们可以在船舰实例的时候，把一些我们认为必须要绑定的属性填写进去。这是我们就通过特殊的__init__方法。在创建实例的时候，绑定相关的属性。比如前面的name, score

class student:
    def __init__(self, name, skill):
        self.name = name
        self.skill = skill
stu1 = student('TOM','sing')   #实例化
print(stu1.name, stu1.skill)

和普通函数相比，在类中定义方法时，第一个参数必须是self。除第一个参数外，其他的和普通参数没有什么区别

self代表的是实例，而非类

__init__方法

1.为对象初始化自己的特征
2.该方法中可以有任意的代码，但是一定不可以有返回值

数据分装

class Student:
    def __init__(self, name, score)：
        self.name = name
        self.score = score
    def find_score(self)：
        print(self.name, ':', self.score)
        
stu1 = Student('Tom', 99) #实例化的过程
stu1.find_score()

我们通过__init__()让stu1实例本身就拥有了县官数据，如果要访问这些数据，我们可以直接在Student类的内部定义相关的函数来访问数据，一次封装数据

这些封装数据的函数和Student类本身是关联起来的，他们被称之为方法

类得两个作用：

属性引用
- 类名.属性
实例化
- 类名加上一个括号就是实例化，他能够自动触发__init__函数得运行
  
  进而为每一个实例定制自己的特征

类属性的补充

类属性的查看

dir(类名)
- 返回一个列表
类名.__dict__
- 返回一个字典，key为属性名，value是属性值

特殊的属性

类名.__name__  #返回类的名字
类名.__doc__   #返回类的说明文档字符串
类名.__base__  #返回类的第一个父类
类名.__bases__ #返回类的所有父类组成的元组
类名.__module__#返回类定义所在模块
类名.__class__ #返回实例所对应的类
类名.__dict__  #返回类的字典属性

总结

class ClassName:
    def __init__(self, 参数一, 参数二):
        self.对象属性1 = 参数一
        self.对象属性2 = 参数二
    def 方法名1(self):
        pass
    def 方法名2(self):
        pass
obj = ClassName(参数1，参数2)
#对象的实例化，代表具体的东西，传递实参
#ClassName():调用__init__
#括号内传参，无需传入self,参数一一对应
#结果是返回对象obj

obj.对象属性1 #查看对象的属性
obj.方法名1 #调用类的方法

对象之间的交互

加入说现在定义两个类 Person Dog

class Person:
    def __init__(self, name, aggressivity, life_value):
        self.name = name
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self, dog):
        dog.life_value -= self.aggressivity

class Dog:
    def __init__(self, name ,breed, aggressivity, life_value):
        self.name = name
        self.breed = breed
        self.aggressivity = aggressivity
        self.life_value = life_value
    def bite(self,people):
        people.life_value -= self.aggressivity

per = Person('Jack', 5, 1000)
dog = Dog('jerry', 'boss', 8, 700)
per.attack(dog)
print(dog.life_value)

类命名空间与对象、实例的空间

创建一个类就会创建一个类的名称空间，用来存储我们定义的所有的变量名。这些名字就是属性

类的属性有两种：

静态属性
- 直接在类中定义的变量
动态属性
- 在类中定义的方法

静态属性是共享给所有对象的

class Student:
    school = 'zucc'
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def find_score(self):
        print(self.name, ':', self.score)

stu1 = Student('Tom', 99)
stu2 = Student('Jack', 66)
print(id(stu1.school))
print(id(stu2.school))

print(stu1.find_score)
print(stu2.find_score)

1296896721392
1296896721392
<bound method Student.find_score of <__main__.Student object at 0x0000012DF5118CC0>>
<bound method Student.find_score of <__main__.Student object at 0x0000012DF5118CF8>>

类的大特征

继承
多态
封装

继承

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类(SubClass)

,而被继承的类则被称为基类，父类，超类(Base Class, Father Class, Supper Class)

比如，我们定义一个动物类(Animal),其有一个run()方法如下:

class Animal(object):#如果你的类没有从任何祖先类派生，可以使用 object 作为父类的名字或不写括号
    def run(self):
        print('Animal is running')
class Dog(Animal):   #单继承
    pass
class Cat(Animal):
    pass
class Husky(Dog):
    pass
class Animal222:
    pass
class Mouse(Animal222, Animal): #多继承
    pass
pig = Husky()
pig.run()
dog = Dog()
cat = Cat()
dog.run()
cat.run()
print(Husky.__bases__)   #继承的查看
print(Mouse.__bases__)
print(Animal.__bases__)
print(Animal222.__class__)
#如果不指定基类，Python类会默认继承object类
#object类是所有Python类的基类，提供宜些常见方法的实现

Animal is running
Animal is running
Animal is running
(<class '__main__.Dog'>,)
(<class '__main__.Animal222'>, <class '__main__.Animal'>)
(<class 'object'>,)
<class 'type'>

多态

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，在运行代码时，

总会调用子类和父类同名的方法

这样就是继承的另外一个好处，多态

class Animal(object):
    def run(self):
        print('Animal is running')
class Dog(Animal):
    def run(self):
        print('Dog is running')        
dog = Dog()
dog.run()

Dog is running