python——第十六天

面向对象——继承

 

class RichMan(object):

 

    def __init__(self):

        self.money = 1000000000

        self.company = "阿里巴巴"

        self.__secretary = "小蜜"

 

    def speak(self):

        print(f"我对钱不感兴趣，我最后悔的事，就是创建了{self.company}")

 

    def __self_info(self):

        print("我有些私密的事，不想让别人"）

 

class Son(RichMan):

 

    # pass

 

    # def __init__(self, name, age):

    #     self.name = name

    #     self.age = age

 

    def tell(self):

        print("我是一个富二代")

 

    def speak(self):

        print("各位叔叔伯伯，请多多关照")

 

 

if __name__ == '__main__':

    # s = Son("张三", 16)

    # print(s.name)

    # print(s.age)

    # print(s.money)

    # print(s.company)

    # s.speak()

    # s.__self_info()

 

    s = Son()

    s.speak()

面向对象的特征——封装

class User(object):

    def __init__(self, name, age, password, nickname):
        # 将属性私有化
        self.__name = name
        self.age = age
        self.password = password
        self.nickname = nickname

    def login(self, name, password):
        if name == self.__name and password == self.password:
            print("登录成功")
            self.__show_info()
        else:
            print("登录失败")
            self.__show_info()

    def __show_info(self):
        # 该方法是私有化方法，所以只能在该类内部，外界访问访问
        print(f"我的名字叫做{self.__name}\n，我的年龄是{self.age}")

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    # 使用property全局函数，二次封装name属性！！！
    name = property(get_name, set_name)

if __name__ == '__main__':
    u1 = User("张三", 16, "123456", "法外狂徒")
    # print(dir(u1))
    # print(u1.__name)
    # u1.__name = "liujianhong"
    # u1.login("liujianhong", "123456")
    # print(u1.__name)
    # print(u1.get_name())
    # u1.set_name("liujianhong")
    # print(u1.get_name())
    # u1.login("liujianhongafdas", "123456")
    # u1.__show_info()

    print(u1.name)
    u1.name = "李四"
    print(u1.name)
    print(u1.get_name())
面向对象——封装的其他写法

class User(object):

    def __init__(self, name, age, password, nickname):
        # 将属性私有化
        self.__name = name
        self.age = age
        self.password = password
        self.nickname = nickname

    def login(self, name, password):
        if name == self.__name and password == self.password:
            print("登录成功")
            self.__show_info()
        else:
            print("登录失败")
            self.__show_info()

    def __show_info(self):
        # 该方法是私有化方法，所以只能在该类内部，外界访问访问
        print(f"我的名字叫做{self.__name}\n，我的年龄是{self.age}")

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

if __name__ == '__main__':
    u1 = User("张三", 16, "123456", "法外狂徒")
    # print(dir(u1))
    # print(u1.__name)
    # u1.__name = "liujianhong"
    # u1.login("liujianhong", "123456")
    # print(u1.__name)
    # print(u1.get_name())
    # u1.set_name("liujianhong")
    # print(u1.get_name())
    # u1.login("liujianhongafdas", "123456")
    # u1.__show_info()

    print(u1.name)
    u1.name = "李四"
    print(u1.name)
 面向对象的特性及相关知识

面向对象的三大特征：

 |--封装

 |--继承

 |--多态

封装：

 在面向对象中，封装往往有两层含义：

  1、类会将类成员封装在类内部

  2、类的属性，私有化，不让外界访问，如果外界需要访问，则提供对于的公开的方法或方式

python如何私有化属性或者方法：

 1、正常命名的属性或者方法

  name 

  age

  speak（）

 2、双下划线的属性或者方法（魔法属性或者方法 double line methon/attribute）

  _doc_

  _int_()

  _eq_

  _init_()

 3、前面加一个下划线的属性或者方法

  _name

  _age

  _nickname

  这样定义的无法使用 from xxx import* 这种导入方式导入到其他模块中

 4、封装

  __属性名称或者方法名称

class User(object):

    def __init__(self,name,age,password,nickname) :

        #将属性私有化#

        self.__name=name

        self.age=age

        self.password=password

        self.nickname=nickname

    def login(self,name,password):

        if name==self.__name and password==self.password:

            print("登录成功") 

            self.__show_info()

        else:

            print("登录失败") 

            self.__show_info()

    def __show_info(self):

        #该方法是私有化方法，所以只能在该类内部，外界无法访问

        print(f"我的名字叫做{self.__name}\n,我的年龄是{self.age}")

    def get_name(self):

        return self.__name

    def set_name(self,name):

        self.__name=name

if __name__=='__main__':

    u1=User("zhangsan",16,"123456","法外")

    print(u1.get_name())

    u1.set_name("hjt")

    print(u1.get_name())

    u1.login("hjt","123456")

继承：

 在面向对象中，存在了类继承类的特征，这个就是我们说的——继承

 父类：被继承的类，被称为父类，也被称为超类（super class）

 子类：继承父类的类，被称为子类

方法重写、方法覆盖（override、overwrite）

 在继承的关系中，如果子类继承父类中某一个或者某些方法时，如果想要修改原有方法

 这需要重写该方法

函数重载（overload）：