PythonMan（九）

标签：

Hello Python ：）

　　面向对象的特征：封装、继承、多态
　　　　Python在创建类，创建对象，继承在语法上有较大的出入。

　　类和对象：
　　　　Python和其他大多数高级语言一样，大写字母开头。
　　　　创建类：
　　　　　　class First:
　　　　　　　　Something Code...

　　　　创建对象：
　　　　　　obj = First()

　　　　多态：
　　　　　　class A:
　　　　　　　　def fun(self):
　　　　　　　　　　print("A Here")

　　　　　　class B:
　　　　　　　　def fun(self):
　　　　　　　　　　print("B Here")

　　　　　　a = A()
　　　　　　b = B()
　　　　　　a.fun()
　　　　　　b.fun()
　　　　　　#同一个方法，对象不同，响应不同，这就是多态

　　　　self：
　　　　　　self相当于本身，由同一个类可以生成无数个对象，当一个对象的方法被调用时，这个对象会将自身作为第一个参数传递给函数。以示自己的身份。

　　　　　　class Ball:
　　　　　　　　def setName(self , name):
　　　　　　　　　　self.name = name

　　　　　　　　def kick(self):
　　　　　　　　　　print("I am %s " % self.name)

　　　　　　　　a = Ball()
　　　　　　　　a.setName("Stark")
　　　　　　　　b = Ball()
　　　　　　　　b.setName("Air")
　　　　　　　　a.kick()
　　　　　　　　b.kick()

魔法方法(一)：
　　被双下划线所包围的方法，一般都会自动触发
　　　　__init__(self):
　　　　　　可以理解为Java等的构造方法啦...

　　公有和私有：
　　　　Python没有Java的private和public等权限修饰符

　　class Person:
　　　　name = "Kepler"

　　p = Person()
　　print(p.name)
　　#默认是公有，通过.来访问
　　　　

　　为了私有，定义私有只需要加入‘__’

　　　　　　class Student:
　　　　　　　　__name = "Air"

　　　　　　s = Student()
　　　　　　print(s.name)
　　　　　　#会报错，如果要访问，可以搞一个getName方法

　　　　　　事实上，也可以s._Person__name这样访问，所以Python是伪私有啦（就算Java等真私有，我们也可以有反射机制强行访问私有，So...）

继承：
　　class Father:

　　　　father = "father‘s"

　　　　def hello(self):
　　　　　　print("hello")

　　class Son(Father):
　　　　pass

　　s = Son()
　　print(s.father)
　　s.hello()
　　#子类可以调用父类的方法过河变量

　　当子类重写了父类的方法时，子类对象默认会调用子类的方法。如果想在重写的方法里面还拥有父类的属性，How？
　　　　a）调用未绑定的父类方法
　　　　　　class Father:
　　　　　　　　def __init__(self):
　　　　　　　　　　self.x = 1
　　　　　　　　　　self.y = 2

　　　　　　class Son(Father):
　　　　　　　　def __init__(self):
　　　　　　　　Father.__init__(self)
　　　　　　　　self.z = 3

　　　　b）使用super()函数
　　　　　　class Father:
　　　　　　　　def __init__(self):
　　　　　　　　　　self.x = 1
　　　　　　　　　　self.y = 2

　　　　　　class Son(Father):
　　　　　　　　def __init__(self):
　　　　　　　　　　super()
　　　　　　　　　　self.z = 3

Python也支持多继承，但会引起代码隐患，所以单继承就很好了...

组合
　　class Husband:
　　　　def __init__(self,x):
　　　　　　self.power = x

　　class Wife:
　　　　def __init__(self,x):
　　　　　　self.power = x
　　

　　class son:
　　　　def __init__(self,x,y):
　　　　　　self.husband = Husband()
　　　　　　self.wife = Wife()

　　　　def printNum(self):
　　　　　　print("Husband:" + self.husband.power + "Wife:" + self.wife.power)


所以，组合是把几个没有纵性关系的几个类串行起来用，也没有什么风险。


细节：
　　　如果属性和方法的名字相同，属性会覆盖掉方法

绑定：
　　　Python严格要求方法需要有实例才能被调用，这种限制就是Python所谓的绑定概念。
案例一：
　　class Test_1:
　　　　def testMethod():
　　　　　　print("Test")

　　Test_1.testMethod() #可以调用
　　test = Test_01()
　　test.testMethod() #调用失败

案例二：
　　class Test_2:
　　　　def setXY(self,x,y):
　　　　　　self.x = x
　　　　　　self.y = y

　　　　def printXY():
　　　　　　print(self.x)
　　　　　　print(self.y)

　　test = Test_2()
　　test.setXY(10,20)
　　test.printXY()
　　del Test_2
　　test.printXY() #即便删除了Test_2，test对象仍然可以调用方法，仍然拥有x，y属性，直到退出整个Python程序，因为Python的类中，属性和方法都是静态形式存在的。

PythonMan（九）

标签：

原文地址：http://www.cnblogs.com/AirStark/p/5722172.html