类的三大特性

封装性

概念：不能让其他地方随便能访问到你的数据
作用：在一定程度上保证了数据的安全

初级封装：
	在类中定义的属性 只能当前类中使用 如果想在其他地方使用 必须创建实例对象 并通过实例对象.属性名的方式进行访问

	在一定程度上  会导致不合理的赋值
		cp.price = -1000 
高级封装
	把属性隐藏起来 外部也不能访问这个属性 实例对象也访问不到 只能通过这个类提供的 特殊的访问和修改的方法才能对这个属性进行操作。
	步骤：
	1.给属性私有化
		在属性名之前添加两个下划线
		原来的属性: age
		私有化之后: __age
	2.给私有化的属性添加访问和修改的方法
		访问方法：类外部需要获得这个被访问的属性时
		修改方法：类外部需要对这个属性进行修改的时候 提供的方法

	案例：
		class Computer:

	    def __init__(self):
	        self.type = '惠普笔记本'
	        self.__price = 5000
	        self.weight = 500
	
	    # 这是一个访问的方法 当外部要访问这个数据的时候 你需要把这个数据返回出去
	    def getPrice(self):
	        return self.__price

		# 创建修改属性的方法 那么一定要传递一个新的数据过来 才能进行修改
	    def setPrice(self, new_price):
	        if new_price > 0:
	            self.__price = new_price
	        else:
	            print(f'你的赋值是不合理的，现在的值是:{self.__price}')
	
		cp = Computer()
		print(cp.getPrice()#输出被隐藏的Price为5000
		cp.setPrice(1000)#将Price设置为1000
		print(cp.getPrice())#输出被隐藏的Price为1000

继承性

** 单继承**

# 括号里面的类，表示继承的是哪个类
# 继承Person类之后，就拥有person类里面的所有属性和方法
# 当子类和父类拥有同一个方法时 子类会优先继承自己的方法和属性
 1.定义一个父类
class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(f'{self.name}干饭')


2. 定义几个子类去继承父类
	# 括号里面的类，表示继承的是哪个类
	# 继承Person类之后，就拥有person类里面的所有属性和方法
	# 当子类和父类拥有同一个方法时 子类会优先继承自己的方法和属性
class SiChuan(Person):
    # 重写：子类重新定义父类的方法，让同一种方法具有不同行为
    def eat(self):
        # 如果想要得到父类和子类一起使用
        # 方法一，不推荐
	        Person.eat(self)
	        print('四川人爱吃火锅')
	
	    def play(self):
	        print('四川人爱打麻将')
	
	
	class GuangDong(Person):
	    def eat(self):
	        # 方法二，推荐
	        super().eat()
	        print('广东人爱吃肠粉')
	
	    def play(self):
	        print('广东人爱喝茶')


3. 创建对象  --- 对象名 = 类名()
	a= SiChuan('liu', 18, 'falme')
	print(ayan.name)
 	a.eat()
	a.play()

	a1 = GuangDong('阿', 18, 'falme')
	a1.eat()

** 多继承**

# 注意：多继承的属性也是就近原则
# print(实例名.__base__)  # 查看类继承的第一个类
# print(实例名.__bases__)  # 查看类继承的所有类
# print(实例名.mro())  # 查看类继承的继承顺序


多继承:就近继承
	class Huxue(GuangDong, SiChuan):
  	  pass


	hunxue = Huxue('混血', 1, 'female')
	 print(hunxue.name)
	hunxue.eat()

	 print(Huxue.__base__)  # 查看类继承的第一个类
	 print(Huxue.__bases__)  # 查看类继承的所有类
	print(Huxue.mro())  # 查看类继承的继承顺序


 案例
	class Base:
	    def eat(self):
	        print('base')


	class A(Base):
	    def eat(self):
	        super().eat()  # 重写先执行父类的eat，再执行下面那句语句
	        print('A')


	class B(Base):
	    def eat(self):
	        print('B')


	class C(A, B):
	    def eat(self):
	        super().eat()  # 重写先执行父类的eat，再执行下面那句语句
	        print('c')


	c = C()
	c.eat()

多态性

'''
class 类名:
    def 方法名(self, 形参):
        形参.方法名()  
'''
'''
了解多态：指的是一个类事物有多种形态（依赖于继承)
定义：多态是一种使用对象的方法，子类重写的方法，调用不同子类对象的相同父类方法，
可以产生不同的执行结果
好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，已适应需求的不断变化
需求：警务人员和警犬一起工作，那么警犬分为两种:追击敌人，追击毒品，携带不同的警犬，执行
不同的工作
'''


1.定义类，提供公共方法
	class Dog:
	    def work(self):
	        print("指哪打哪")


2.定义子类，子类重写父类方法
	class ArmyDog(Dog):
	    def work(self):
	        print('追击敌人....')


	class DrugDog(Dog):
	    def work(self):
	        print('追查毒品')


 定义人类
	class Person(object):
	    def work_with_dog(self, dog):
	        dog.work()  # ad.work()

    # def work_with_dog(self, dog):
    #   dog()  # ad.work()


创建对象  调用不同的功能，传入不同的对象，观察执行的结果
ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(dd)