面向对象笔记

# 对象的封装    类的概念 ：一个关键字
# 有时候叫一个函数叫函数，有时候叫方法。类里的一个函数叫方法
# 所有的类都有一个实例化的过程
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 这就是私有属性，私有属性在类的外部是不可以访问的
    # __name = ""

    # 构造函数
    def __init__(self, eye, nose, mouth, hair, face):  # 在类里的函数都默认第一个参数是self，传的它自己
        self.eye = eye   # 把用户传的值赋值给类的属性
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print("构造函数运行了")

    # 在这就叫类的方法，有什么样的技能
    def dance(self):
        print("美女在跳舞")

    # 获取美女里面一个具体的方法
    def get_beautiful_girl(self):
        print("这个美女的样貌是:")
        print(self.nose)
        print(self.eye)
        print(self.mouth)
        print(self.hair)
        print(self.face)

# 实例化就是获取具体对象的一个过程   new一个
# girl一个变量  类名
# 实例化的过程自动调用构造函数，一一对应构造函数self后面五个参数
girl = BeautifulGirl("大大的眼睛","小巧的鼻子" ,"薄薄的嘴唇","黑黑的头发","清秀的脸庞")

girl.dance()
girl.get_beautiful_girl()

girl2 = BeautifulGirl("小小的眼睛","鼻子","嘴","头发", "脸庞")
girl2.get_beautiful_girl()

# 类中的方法
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 这就是私有属性，私有属性在类的外部是不可以访问的
    __name = "高圆圆"
    address = "河北"

    # 构造函数，构造方法
    def __init__(self, eye, nose, mouth, hair, face):  # 在类里的函数都默认第一个参数是self，传的它自己
        self.eye = eye  # 把用户传的值赋值给类的属性
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print("构造函数运行了")

        # 在这就叫类的方法，有什么样的技能

    def dance(self):
        print("美女在跳舞")

    # 获取美女里面一个具体的方法
    # 私有方法
    def __dd(self):
        print("美女在跳舞")

   # 这叫一般方法
    def get_beautiful_girl(self):
        print("这个美女的样貌是:")

        # girl在
        print(self.__name)
        print(self.nose)
        print(self.eye)
        print(self.mouth)
        print(self.hair)
        print(self.face)

    # 静态方法
    @staticmethod
    def study():
        print("美女在学习")
       # print(self.eye)  静态方法不能访问类属性

    # 类方法
    # 类方法是不可以访问实例变量，它可以访问类变量（类的属性）
    @classmethod
    def girl_friend(cls):
        print(cls.__name)
        print(cls.address)
        # print(cls.eye)

girl = BeautifulGirl("大大的眼睛", "小巧的鼻子", "薄薄的嘴唇", "黑黑的头发", "清秀的脸庞")
print(BeautifulGirl.__dict__)   # 打印了类里包含那些属性和方法
# 这就访问了类中的私有方法
girl._BeautifulGirl__dd()

girl.study()
BeautifulGirl.study()

# 类名，一般方法的名称调用会报错的
BeautifulGirl.dance(girl)

girl.girl_friend()
BeautifulGirl.girl_friend()

# 类的私有属性
class BeautifulGirl():
    # 类的属性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 这就是私有属性，私有属性在类的外部是不可以访问的
    __name = "高圆圆"
    address = "河北"

    # 构造函数，构造方法
    def __init__(self, eye, nose, mouth, hair, face):  # 在类里的函数都默认第一个参数是self，传的它自己
        self.eye = eye  # 把用户传的值赋值给类的属性
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print("构造函数运行了")

        # 在这就叫类的方法，有什么样的技能

    def dance(self):
        print("美女在跳舞")

        # 获取美女里面一个具体的方法

   # 私有方法
    def __dd(self):
        print("美女在跳舞")

   # 这叫一般方法
    def get_beautiful_girl(self):
        print("这个美女的样貌是:")

        # girl在
        print(self.__name)
        print(self.nose)
        print(self.eye)
        print(self.mouth)
        print(self.hair)
        print(self.face)

girl = BeautifulGirl("大大的眼睛", "小巧的鼻子", "薄薄的嘴唇", "黑黑的头发", "清秀的脸庞")
# print(girl.mouth)
# print(girl.address)
# # print(girl.__name)
#
# # 类的私有属性可以访问吗
# print(BeautifulGirl.__dict__)   # 打印了类里包含那些属性和方法
# print(girl._BeautifulGirl__name)  # 访问类的私有属性

girl.get_beautiful_girl()
# 这就访问了类中的私有方法
girl.get_beautiful__dd()

类的继承

# 类的继承
# 父类和子类

class Father(object):
    age = 38

    def __init__(self, name):
        self.name = name
        print("父类的构造函数运行了")


    def father_money(self):
        print("爸爸很有钱")

    def __father_knowleger(self):
        print("爸爸的知识体系")

    @staticmethod    # 静态方法
    def study():
        print("爸爸在学习")

    @classmethod     # 类方法
    def father_friend(cls):
        print("爸爸有很多朋友")

    def face(self):
        print("爸爸非常帅")

# 意味着son这个类继承了father这个类
class Son(Father):
    #pass          #在继承父类的时候自己没有构造函数，就调用了父类的函数
    def __init__(self):
        print("子类的构造函数运行了")

# son = Son("小王")
son = Son()

# 在继承中，一般的方法是可以被继承的
son.father_money()
# 私有方法不可以被继承  如果被继承就下划线类名 _Father__father_knowleger
son._Father__father_knowleger()

class Mother():
    def face(self):
        print("妈妈长的很漂亮")

# 这就是类多继承
class Son2(Father, Mother):
    def __init__(self):
        print("2儿子的构造函数运行了")

son2 = Son2()
son2.father_money()
# 当多继承的时候，多个父类拥有同一个名称的变量或方法时
# 哪个父类写在继承列表的前边，子类就继承谁的
son2.face()

类的多态

多个类继承同一个类，都重写了父类得方法，呈现出了不同的形态

# 类的多态   指的就是多种形态


class Animal():
    def run(self):
        print("动物开始跑")

# 子类在继承父类的过程中，重写了父类中的方法
class Dog(Animal):
    def run(self):
        print("狗狗跑")

class Cat(Animal):
    def run(self):
        print("猫猫跑")

class Person(Animal):
    def run(self):
        print("人类跑")

dog = Dog()
dog.run()

cat = Cat()
cat.run()

person = Person()
person.run()


# 类的多态性
class A(Animal):
    pass
a = A()

def run(obj):   #里面传一个对象，调用run方法
    obj.run()

run(dog)
run(cat)
run(person)