封装，继承，多态

一：封装

面向对象的三大特性：封装、继承、多态。   面试必问

作用：指的是隐藏对象中一些不希望被外部所访问到的属性或者方法

1.1隐藏属性（私有权限），只允许在类的内部使用，无法通过对象访问

如何把属性名或者方法名变成私有的？  在前面加上俩个下划线_ _就可以了

class Person:
    name = 'xiaolan' #类属性
    __age = 24        #隐藏属性
    def introduce(self)  #实例方法
        print(f{Person.name}的年龄是{Person.__age})   #在实例方法中访问类属性和隐藏属性
pe = Person()  
print(pe.name)  #打印 xiaolan
print(pe.__age)  #报错 属性错误
#那如何访问隐藏属性呢
#第一种  不推荐使用 了解就行
#print(pe._Person__age)  #可以访问隐藏属性打印24
#修改隐藏属性
#pe._Person__age=18
#print(pe._Person__age)  #打印18

#第二种 在类的内部访问  推荐使用  def
pe.introduce()
   
 

1.2私有属性、方法

区别：

_xxx: 单下划线开头，声明私有属性/方法，如果定义在类中，外部可以使用，子类也可以继承，但是在另一个py文件中通过from import * 导入时，无法导入

__xxx：双下划线开头，隐藏属性，如果定义在类中，无法在外部访问，子类不会继承，访问只可以间接通过定义def ,另一个py文件中通过from import * 导入时，也无法导入

1.2.1 隐藏方法 

class Man:
    def __play(self):  #隐藏方法
        print("学习py")
    def eat(self):  #普通的吃饭实例方法
        print("吃辣椒炒肉盖饭")
        self.__play() 
ma = Man()
ma.eat() #可以打印

1.2.2私有属性

class Person:
    name ='xiaohong'
    __age = 18   #隐藏属性 （双下划线）
    _sex = "女"   #私有属性（单下划线）
#实例化对象  创建的对象名 pe
pe = Person()
print(pe._sex) #女 可以通过 对象名._属性名直接打印
print(pe.__age) #报错用  def xx

1.2.4私有方法

class Girl：
    def _buy(self):  #私有方法
        print("买化妆品")
gl = Girl()
gl._buy() #可以打印

 

二：继承

继承分为单继承、多继承

语法：

class  类名 （父类名）：

  代码块

2.1 单继承

子类可以以及成父类的属性和方法，就算子类自己没有，也可以使用父类的。

2.2 继承的传递（多重继承）

子类拥有父类的父类的属性和方法

class Father: #父类
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
class son(Father):
    pass  #占位符
class Grandson(son):
    pass
gd = Grandson()
gd.eat()
gd.sleep()

2.3方法的重写

含义：如果父类继承的方法不满足子类的需求，可以在子类中重写父类的方法，这个过程称为方法的覆盖，也叫作方法的重写

class Person:
    def money(self):
        print("一百万需要被继承")
class Son(Person):
    #pass
    def money(self):
        print("自己赚 ")
son = Son()
son.money()  #覆盖了父类（重写父类）打印自己赚

2.3.1对父类方法进行扩展三种方式：继承父类的方法，子类也可以增加自己的功能 

1.父类名.方法名(self)

2.super().方法名（）-----推荐使用

super在python里面是一个特殊的类，super（）是使用super类创建出来的对象，可以调用父类的方法

 3.super(子类名,self).方法名

例子1

class Person:
    def money(self):
        print("一百万需要被继承")
class Son(Person):
    def money(self):
        Person.money(self)
        print("自己赚 ")
son = Son()
son.money()  #打印  一百万需要被继承   自己赚 

例子2

class Person:
    def money(self):  #父类的方法
        print("一百万需要被继承")
    def sleep(self):  #父类的睡觉方法
        print("baba在睡觉")
class Son(Person):
    def money(self):
        super().money(self)
        super().sleep(self)
        print("自己赚 ")
son = Son()
son.money()  #打印  一百万需要被继承   自己赚 baba在睡觉

2.4多继承的弊端

1.容易引发冲突

2.代码设计的复杂度增加

 

三：多态

含义：一个对象具有多种形态，在不同的使用环境中以不同的形态展示其功能，称该对象具有多态特性。

前提：1.继承 2.重写

例子

class Animal(object):  #父类动物类
    def shout(self):
        print("动物叫声")
class Cat(Animal):   #子类 猫类继承父类
    def shout(self):
        print("喵喵喵")
class Dog(Animal):   #子类 狗类继承父类
    def shout(self):
        print("汪汪汪")
cat = Cat()
cat.shout() #覆盖了父类（重写父类）
dog = Dog()
dog.shout()  #覆盖了父类（重写父类）

3.1 多态性：一种调用方式，不同的执行结果

class Animal(object):  #父类动物类
    def eat(self):
        print("我会吃饭")
class Pig(Animal):   #子类 
    def eat(self):
        print("猪吃猪饲料")
class Dog(Animal):   #子类 
    def eat(self):
        print("狗吃骨头")
#多态性：定义一个统一的接口，一个接口多种实现
def test(obj):
    obj.eat()
animal = Animal()  #实例化对象   
pig = Pig()
dog = Dog()
test(animal)  #我会吃饭 
test(pig)
test(dog)
#test函数传入不同的对象，执行不同对象的eat方法