初识面向对象

一.类与对象

  1.类    

class Car:
    pass

c = Car              # 创建对象     类名()
c.color = "红色"               # 对象.属性        当属性不存在的时候,添加一个属性
c.paizhao = "冀D88888"
c.pailiang = "4.8T"

print(c.color)
print(c.pailiang)
print(c.paizhao)

c.color = "黑色"   # 当属性存在的时候就是修改
print(c.color)

　2.升级版  类

　　__init__ 方法是一个特殊的方法,初始化方法(构造方法)

　　在创建对象的时候会自动的调用__init__()

　　self 就是你创建出来的那个对象 ,当前类的对象

　　在类中写的函数(self)叫    方法

class Car: 
    def __init__(self, color, paizhao, pailiang):
        self.color = color
        self.paizhao = paizhao
        self.pailiang = pailiang
    
    # self 就是当前类的对象
    def pao(self):          # self是自动传递的
        print("跑起来")
    
    def jump(self):
        print(f"{self.color}跳起来")


c = Car("红色", "冀D88888", "4.8T")  # 创建对象的时候会自动调用__init__()
print(c.color)

c1 = Car("黑色", "冀D66666", "2.0T")

print(c1.color)

c.jump()
c1.jump()

二.面向对象和面向过程的对比

　1.对比

　　脚本,此时的代码是最简单的.不需要构思整个程序的概况

　　函数式编程,比脚本麻烦点,对功能有了概况. 函数侧重的是功能

　　面向对象编程,是对整个系统进行分析,分析除需要哪些对象,然后给对象进行归类. 面向对象侧重是的归类

　2.总结

　　面向过程:程序相对比较小,不需要大规模的设计时候用

　　面向对象:程序非常大,项目管理,维护成本很高.此时更适合用面向对象,可维护性好

三.面向对象的三大特征

　　1.封装性     可以封装不相关的东西

　　　1.对属性的封装 (在创建对象的时候进行封装)

　　　2.对功能(或方法)的封装

　　　3.模块   包

class Student:
    def __init__(self,num,name,cls):   # 对属性的封装
        self.num = num
        self.name = name
        self.cls = cls

stu = Student("10010","小明","三年二班")


def kill(s):
    print(f"kill {s.name}")

kill(stu)

　　2.继承 

　　　定义 : 子类自动拥有父类中除了私有内容的其他所有内容

　　　目的 : 对父类进行扩展

class Foo:
    def money(self):
        print("give me money")

class Bar(Foo):
    pass

br = Bar()
br.money()    # 此时调用的时父类中的方法

　　 类中方法的查询顺序: 先找自己,然后再找父类

class Animal:
    def dong(self):
        print("驾驾驾")


class Cat(Animal):  # 子类其实是对父类的扩展
    def dong(self): # 子类中写了和父类中一样的功能,这个叫覆盖.重写
        print("小碎步走起")

    def budong(self):
        pass


# a = Animal()
# a.budong()    # 报错  因为父类不能使用子类中的方法

c = Cat()
c.dong()  # 类中功能的查询顺序 : 先找自己,然后再找父类

　　　多继承 : python支持多继承,遵循MRO

　　3.多态性         (注意等效替换)

　　　 定义 : 同一个对象,多种形态. (一个东西,多种叫法)

　　　优点 : 超强的可扩展性.面向对象的核心

　　推断 : python支持的是鸭子类型,会嘎嘎叫的东西就是鸭子.为了程序能够正常执行,本来需要传递进来的是一只鸭子,但是只需要传递一个　                      会嘎嘎叫的东西就行

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

class Cat(Animal):
    pass

class Dog(Animal):
    pass

class Pig(Animal):
    pass

class Person:
    def wei(self,who):
        who.chi()                  # 鸭子模型,只要包含chi的方法的  都能传入


c = Cat()
d = Dog()
p = Pig()

per = Person()

per.wei(c)
per.wei(d)
per.wei(p)