python面向对象day02-私有成员和继承

私有成员

1. 概念:
私有成员(属性,方法), 只能在 本类  内部使用

作用:
    1. 起到对成员属性的保护作用,不能在类外修改
    2. 提高类的封装性,将用户不需要用的功能都设置成私有的,简化用户的使用(关心公有的)
        ATM 机
2. 语法:
  只需要在成员(属性,方法)名前面加 两个下划线, 这样的成员就是私有成员

3. 了解 原理
    在类外部使用的时候, 其实python解释器将私有成员名进行修改了: _类名__私有成员名
    如何查看: dir(对象)  列出对象上的属性

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 名前面加 两个下划线 就是私有成员

    def show(self):
        # 展示个人信息
        print("我是{},今年{}岁".format(self.name, self.__age))  # 私有成员能在本类内部访问


# 创建学生 张飞
zhangfei = Student(name="张飞", age=28)
zhangfei.show()
print(zhangfei.name)
# print(zhangfei.__age) # 私有成员不能在本类外部访问
print(dir(zhangfei)) # 查看对象上的所有属性

---

del 方法

1. 概念:
当我们的对象 在内存中被销毁(释放)的时候 自动调用对象上的 __del__ 方法

注意: __方法__ : 这类方法被称为魔术方法, 都是自动调用

作用:
    1. 清理对象占用的第三方资源(打开的数据库连接,打开的文件)
    2. 明确知道对象的销毁时机

2 明确知道对象的销毁时机
	a. 脚本执行结束, 程序占用内存的所有数据都会释放,包括对象
    原因: python高级语言,自带垃圾回收机制
	b. 当对象空间没有被任何的变量所指向(引用), 这个时候对象被当作垃圾进行释放
    两种方式:
        del 对象变量
        或者
        对象变量 = None

定义一个学生类

class Student:
    def __init__(self):
        print("创建对象成功!")

    def __del__(self): # 对象被销毁自动调用
        print("对象被消耗~~")


# 创建对象
stu1 = Student()
stu2 = stu1
del stu1
del stu2  # 如果对象的所有引用被删除,对象就会被当作垃圾销毁释放
print("end.....")  # 默认脚本执行结束对象被销毁
# print(id(None))

继承的使用

1. 概念:
什么是继承: 子类继承父类, 就可以直接使用父类上的成员(属性和方法)
补充俩概念: 子类  父类
继承的作用: 达到代码的重用(覆用)

2. 语法:
class 子类名(父类名):
    # 定义子类自己的属性和方法
    pass

说明:
    1. 子类如果没有明确指明继承的类, 那么默认继承基础类 object, 或者明确指明继承object
    2. 子类和父类 建议为有关系的类

注意:
    1 私有属性不能被继承(私有属性只能在本类内部使用)
    2.子类可以新增自己的属性和方法

"""
定义俩类:
Father
Son
"""
class Father(object):
    def __init__(self, name, age, money):
        # 初始化方法
        self.name = name
        self.age = age
        self.money = money
        # 定义一个私有的属性
        self.__height = 178

    def show(self):
        print(f"{self.name}今年{self.age},有财富:{self.money},身高:{self.__height}")


# 子类 继承 父类, 直接使用父类上的成员
class Son(Father):

    # 展示身高
    def showHeight(self):
        print(self.__height)  # 子类不能使用父类上的私有成员,报错


# 创建一个大头儿子对象
son = Son(name="大头儿子", age=8, money=20)
print(son.name)  # 继承的属性
son.show()  # 继承的方法
print(dir(son))
son.showHeight()

单继承: 一个子类继承一个父类

class 类名(父类名):
    pass

多层继承: 一个子类继承一个父类, 父类又继承其他父类,可以同时使用多个类上的成员

class C(object):
    pass

class B(C):
    pass

class A(B):
    pass

多继承: 一个子类可以继承多个父类, 可以同时使用多个类上的成员

class 子类(父类1,父类2):
    pass

class C(object):
    def showC(self):
        print("C")


class B(C):
    def showB(self):
        print("B")


class A(B):
    def showA(self):
        print("A")


a = A()
a.showA()
a.showB()
a.showC()


# 案例: 骡子同时继承驴和马
class Horse(object):
    def run(self):
        print("跑得快~")


class Lv(object):
    def tuo(self):
        print("拖得绑重~")


# 骡子
class Luozi(Horse, Lv):
    pass


# 创建骡子对象
lz = Luozi()
lz.run()
lz.tuo()

重写

1. 概念
什么是重写: 在子类中定义一个与父类相同名字的成员, 就叫作 重写

常见的重写:
    1. 属性的重写(了解)
    2. 方法的重写(重点关注)

2. 方法的重写
为什么要重写方法:  当父类上的方法不满足子类需求的时候, 但是子类又不得不使用该方法,
这个时候只能在子类上重写父类方法.

例如: 子类的初始属性多于父类

特点: 如果子类重写了父类方法, 再通过子类对象调用被重写的方法的时候, 只调用
子类上的方法.

3. 优化重写方法
我们可以在子类中通过以下语法 调用父类上的方法:
    super().父类方法名([实参])
    super(子类名,self).父类方法名([实参])

# 定义俩类:
# 商品类: 属性: 名字,价格
# 手机类: 属性: 名字,价格,品牌,尺寸,颜色
class Goods(object):
    def __init__(self, name, price):
        self.name = name
        self.price = price
        print("对象被创建")

    def ma(self):
        print("安全码~~~~~")

    # 父类上有很多方法


class Phone(Goods):
    # 父类上有__init__, 子类又定义了 __init__ , 重写了初始化方法
    def __init__(self, name, price, brand, size, color):
        # self.name = name
        # self.price = price
        # 调用父类上的方法
        super(Phone, self).__init__(name, price)
        self.brand = brand
        self.size = size
        self.color = color
        print("子类对象被创建")


# 创建子类对象
iphone11 = Phone("iphone11", 5000, "苹果", 5, "土豪金")
print(iphone11.name, iphone11.price, iphone11.brand, iphone11.size)
print(iphone11)

类属性和实例属性

1. 实例属性
实例(对象) 属性: 对象上的属性

如何添加实例属性:
    1. 动态添加: 对象变量.属性名 = 值
    2. 属性绑定: self.属性名 = 值

2. 类属性
万物皆对象
类 也是一个对象: 通过 dir(类) 只要查看到属性说明 类也是一个对象

类属性: 可以在类上添加属性

添加类属性的语法:
    (1) 动态添加: 类名.属性名 = 值
    (2) 类中绑定
        class 类名(object):
            类属性名1 = 值
            类属性名2 = 值
访问的语法:
    类名.属性名

类属性的的作用:
    将 所有对象共享的属性 设置为类属性, 目的为了节约内存空间

    类属性的特殊(了解): 可以通过对象访问类属性

class Student(object):
    # 绑定类属性
    class_name = "软件测试精英班"


# print(dir(Student)) # 说明类也是对象

# 例如: Student类添加一个属性 班级名    对象.属性名 = 值
# 动态添加
# Student.class_name = "软件测试精英班"

# 在类中绑定类属性
print(Student.class_name)

# 创建对象
stu = Student()
print(stu.class_name)  # 对象访问类属性

类方法和静态方法

1. 类方法和静态方法
作用: 不用创建对象就能通过类名调用, 简单方便

2. 语法
类方法:

class 类名(object):
    # 实例方法
    def 方法名(self,[形参]):
        pass

	# 类方法
    @classmethod  # 装饰器
    def 方法名(cls,[形参]): # cls == class, python自动将调用的那个类传递给第一个参数 cls
        pass

静态方法:

class 类名(object):
    # 实例方法
    def 方法名(self,[形参]):
        pass

    # 静态方法
    @staticmethod  # 装饰器
    def 方法名([形参]):
        pass

案例:

class Student(object):
    # 类属性
    class_name = "软件测试精英班"

    # 初始化方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 展示个人信息: 实例方法
    def show(self):
        print(f"{self.name},今年{self.age}, 在{Student.class_name}班")

    # 展示班级 类方法
    @classmethod
    def showClass(cls):
        # cls 类自己: 类名.属性名
        # print(id(cls))
        print(cls.class_name)

    # 展示时间 静态方法
    @staticmethod
    def showTime():
        import datetime
        print(datetime.datetime.now())


# 创建对象
# stu = Student("张飞",28)
# stu.show()
# print(id(Student))

# 调用类方法
Student.showClass()

# 调用静态方法
Student.showTime()