目录

1.封装的方法
2.封装的实现原理
3.property装饰器
4.多态
5.多态abc模块
6.多态abc理解
7.鸭子类型

1.封装的方法

class Camera:
    def __jj(self):
        print('聚焦')

    def __tgq(self):
        print('调节光圈')

    def __pz(self):
        print('拍照')

    def zx(self):
        self.__jj()
        self.__tgq()
        self.__pz()


c=Camera()
# 把其它方法隐藏了（在方法名前加 __）
# c.zx()
# 在方法名前加__,内部可以正常使用，外部不能使用，相当于隐藏起来了
# c.__jj()  # 报错，找不到这个属性
# c.__tgq()
# c.__pz()


print(Camera.__dict__) # 隐藏起来了，但是内部还是有，只不过变形了
# _类名__方法名
# 外部特别想用(python独有的)
c._Camera__jj()

# 案例二
# 面向对象封装使用之定义一个人类，人有名字，人名不能以sb开头

class Person:
    def __init__(self,name):
        if name.startswith('sb'):
            print('不能以sb开头，name没有放进来')
        else:
            self.__name=name

    def print_name(self):
        print(self.__name)

    def change_name(self,name):
        if name.startswith('sb'):
            print('不能以sb开头，name没有放进来')
        else:
            self.__name = name
# 把name属性隐藏起来，外部访问不到
# 访问不到name属性，如何打印出来？提供一个打印名字的方法
# 改名，定义一个修改名字的方法

# 保证了数据的安全
egon=Person('sb_egon')

egon.change_name('ddd')

egon.print_name()

# 强行使用(不推荐)
egon._Person__name='sb_egon'
egon.print_name()

# 面向对象封装：在类内部（属性/方法） 在前面加__,表示隐藏，只能在内部用，外部使用不到

# 模块中也可以隐藏属性，在属性前加_，只是在模块内部使用，不期望外部的使用
# from s1 import *  导入不进来
from s1 import __name
# print(_name)
print(__name)

2.封装的实现原理

class Person:

    def __init__(self,name,sex,age,idCard):
        self.name = name
        self.sex = sex
        self.__age = age
        self.__idCard = idCard

    def get_idCard(self):
        return self.__idCard

    def __test(self):
        pass

    print("aaaaaaaaaa")


p = Person("比尔盖茨","男",20,"322323232332332")

# print(p.__idCard)
p.__idCard = "XXXXXX"
print(p.__idCard)

print(p.get_idCard())

print(p.__dict__)
print(Person.__dict__)


p.__xxxxxxxxxxxx = 1

print(p.__dict__)


# 通过__dict__ 可以发现
# 1.私有的属性和方法名称 前自动加上了_类名 python就是通过这样的转换方式来实现封装
# 2.只有在类的内部的双下划线才会被自动转换,并且这个转换过程只执行一次,在类定义完成后 后续添加的双下划线开头的名称是不会自动转换的
# 3.父类中私有的方法 子类中无法使用


#在父类中定义的私有方法 能不能被子类所覆盖?

class A:
    def __f1(self):
        print("A __f1")

class B(A):
    def __f2(self):
        # self.__f1()
        super().__f1()
        print("B __f2")

    def test(self):
        self.__f2()

b = B()
b.test()




# 子类无法覆盖父类的私有方法

class  A:
    def f(self):
        self.__f1()   #_A__f1

    def __f1(self):
        print("A  __f1")

class B(A):
    def __f1(self):  # _B__f1
        print("B __f1")

    def f2(self):
        self.f()

b = B()
b.f2()
# 之所以无法覆盖 是因为 子类和父类中的私有方法 名称必然不相同 所以无法覆盖   子类的方法一定子类独有的 因为名称不同




class A:
    __age = 10

# 绕过封装的限制直接访问  这是毫无意义的
print(A._A__age)

3.property装饰器

'''
当一些属性的值 不是固定的而是通过计算得来的时候  我们必须为这个属性增加方法才能完成计算
但是一旦使用方法后 该属性的访问就变成了方法的调用  很明显与其他的属性访问方式不同,这样给使用者造成迷惑
所以需要将这个方法伪装成普通属性 这就用到了Property

property可以将方法伪装成属性 利用这个特点 我们也可以将其使用到封装中
之前没有这个装饰器我们需要为私有的属性 提供两个方法  但是这样一来方位私有属性时的方式就发生了变化
这时候就可以使用property来进行伪装 使得访问私有属性与访问普通属性的方式一致
另外 property还提供了 setter(用于修改属性的值)  和 deleter(删除属性的值)

重点：把方法包装成数据属性
'''

# BIM案例:
class Person:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height
        # self.bmi = weight/(height*height)
    
    @property # 把方法包装成数据属性
    def bmi(self):
        return self.weight / (self.height * self.height)

p = Person("尔晴",50,1.5)

# 使用property装饰器 可以将一个方法伪装成一个属性
print(p.bmi)
p.height += 0.2
print(p.bmi)


class Student:
    def __init__(self,name,sex,idCard):
        self.name = name
        self.sex = sex
        self.__idCard = idCard

    def get_idCard(self):
        return self.__idCard

    def set_idCard(self,new_id):
        self.__idCard = new_id

    @property # 需要掌握
    def idCard(self):
        return self.__idCard


    @idCard.setter #了解的
    def idCard(self,new_id):
        self.__idCard = new_id

    @idCard.deleter # 了解的
    def idCard(self):
        print("身份证属性被删除了.....")
        del self.__idCard


stu = Student("尔康","男","323254554554")

# print(stu.get_idCard())

# stu.set_idCard("xxxx")

print(stu.get_idCard()) # 使用装饰器前
print(stu.name) # 普通属性的访问

print(stu.idCard) # 使用装饰器后

stu.idCard = "aaaaaaa" # 使用装饰器后的修改操作

print(stu.idCard)

del stu.idCard

print(stu.__dict__)
print(Student.__dict__)

4 .多态

'''
学习知识点的四个重要步骤
    What When Why HOW

多态
    什么是多态
        多种状态 形态
        生活中具备多种形态的事物  水(水蒸气,冰,液态水)  奥特曼(红色 力量,蓝色 速度)  数码宝贝(究极形态)
        一种事物 具备多种形态或状态 就称之为多态
        官方解释:不同对象 可以相应同一方法,并作出不同的行为,产生不同结果

如何实现多态?
   让几个不同类拥有相同父类,这样一来他们就具备了相同的方法,每个子类要覆盖父类的方法,从而每个类的对象行为都不同

    重点：多态的前提是：是同一类事物，最好的办法就是继承同一个基类，多态必须属性方法一致。
'''

# 案例 一


class Animal:
    def eat(self):
        print("动物在吃东西...")
    def sleep(self):
        print("动物在睡觉...")
    def drink(self):
        print("动物需要水.....")

# 以下三类属于同一类
class Person(Animal):
    def eat(self):
        print("人吃粮食...")

class Pig(Animal):
    def eat(self):
        print("猪吃饲料...")

class Dog(Animal):
    def eat(self):
        print("狗吃骨头...")


person = Person()
pig = Pig()
dog = Dog()

#  person,pig,dog对象，属于同一类
# 表现出来的不一样
# 同一类事物都在调用eat方法，但是执行的效果是不一样的：多态

person.eat()
pig.eat()
dog.eat()

# 案例 二

# 当使用了多态之后 对象的使用者不需要关系这个对象具体的实现,只需要知道该对象属于哪个基类,就能直接使用它
# 如此扩展性变高了


class Phone:
    def call(self):
        print("手机就能打电话..")

    def send_msg(self):
        print("手机能发短信..")


class WindowsPhone(Phone):
    def call(self):
        print("拨号打电话..")

    def send_msg(self):
        print("输入号码发短信..")

class IPhone(Phone):
    def call(self):
        print("拨号打电话..")


    def send_msg(self):
        print("输入号码发短信..")




# 可以定义一个方法接受一个手机为参数 无论是是类型的手机 都可以被使用

def CALL(phone):
    phone.call()

wp = WindowsPhone()
ipx = IPhone()

CALL(wp)
CALL(ipx)


# 系统内置的方法有很多都体现了多态


print(len("abc"))
print(len([1,2,3,4,]))
print(len({"name":"123","sex":"man"}))

print("abc".__len__())
print([1,2,3,4,].__len__())
print({"name":"123","sex":"man"}.__len__())

print(len({1,23,4,5}))

5.多态 abc模块

'''
多态是多个类的对象拥有相同的方法,但是我们没有从严格要求说必须提供这些方法,子类完全可以不提供这些方法

现在要做的就是 严格要求 子类必须实现父类声明的方法
'''

import abc
# abstract class 是抽象类的缩写   抽象的意思是 不清晰 不具体 看不懂

#使用ABC模块来限制子类 的步骤
#1.为类中指定元类为abc.ABCMeta
#2.在相应的方法上加上abc.abstractmethod装饰器

class Animal(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def drink(self):
        pass


class Cat(Animal):
    def eat(self):
        print("猫爱吃鱼肉...")

    def drink(self):
        print("用舌头舔..")

class Dog(Animal):
    def eat(self):
        print("狗爱吃骨头...")
    def drink(self):
        print("用舌头舔..")

class Pig(Animal):
    def eat(self):
        print("猪 爱吃草...")

    def drink(self):
        print("用嘴吸的..")

p = Pig()
# p.eat()

c = Cat()
# c.eat()

# 多态的好处 完全不需要考虑得到的对象时声明类型 只要知道了其基类中的内容就能使用
def feeding(animal):
    animal.eat()
    animal.drink()

feeding(c)
feeding(p)
# 多态中的基类 相当于(协议 标准 规范) 要求子类必须满足这些标准

6.多态abc理解

'''
为了保证多态，可以使用abc模块，来实现，如果子类不重写父类的方法，就会报错
不是我们惯用的做法（第一：它有其他方法实现  第二：python中不推荐强制使用父类来约束，推荐鸭子类型）
'''

import abc
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def click(self):
        print('文件被点击')

# 子类如果继承了File，就必须重写click，如果不重写，就报错
class TxtFile(File):
    def click(self):
        print('文本文件，点击被打开了')


class ExeFile(File):
    def click(self):
        print('可执行文件，点击执行')


t = TxtFile()
e = ExeFile()

# t和e属于同一类，但是调用click，他们表现的样子不一样
t.click()
e.click()

7.鸭子类型

'''
有一个对象，只要看起来像鸭子，走路像鸭子，叫声像鸭子，那就是个鸭子
只要一个对象，具备鸭子的所有属性和方法，我们就认为这个对象就是鸭子类的对象，使用多态
当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子

对应到代码中就是: 只要你的行为一样 那就把你当成同一个类型来看待
如果你足够自觉 你可以不使用abc模块 也不需要基类 自觉地将方法名字都写成一样 同样可以实现多态
这种方式称之为鸭子类型，是从多态中演变过来的

重点：python中推崇使用鸭子类型，不使用父类
'''

# 方案 一
class Duck:

    def bark(self):
        print("鸭子嘎嘎叫...")

    def run(self):
        print("摇摇晃晃走....")

class Chicken:
    def bark(self):
        print("鸡咯咯叫...")

    def run(self):
        print("摇摇晃晃走....")

def test(obj):
    obj.bark()
    obj.run()
duck = Duck()
c = Chicken()

test(duck)
test(c)

# 方案 二
# 唐老鸭类
class TDuck():
    def speak(self):
        print('唐老鸭叫')

    def run(self):
        print('唐老鸭走路')
    def money(self):
        print('唐老鸭赚钱')

# 普通鸭子类
class PDuck():
    def speak(self):
        print('普通鸭子叫')

    def run(self):
        print('普通鸭子走路')


p = PDuck()
# 只要这个对象有下面两个方法，我们就认为p就是鸭子对象
p.speak()
p.run()

t = TDuck()
# t也是鸭子对象
t.run()
t.speak()