# 測試類
from cat import Cat
from mouse import Mouse
from person import Person
'''
多態(tài): 一種事物的多種狀態(tài)
需求:人可以喂任何一種動物
'''
#創(chuàng)建貓和老鼠的對象
tom = Cat("tom")
jerry = Mouse("jerry")
#調用各自的方法
tom.eat()
jerry.eat()
#定義了一個有name屬性和eat方法的Animal類,讓所有的動物類都繼承自Animal.
#定義一個人類,可以喂貓和老鼠吃東西
per = Person()
#per.feedCat(tom)
#per.feedMouse(jerry)
#思考:人要喂100種動物,難道要寫100個feed方法嗎?
#前提:tom和jerry都繼承自動物
per.feedAnimal(tom)
per.feedAnimal(jerry)

#animal.py文件中的動物類
class Animal(object):
  def __init__(self, name):
    self.name = name
  def eat(self):
    print(self.name + "吃")

#cat.py文件中的貓類
class Cat(Animal):
  def __init__(self, name):
    #self.name = name
    super(Cat,self).__init__(name)

#mouse.py中的老鼠類
class Mouse(Animal):
  def __init__(self, name):
    #self.name = name
    super(Mouse,self).__init__(name)

#person.py中的人類
class Person(object):
  def feedAnimal(self, ani):
    print("給你食物")
    ani.eat()

class Person(object):
  #1.定義位置
  #類屬性:直接定義在類中的屬性
  name = "person"
  def __init__(self, name):
    #對象屬性:定義在構造方法中的屬性
    self.name = name
#2.訪問方式
print(Person.name)
per = Person("tom")
#對象屬性的優(yōu)先級高于類屬性
print(per.name)
#動態(tài)的給對象添加對象屬性
per.age = 18
#只針對當前對象生效,對于類創(chuàng)建的其他對象沒有作用
print(Person.name)
per2 = Person("lilei")
#print(per2.age) #沒有age屬性
#刪除對象中的name屬性,再調用會使用到同名的類屬性
del per.name
print(per.name)
#注意事項:不要將對象屬性與類屬性重名,因為對象屬性會屏蔽掉類屬性,但是當刪除對象屬性之后,再使用就能使用到類屬性了.

from types import MethodType
#定義一個空類
'''
class Person():
  pass
'''
class Person(object):
  __slots__ = ("name","age","speak","hobby")
  pass
# 動態(tài)添加屬性[體現了動態(tài)語言的特點:靈活性]
per = Person()
per.name = "tom"
print(per.name)
#動態(tài)添加方法
def say(self):
  print("my name is "+ self.name)
per.speak = say
per.speak(per)
#這樣實現不好,所以引入MethodType
def hobby(self):
  print("my hobby is running")
per.hobby = MethodType(hobby,per)
per.hobby()

#動態(tài)添加方法
def say(self,name):
  self.name = name
  print("my name is "+ self.name)
Person.speak = say
per2 = Person()
per2.speak('hh')

class Person(object):
  __slots__=("name","age")
#[不想無限制的任意添加屬性]
#比如,只允許給對象添加name, age屬性
#解決:定義類的時候,定義一個特殊的屬性(__slots__),可以限制動態(tài)添加的屬性范圍
per = Person()
per.height = 170
print(per.height)

__slots__ = (屬性名1,屬性名2,...)

p = Person()
p.age = -1

class Person(object):
  def __init__(self, name, age):
    # 屬性直接對外暴露
    # self.age = age
    # 限制訪問
    self.__age = age
    self.__name = name
    # self.__name = name
  def getAge(self):
    return self.__age
  def setAge(self, age):
    if age < 0:
      age = 0
    self.__age = age
  # 通過@property和@age.setter改變原來的get/set方法
  # 方法名為受限制的變量去掉雙下劃線
  # 相當于get方法
  @property
  def age(self):
    return self.__age
  # 相當于set的方法
  @age.setter # 去掉下劃線.setter
  def age(self, age):
    if age < 0:
      age = 0
    self.__age = age
  @property
  def name(self):
    return self.__name
  @name.setter
  def name(self, name):
    self.__name = name
per = Person("lili", 18)
# 屬性直接對外暴露
# 不安全,沒有數據的過濾
# per.age = -10
# print(per.age)
# 使用限制訪問,需要自己寫set和get的方法才能訪問
# 劣勢:麻煩,代碼不直觀
# 思考問題:如果我就想使用對象"."的方式訪問對象的私有屬性,怎么辦?
# per.setAge(15)
# print(per.getAge())
# property:可以讓你對受限制訪問的屬性使用"."語法
per.age = 80 # 相當于調用setAge
print(per.age) # 相當于調用getAge
print(per.name)

@property
  def 屬性名(self):
    return self.__屬性名

@屬性名.setter
  def 屬性名(self, 值):
    #業(yè)務邏輯處理
    self.屬性名 = 值

# 舉例
# 數字和字符串都能相加
#print(1 + 2)
#print("1" + "2")
# 不同的類型用加法會有不同的解釋
class Person(object):
  def __init__(self, num):
    self.num = num
  # 運算符重載
  def __add__(self, other):
    return Person(self.num + other.num)
  # 方法重寫
  def __str__(self):
    return "num = " + str(self.num)
# 如果兩個對象相加會怎樣?
# 對象相加,編譯器解釋不了,所以就要用到運算符重載
per1 = Person(1)
per2 = Person(2)
print(per1 + per2)
# 結果為地址:per1+per2 === per1.__add__(per2),如果想得到num的和則重寫str方法
# 上述打印就等價于:print(per1.__add__(per2)),只不過add方法會自動調用
print(per1)
print(per2)