python面向对象下

• 封装
• • 封装的方法
  • 获取私有属性
• 继承
• • 单一继承
  • • 语法格式
    • 同名的情况
    • 私有属性的调用方法
  • 多重继承
  • • 语法格式
    • 小例子
    • 同名的情况
• 多态
• 持续更新中~~~~~~~~~

封装

封装是面向对象的核心思想。它是指将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏细节，这就是封装的思想。

私有属性：我们在属性前加两个下划线表示的是私有属性

封装的方法

我们写如下的代码：

class Student():def __init__(self,myName,myScore):self.name,self.score=myName,myScoredef __str__(self):return '姓名：'+str(self.name)+'\t成绩：'+str(self.score)
s1=Student('ohhh',100)
print(s1)
s1.score=-18
print(s1)

以上的结果如下：

我们在实际情况中，通常是不能将成绩改成负数的，所以这里为了防止用户的自我修改，就用到了封装
下面是封装后的代码：

class Student():def __init__(self,myName,myScore):self.name,self.__score=myName,myScoredef __str__(self):return '姓名：'+str(self.name)+'\t成绩：'+str(self.__score)
s1=Student('ohhh',100)
print(s1)
s1.__score=-18
print(s1)

下面是程序的执行图：

我们发现将__score这个变量不能够被函数外面的引用修改我们可以想一下在游戏中，我们可以自己修改自己的用户名，但是自己不能修改自己的等级，和这个封装很类似

获取私有属性

我们通常应该提供设置或获取属性值的两个方法供外界使用，如下面的代码：

class Student():def __init__(self,myName,myScore):self.name=myNameself.setScore(myScore)def setScore(self,myScore):if(myScore>=0 and myScore<=100):self.__score=myScoreelse:self.__score=0print("输入的成绩有误！")def getScore(self):return self.__scoredef __str__(self):return '姓名：'+str(self.name)+'\t成绩：'+str(self.__score)
s1=Student('ohhh',-100)
print(s1)
s2=Student('ojjj',89)
print(s2)

下面是代码结果：

继承

用于描述类的所属关系，多个类通过继承形成一个关系体系

单一继承

语法格式

单一继承只有一个基类，继承关系比较简单，操作比较容易，因此使用相对较多
语法格式如下代码：

class People(object): #object通常省略print('人们有不同的职业')
class Student(People):print('我们都一样')

派生类继承于基类，派生类可以使用基类的所有公有成员，也可以定义新的属性和方法，从而完成对基类的扩展，python中所有的类继承于object，但是其通常省略

同名的情况

如果派生类中的属性和方法同名，那么派生类实例对象调用派生类中的定义的属性和方法，如下例所示：

class Person(object):def __init__(self,name):self.name='wan' #实例对象def show(self):print("姓名",self.name)
class Student(Person):def __init__(self,name,score):self.name,self.__score=name,scoredef __str__(self):return "姓名："+self.name+' '+'分数：'+str(self.__score)
s1=Student('qian',100)
print(s1)

下面是代码运行结果：

如果派生类的构造函数中需要添加参数，则可以再派生类中调用基类，如下例所示：（也有很多其他的方法，如直接给继承的变量赋新值就可以）

class Person(object):name='ccc'def __init__(self,name):self.name='wan'def show(self):print("姓名",self.name)
class Student(Person):def __init__(self,name,score):super(Student,self).__init__(name)# Person.__init__(self,name) # 这两种形式都可以self.__score=100def __str__(self):return "姓名："+self.name+' '+'分数：'+str(self.__score)
s1=Student('qian',100)
print(s1)

下面是运行结果：

我们发现，这个虽然传入了自己的参数，但是输出的name是基类中的名字

私有属性的调用方法

这里要注意的是基类的私有属性和方法是不会被派生类继承的，因此，派生类不能反问基类的私有成员，但是可以通过相应的方法间接调用，如下例所示：

class Person(object):def __init__(self,name):self.__name=namedef __show(self):print("姓名：",self.__name)def get_name(self):print(self.__name)def get_method(self):self.__show()
class Student(Person):def test(self):print(self.__name)def test1(self):self.get_name()self.get_method()
s1=Student('1111')
# s1.test()# 我们会发现调用这个的话会报错
s1.test1()

下面是输出结果：

我们发现对于基类中的私有变量，我们只能通过一定的方法去访问，不能直接访问

多重继承

语法格式

多重继承就是指派生类同时继承多个基类，其语法格式如下：

class 基类1(object):类体
class 基类2(object):类体
class 派生类(基类1,基类2):类体

格式很简单，就是再派生类里面依次写上要继承的类名即可。

小例子

下面是一个样例代码：

class Student(object):def __init__(self,name,score):self.name,self.score=name,scoredef showStd(self):print('姓名:',self.name,'分数:',self.score)
class Staff(object):def __init__(self,id,salary):self.id,self.salary=id,salarydef showStf(self):print('ID:',self.id,'薪资:',self.salary)
class jobGraduate(Student,Staff):def __init__(self,name,score,id,salary):Student.__init__(self,name,score)Staff.__init__(self,id,salary)
g1=jobGraduate('qian',100,'001',1000000)
g1.showStd()
g1.showStf()

下面是输出结果：

同名的情况

在多重继承中，如果基类存在同名的方法，python按照继承顺序从左到右在基类中搜索方法
如下例：

class Student(object):def __init__(self,name,score):self.name,self.score=name,scoredef showStf(self):print('姓名:',self.name,'分数:',self.score)
class Staff(object):def __init__(self,id,salary):self.id,self.salary=id,salarydef showStf(self):print('ID:',self.id,'薪资:',self.salary)
class jobGraduate(Student,Staff):def __init__(self,name,score,id,salary):Student.__init__(self,name,score)Staff.__init__(self,id,salary)
g1=jobGraduate('qian',100,'001',1000000)
g1.showStf()

我们将两个方法改成同名，发现是执行的继承的第一个对象：

总的来说，多重继承和单一继承是一样的，只是有一个在继承的类中依次查询变量的过程

多态

多态是指基类的同一个方法在不同的派生类对象中具有不同的表现和行为，当调用该方法时，程序会根据对象选择合适的方法
下面是一个例子：

class animal(object):def __init__(self,name,call):self.name=nameself.call=calldef say(self):print(self.call)def get(self):print(self.name)
class dog(animal):def __init__(self):self.name='dog'self.call='汪汪'
class cat(animal):def __init__(self):self.name='cat'self.call='喵喵'
an1=dog()
an1.say()
an1.get()
an2=cat()
an2.say()
an2.get()

持续更新中~~~~~~~~~