Python面向对象编程

一：类的组成:

1：类的名称：类名

2：类的属性：一组数据

3：类的方法：允许进行操作的方法（行为）

 

二:定义类：

#定义类（经典类）
class Car:
    #方法：
    def getCarinfo(self):
        print("车轮个数：%d,颜色%s"%(self.whelelNum,self.color))
    def move(self):
        print("车正在移动")

新式类：Car（object）

三：创建对象：

格式：对象名 = 类名（）

class Car:
    def move(self):
        print("车在奔跑")
    def toot(self):
        print("车在鸣笛")
#创建对象
BMW = Car()
BMW.color = '黑色'
BMW.wheelNum = 4
BMW.move()
BMW.toot()
print(BMW.color)
print(BMW.wheelNum)

私有成员：__name，即：变量名前加两个下划线

四：self，init，del

class Dog(object):
    def __init__(self,name,dog_type):
        self.name = name
        self.type = dog_type
    def sayhi(self):
        print("hello,my name is",self.name)
        print("I am a",self.type)
d = Dog('Tom','二哈')
d.sayhi()

这里还有很多没讲到的内容，我们还需要进一步学习

#析构方法
class Animal():
    def __init__(self):
        print('构造方法被调用---')
    def __del__(self):
        print('析构方法被调用---')
dog = Animal()

 

五：继承

如果子类中定义与父类同名的方法或属性，则会自动覆盖父类中对应的方法或属性

（1）单继承：

#（1）单继承
class Cat:
    name = '猫'
    color = 'white'
    def run(self):
        print(self.name,'在跑')

#定义一个子类:
class Bosi(Cat):
    def setName(self,newName):
        self.name = newName
    def eat(self):
        print(self.name,'在吃')

bs = Bosi()
print('bs的名字为：',bs.name)
print('bs的颜色为：',bs.color)
bs.eat()
bs.setName('波斯')
bs.run()
'''
运行结果：
bs的名字为： 猫
bs的颜色为： white
猫 在吃
波斯 在跑
'''

继承中的init：

class TestA():
    def __init__(self):
        print('TestA init')
class TestB(TestA):
    def __init__(self):
        TestA.__init__(self) #当子类中自己带init时，则不执行父类中的init，除非写这一句进行声明
        print("TestB init")
b = TestB()

import random as r

class Fish:
    def __init__(self):
        self.x = r.randint(0,10)
        self.y = r.randint(0,10)
    def move(self):
        self.x -= 1
        print("我的位置是：",self.x,self.y)

class Goldfish(Fish):
    pass
class Carp(Fish):
    pass
class Salmon(Fish):
    pass

class Shark(Fish):
    def __init__(self):  #重写父类
      #  Fish.__init__(self)  #写法1：调用父类，这里的self是Shark
        super().__init__()   #写法2：更加推荐
        self.hungry = True
    def eat(self):
        if(self.hungry==True):
           print("我要吃饭！！！")
        else:
            print("我吃饱了.")

fish = Fish()
fish.move()

goldfish = Goldfish()
goldfish.move()

shark = Shark()
shark.move()
shark.eat()

 

（2）多继承：

#（2）多继承
class A:
    def printA(self):
        print('--A--')
class B:
    def printB(self):
        print('--B--')
class C(A,B):
    def printC(self):
        print('--C--')

obj_C = C()
obj_C.printA()
obj_C.printB()
obj_C.printC()

'''
运行结果为：
--A--
--B--
--C--
'''

继承中的init

class TestA():
    def __init__(self):
        print('TestA init')
class TestC():
    def __init__(self):
        print('TestC init')
class TestB(TestA,TestC): 
   # pass  #此时谁写的靠左调用谁的 init
    def __init__(self):
        TestA.__init__(self) #当子类中自己带init时，则不执行父类中的init，除非写这一句进行声明
        TestC.__init__(self)
        print("TestB init")
b = TestB()

（3）多重继承（多个单继承）：

继承中的init：

class TestA():
    def __init__(self):
        print('TestA init')
class TestC(TestA):
    def __init__(self):
        TestA.__init__(self)
        print('TestC init')
class TestB(TestC):
    #pass  #此时从下到上，若C里没有init，则向上找A的init
    def __init__(self):
        TestC.__init__(self)
        print("TestB init")
b = TestB()

 

六：组合

把几个没有继承关系的类放在一起

class Turtle:
    def __init__(self,x):
        self.num = x

class Fish:
    def __init__(self,x):
        self.num = x

class Pool:
    def __init__(self,x,y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)
    def print_num(self):
        print("水池里一共有乌龟%d只,小鱼%d条"%(self.turtle.num , self.fish.num))

pool = Pool(1,10)
pool.print_num()
#输出：水池里一共有乌龟1只,小鱼10条

七：类、类对象、实例对象

如果属性的名字和方法相同，也会覆盖方法

class C:
    def x(self):
        print('hello')

c = C()
c.x()  #输出hello

c.x = 1 #新建一个属性x
print(c.x)  #输出1
print(c.x())   #输出错误，因为新建的属性覆盖了之前的方法

 

八：多态

定义时的类型和使用时的类型不一样 ，此时就形成了多态

class F1:
    pass
class S1(F1):
    def show(self):
        print('S1.show')
class S2(F1):
    def show(self):
        print('S2.show')
def Func(obj):
    print(obj.show())

s1_obj = S1()
Func(s1_obj)

s2_obj =S2()
Func(s2_obj)

九：重载

class Cat:
    def sayHello(self):
        print('halou--1')
class Bosi(Cat):
    def sayHello(self):
        print('halou--2')
bosi = Bosi()
bosi.sayHello() #就近原则，所以输出halou--2

十：公有私有

python中不存在public和private这样的关键字，python是伪私有

#公有
class  Person():
    name = '哈哈'

p = Person()
print(p.name)  #输出：哈哈


#私有
class Person():  
    __name - '哈哈' #相当于private

p = Person();
print(p.__name)  #报错
print(p.name)   #报错


#使用私有
class Person():
    __name = '哈哈'
    def getName(self):
        return self.__name
p = Person()
print(p.getName())  #输出正确结果
print(p._Person__name)  #同样输出正确结果

十一：构造和析构

class CapStr(str):  #当类继承自不可改变的类（str就是不可改变的类）
    def __new__(cls, string):  #此时调用new方法对str进行修改
        string = string.upper()
        return  str.__new__(cls,string)
a = CapStr("fdsgfASFGFDsadDFDfds")
print(a)

#垃圾回收机制:当所有的对这个对象的引用都被del之后才会被del
class A:
    def __init__(self):
        print("haha")
    def __del__(self):
        print("beybey")