python面向对象 继承编程题 python面向对象例题

面向对象

文章目录

• 面向对象

• 1.类和对象
• 2.实例方法、类属性和实例属性
• 3.添加实例属性
• 4.魔术方法

• （1）直接打印对象
• （2）__ str __方法
• （3）__ new __方法

• 5.析构方法

• （1）程序执行完毕自动调用del释放内存
• （2）手动清理对象

• 6.单继承
• 7.多继承

• （1）多继承
• （2）继承顺序
• （3）继承的传递性

• 8.重写父类和调用父类
• 9.类属性和实例属性
• 10.类方法和静态方法

• （1）类方法
• （2）静态方法

• 11.多态

• （1）手动实现多态
• （2）自动实现多态

• 12.私有化属性
• 13.私有化方法

1.类和对象

#定义类
class Person:
    name='小明' #类属性
    age=20 #类属性
    def eat(self): #实例方法
        print(+'吃'+'apple')
        pass
#创建对象:类的实例化
xm=Person()
print()
print(xm.eat())

结果：

小明
小明吃apple

2.实例方法、类属性和实例属性

class Person:
    name='小明' #类属性
    age=20 #类属性
    def __init__(self,pro,fam):
        one='jkl' #实例属性
        self.pro=pro  #实例属性
        self.fam=fam #实例属性
    def eat(self): #实例方法
        print(+'吃'+'banana')
        pass

xm=Person('teacher','three')
print(,xm.pro)
print(xm.eat())

结果：

小明 teacher
小明吃banana

3.添加实例属性

class Person:
    name='小明' #类属性
    def __init__(self,pro,fam):
        one='jkl' #实例属性
        self.pro=pro  #实例属性
        self.fam=fam #实例属性
    def eat(self): #实例方法
        print(+'吃'+'banana')
        pass

xm=Person('teacher','three')
xm.age=20 #添加实例属性
print(xm.age)
xl=Person('teacher','three')
print(xl.age)

结果：

20
AttributeError: 'Person' object has no attribute 'age'

4.魔术方法

（1）直接打印对象

class Person:
    name='小明' #类属性
    age=20 #类属性
    def eat(self): #实例方法
        print(+'吃'+'apple')
        pass
#创建对象:类的实例化
xm=Person()
print(xm) #直接打印对象，得到的是对象的地址

结果：

<__main__.Person object at 0x00000229D1164940>

（2）__ str __方法

class Person:
    name = '小明'  # 类属性
    age = 20  # 类属性

    def __init__(self, pro, fam):
        one = 'jkl'  # 实例属性
        self.pro = pro  # 实例属性
        self.fam = fam  # 实例属性

    def eat(self, food):  # 实例方法
        print( + '吃' + food)
        pass

    def __str__(self):
        return '%s的专业是%s' % (one, self.pro)

xm=Person('teacher','three')
print(xm)

结果：

jkl的专业是teacher

（3）__ new __方法

若直接创建对象，则默认调用__ new __ ，若使用 __ new __，必须在内部创建并返回。

class Person:
    name = '小明'  # 类属性
    age = 20  # 类属性

    def __init__(self, pro, fam):
        one = 'jkl'  # 实例属性
        self.pro = pro  # 实例属性
        self.fam = fam  # 实例属性

    def eat(self, food):  # 实例方法
        print( + '吃' + food)
        pass

    def __new__(cls, *args, **kwargs):
        print('new函数执行')

xm=Person('teacher','three')
print(xm.pro)

结果：

new函数执行
AttributeError: 'NoneType' object has no attribute 'pro'

真正创建实例对象。new函数执行要早于init函数。

class Person:
    name = '小明'  # 类属性
    age = 20  # 类属性

    def __init__(self, pro, fam):
        one = 'jkl'  # 实例属性
        self.pro = pro  # 实例属性
        self.fam = fam  # 实例属性

    def eat(self, food):  # 实例方法
        print( + '吃' + food)
        pass

    def __new__(cls, *args, **kwargs):
        print('new函数执行')
        return object.__new__(cls) #创建当前类的实例对象并返回

xm=Person('teacher','three')
print(xm.pro)

结果：

new函数执行
teacher

5.析构方法

（1）程序执行完毕自动调用del释放内存

class Animal:
    def __init__(self,name):
        =name
        print('这是构造初始化')
        pass
    def __del__(self):
        print('这是析构方法')
        pass

cat=Animal('cat')
print()
input('输入: ') #程序没有执行完毕，则不会调用del函数释放内存

当没有执行完毕时：

这是构造初始化
cat
输入:

当执行完毕时：

这是构造初始化
cat
输入:2
这是析构方法

（2）手动清理对象

手动清理对象，会指定del方法用来释放内存

class Animal:
    def __init__(self,name):
        =name
        print('这是构造初始化')
        pass
    def __del__(self):
        print('这是析构方法')
        pass

cat=Animal('cat')
del cat

结果：

这是构造初始化
这是析构方法

6.单继承

class Animal:
    def eat(self):
        print('吃')
        pass
    def drink(self):
        print('喝')
        pass
class dog(Animal): #继承父类，dog是子类
    def wwj(self):
        print('wwj')
        pass
class cat:
    def mmj(self):
        print('mmj')
        pass
d1=dog()
d1.eat()
d1.wwj()

结果：

吃
wwj

7.多继承

（1）多继承

class sx:
    def fly(self):
        print('会飞')
        pass
class Monkey:
    def ct(self):
        print('吃桃')
        pass
class Swk(sx,Monkey):
    pass

swk=Swk()
swk.fly()
swk.ct()

结果：

会飞
吃桃

（2）继承顺序

class D:
    def eat(self):
        print('D.eat')
        pass
class C(D):
    def eat(self):
        print('C.eat')
        pass

class B(D):
    pass
class A(B,C):
    pass
a=A()
a.eat() #广度优先
print(A.__mro__)

结果：

C.eat 
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

（3）继承的传递性

class Gp:
    def eat(self):
        print('吃')
        pass
    pass
class Fa(Gp):
    pass
class Son(Fa):
    pass
son=Son()
son.eat()

结果：

吃

8.重写父类和调用父类

class Dog:
    def __init__(self,name):
        =name
        pass
    def bark(self):
        print('wwj')
        pass
    pass
class kj(Dog):
    def __init__(self,name):
        #Dog.__init__(self,name) #手动找到父类
        super().__init__(name) #自动找到父类
        self.age=20 #拓展新的属性
        pass
    def bark(self):
        print('叫的厉害')
        print()
        pass
    pass
gh=kj('哮天犬')
gh.bark()
print(gh.name)

结果：

叫的厉害
哮天犬
哮天犬

9.类属性和实例属性

class Student:
    name='jkl'#类属性
    def __init__(self,age):
        self.age=age #实例属性
        pass
    pass
stu=Student(18)
='zqz' #实例修改类属性，只有修改的实例的属性会发生变化
print(,stu.age)
xm=Student(20)
print()

='wxq' #通过类对象修改类属性，所有实例的类属性都会变化

stu1=Student(25)
print()
print()
#print(Student.age) #类对象不能调用实例属性

结果：

zqz 18
jkl
wxq
wxq

10.类方法和静态方法

（1）类方法

class People:
    '''
    类方法：类对象拥有的方法，用装饰器@classmethod来标识，第一个参数是类对象cls。类对象、实例对象可以调用类方法。
    '''
    country='china'
    @classmethod
    def get_country(cls): #类方法
        return cls.country
        pass
    @classmethod
    def change_country(cls,data): #类方法中修改类属性的值
        cls.country=data
        pass

print(People.get_country()) #通过类对象引用
p=People()
print(p.get_country()) #通过实例对象引用
People.change_country('japan')
print(People.get_country())

结果：

china
china
japan

（2）静态方法

class People:
    '''
    静态方法：类对象拥有的方法，用装饰器@staticmethod来标识，可以不需任何参数。一般，不通过实例对象访问静态方法。
    一般存放逻辑性的代码，和类、实例没有交互。
    '''
    country='china'
    @staticmethod
    def getdata():
        return People.country
    pass

print(People.getdata())

结果：

china

11.多态

（1）手动实现多态

'''
多态：同一种方法对不同的子类有不同的表现。
条件：继承和重写。
'''
class Animal:
    def say(self):
        print('一只动物')
        pass
    pass
class Dog(Animal):
    def say(self):
        print('一只狗')
        pass
    pass
class Cat(Animal):
    def say(self):
        print('一只🐱')
        pass
    pass
    
cat1=Cat()
cat1.say()
dog1=Dog()
dog1.say()

结果：

一只🐱
一只狗

（2）自动实现多态

class Animal:
    def say(self):
        print('一只动物')
        pass
    pass
class Dog(Animal):
    def say(self):
        print('一只狗')
        pass
    pass
class Cat(Animal):
    def say(self):
        print('一只🐱')
        pass
    pass
def commonInvoke(obj): #实现用统一的方法调用
    obj.say()
    pass
    
listobj=[Dog(),Cat()]
for i in listobj:
    commonInvoke(i)

结果：

一只🐱
一只狗

12.私有化属性

class Person:
    __hobby='sing'
    def __init__(self):
        self.__name='jkl'
        self.age=30
        pass
    def __str__(self):
        return '名字是%s,爱好是%s'%(self.__name,self.__hobby) #可以在类内访问
    pass
    def changevalue(self):
        Person.__hobby='dance' #私有化属性可以在类内修改
class Student(Person):
    pass
stu=Student()
#print(stu.__name) #子类不能继承父类私有化属性
xl=Person()
#print(xl.__name) #私有化属性在类外不能访问
xl.changevalue()
print(xl)
#print(xl.__hobby) #私有类属性不能在类外访问

结果：

名字是jkl,爱好是dance

13.私有化方法

class Animal:
    def __eat(self):
        print('吃')
        pass
    def run(self):
        self.__eat() #可以在类内调用
        print('跑')
        pass
    pass
class Bird(Animal):
    pass

b1=Bird()
#b1.__eat() #类外不能调用私有化方法
b1.run()

结果：

吃
跑