Python Day24

一、复习：

类 -（实例化）-> 对象 /实例
a = A()
class A:
   country = 'China'    #静态属性
   def __init__(self,name):  #动态属性 方法
       self.name = name   #对象属性 ： 每个对象拥有各自不同的属性

   def talk(self):      #动态属性
       self.name

alex = A('alex')
alex.name
egon = A('egon')
egon.name
alex = A('alex')

60
alex.girlfriend = '凤姐'
alex.talk('alex')


命名空间
类的命名空间和对象的命名空间是分开，且每个对象有独立的命名空间，公用一个类的命名空间

class A:
    a = 123
    def a(self):
        self.a = '123'

组合
什么有什么 的 关系
一个对象的属性 是另一个对象

二、面向对象3：

1.继承：

~继承是类中提供的一种新语法
~面向对象三大特性：封装 继承 多态
~简易的继承
~继承：什么是什么的关系
      他大舅他二舅都是他舅
      高桌子低板凳都是木头

实例：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()


输出结果

ken 说: 我 10 岁了，我在读 3 年级

父类 animal
class Animal:
    def __init__(self,name):
        self.name = name

    def eat(self):
        print('%s eating %s'%(self.name,self.food))

    def drink(self):
        print('drinking')

    def sleep(self):
        print('sleeping')

#狗
class Dog(Animal):
    def __init__(self,name):
        # Animal.__init__(self,name)    #经典类的调用父类中方法的方式
        super().__init__(name)
        self.food = '狗粮'

    def say(self):
        print('汪汪汪')

#猫
class Cat(Animal):
    def __init__(self,name):
        super().__init__(name)  #新式类
        self.food = '猫粮'

    def say(self):
        print('喵喵喵')

wang = Dog('alex')
ha2 = Dog('二哈')
wang.eat()
ha2.eat()

c = Cat('egon')
c.eat()


输出结果

alex eating 狗粮
二哈 eating 狗粮
egon eating 猫粮

***在继承中
　　子类可以继承父类的所有属性和方法
　　但是 当父类和子类中有同名方法的时候 一定调用子类的
　　如果想使用父类该方法的功能 需要借助super方法
2.super 方法

class A:
  def __init__(self):
   print "enter A"
   print "leave A"

 class B(A):
  def __init__(self):
   print "enter B"
   A.__init__(self)
   print "leave B"

 >>> b = B()
 enter B
 enter A
 leave A
 leave B

使用非绑定的类方法（用类名来引用的方法），并在参数列表中，引入待绑定的对象（self），从而达到调用父类的目的。

　　这样做的缺点是，当一个子类的父类发生变化时（如类B的父类由A变为C时），必须遍历整个类定义，把所有的通过非绑定的方法的类名全部替换过来，例如代码段2：

代码2：

class B(C):    # A --> C
  def __init__(self):
   print "enter B"
   C.__init__(self) # A --> C
   print "leave B"

如果代码简单，这样的改动或许还可以接受。但如果代码量庞大，这样的修改可能是灾难性的

后续总结：

　　1. super()是一个类名而非函数，super(class, self)事实上调用了super类的初始化函数，产生了一个super对象；

        2 super()机制必须要用新式类，否则会报错;

        3 super()或直接父类调用最好只选择一种形式。