python 初识面向对象

1. 初识面向对象
面向过程:
一切以事务的发展流程为中心.
面向对象:
一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象

打比方:
大象进冰箱
步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门

面向对象:大象, 你进冰箱.
此时主语是大象. 我操纵的是大象. 此时的大象就是对象

class Car:  # 类名首字母大写,严格蹲守驼峰命名规则
    pass


# 造车
c = Car()  # 类名()  # 创建对象

#  出厂之后进行改装
c.color = '红颜色'  # 对象.属性    点:的  当属性不存在的时候, 添加一个属性
c.pai = '京A8888'  # 对象.属性
c.pailiang = '555L'  # 排量

print(c.color)  # 此车是红颜色
print(c.pai)
print(c.pailiang)

c.color = '绿颜色'  # 当属性存在的时候是修改属性信息
# 对象.属性 =xxx 设置属性信息
print(c.color)

2. 类. 对象
类: 就是图纸. 创建对象的第一步. 先画图纸. 先写类.
对象: 对象就是车. 通过图纸造出来的具体的东西. 通过类来创建对象

类与对象的关系:
类是对xxx事物的归类.
写:
__init__(self, 参数) 参数一般作为属性设置给对象. 对象就是self, 对属性的封装.

def 方法(self, 参数): 方法. 第一个参数一般是固定的self. 当前类的对象.
pass

对象是xx类型的一个具体
创建对象: 类名()

创建类:
class 类名:

def __init__(self): # 初始化方法. 又被成为构造方法
self.属性 = 值
self.属性 = 值
self.属性 = 值

def fangfa(self):
方法体(函数体, return)

创建对象:
变量 = 类名() # 实例化 <-> 创建对象

变量.属性 # 访问对象的属性信息
变量.方法() # 访问类中的方法

1.
class Car:  # 类名首字母大写,严格蹲守驼峰命名规则
    # __init__方法是一个特殊的方法. 初始化方法. (构造方法)
    # 在创建对象的时候会自动的调用__init__()
    # self就是你创建出来的那个对象
    def __init__(self):  # init初识方法. 在创建对象的时候. 默认执行这个函数
        print('我是init')
        print('self=', self)


c = Car()  # 创建Car类型对象. 此时self参数不需要我们管
print('c=', c)

2.
class Car:  # 类名首字母大写,严格蹲守驼峰命名规则
    def __init__(self, color, pai, pailiang):  # init初识方法. 在创建对象的时候. 默认执行这个函数
        # self.color = '红色' # 在出厂的时候都是红色 静态的
        self.color = color  # 动态获取 第一个color是设置 第二个color是获取的参数
        self.pai = pai
        self.pailiang = pailiang

    # 跑: 动作, 功能 -> 函数
    # 在类中写的函数-> 方法
    # self 当前类的对象
    def pao(self):  # self是自动传递的. 不用管它
        print('%s我的车能跑' % self.color)  #self.color
    def jump(self):
        print('you jump, I jump')
#
#
#
#
c = Car('红色', '京A8888', '555L')  # 创建Car类型对象. 此时self参数不需要我们管
c2 = Car('蓝色', '京B6666', '1.6T')
print(c.color)
print(c2.color)
#
#
c.pao()
c2.pao()
c.jump()

3. 面向对象和面向过程的对比
如果写一些比较小的程序用面向过程.
程序很复杂. 很庞大建议用面向对象.

4. 面向对象的三大特征
封装:
1. 对属性的封装(__init__())
self.xxx = xxx
2. 对方法和功能的封装

继承
子类自动拥有父类中除了私有内容外的其他所有内容
class Bar(Foo): Bar对Foo进行了扩展
pass

当出现x是一种y的时候. 推荐使用继承关系
python支持多继承. 查找顺序: 先找离他近的.

class Foo:
    def getMoney(self):
        print('拿钱')

class Bar(Foo):
    pass

b = Bar()
b.getMoney()  # 此时调用的是父类中的方法

多态(python原生直接就是多态)
python更多的支持的是鸭子模型, 只要会嘎嘎叫就是好鸭子

多态性: 用一个对象. 多种形态
python 支持的是鸭子类型. 会嘎嘎叫的东西就是鸭子
为了程序能够正常执行. 本来需要传递进来一只鸭子. 但是我只需要传递一个会嘎嘎叫的东西就可以了
def func(yazi):
    yazi.gagajiao()

class Animal:
    def chi(self):
        print("会吃")

class GoldenMonkey(Animal):
    def chi(self):
        print("用手拿着吃, 五花八门")

class Tiger(Animal):
    def chi(self):
        print("老虎吃肉")

class Elephant(Animal):
    def chi(self):
        print("大象吃香蕉")

class QiE(Animal):
    def chi(self):
        print("企鹅吃人民币")

# 以下代码是饲养员
# 优点: 超强的可扩展行. 面向对象的核心就是多态
def wei_animal(ani):  # 传进来的东西要会吃的就行
    ani.chi()

# 动物园
t = Tiger()
m = GoldenMonkey()
e = Elephant()

wei_animal(t)
wei_animal(m)
wei_animal(e)

a = 188
def cul(n):  # python中万事万物都是对象, object(对象)
    print(n)

cul(a)
cul('哈哈')