关于python中的面向对象

标签：测试   python   

对于面向对象（oop）的理解

在人类的认知中，我们习惯把属性相近的东西进行归类。所以，我们写的class xxx就是一个类，描述了一组属性的集合。而我们把这组属性具体实例出来的称之为对象

比如：

class Bird(object):
      def __init__(self,feather,call):
          self.feather=feather
          self.call=call

我们定义了一个鸟的类，并且初始化函数定义了它有羽毛，可以叫。这个就是类

bird=Bird("yellow","jiujiu")

我们定义了一个对象。***羽毛的鸟，叫声是啾啾

当然，面向对象没有那么简单。其中还是涉及到了

继承，

多继承，迷信继承，

方法重写，

权限，如父类私密的数据能否在子类中读取跟操作

python中实现继承的方式，是直接在这个类的括号里面写出父类。例如Bird的父类就是object

关于子类继承父类：

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather,year):
		self.name=name
		self.feather=feather
		self._year=year
	def call(self):
		print "this is a mether----For bird"
	def get_year(self):
		return self._year
class litteBird(Birds):
	pass

b=litteBird("ll",‘yellow‘,‘100‘)

如果子类中定义的是pass，那么，将会接收的是父类的所有函数和参数。在python中类的所有参数都是在__init__()中定义的，貌似没有直接在函数外定义。那样感觉很怪，无奈才疏学浅。还不能很好参透

访问限制：

__name:这个形式在python中表现是私密数据/方法，python将之转换为了_className__name

__name__：这个在python是表示特殊变量的

_name:这个虽然可以访问，但是表示，我是私密数据，最好不要访问

所以在父类中设为私密的，是_fatherName__name。当你在子类想要访问父类的私密方法，或者数据是，就会提示为_sonName__name不存在

所以，你直接在子类中直接去调用self.__year是不存在的。因为被改成了__sonName__year。只有你改成了父类的_fatherName__year才可以访问

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather):
		self.name=name
		self.feather=feather
		self.__year=100
	def call(self):
		print "this is a mether----For bird"
	def __Get_year(self):
		print self.__year

class litteBird(Birds):
	def set_year(self):
		print self.__year #找不到。

b=litteBird("ll",‘yellow‘)
b.set_year()

改成下面就可以访问到数据：

#!/usr/bin/env python
#-*-coding:utf-8-*-
class Birds:
	def __init__(self,name,feather):
		self.name=name
		self.feather=feather
		self.__year=100
	def call(self):
		print "this is a mether----For bird"
	def __Get_year(self):
		print self.__year

class litteBird(Birds):
	def set_year(self):
		print self._Birds__year

b=litteBird("ll",‘yellow‘)
b._Birds__Get_year()

所以关于访问限制：

    在一个类中被设为私密的数据的。都会被改成_className__name这种直白的方式.所以在子类也不能直接访问。除非你改成这种直白的方式

多态：

关于多态的理解。就是我们可以重写父类函数。比如

b=litterBird()

    python中没有强调类型。但是，这里的b其实既是Birds类型，也是litterBird类型。用isinstance()可以看出来。所以。我们可以再子类定义自己的方法。重复使用父类中共同的方法

多继承和迷信继承：

多继承就是同时继承多个类。速度会比较快

迷信混入继承，属于动态的多继承。会比较慢

有一点，多继承如果，继承的两个类有相同的方法名？那么执行排在最前面的方法。

如果子类有方法，执行子类方法

如果子类没方法，执行父类方法

如果多个父类，执行排在最前面的父类

如果排在最前的父类没有，但是，这个父类的父类有，那么会执行这个父类的父类，还是下一个父类？

执行父类的父类

#!/usr/bin/env python
#-*-coding:utf-8-*-
class grandfather:
	def hair(self):
		print "Ghair"

class mother(grandfather):
	pass

class father:
	def hair(self):
		print "No hair"
class son(mother,father):
	pass

s=son()
s.hair()
#Ghair

本文出自 “ehealth” 博客，谢绝转载！

关于python中的面向对象

标签：测试   python   

原文地址：http://ehealth.blog.51cto.com/10942284/1731679