Python的OOP面向对象

# OOP 实战通过简单的case 更好的理解OOP思想， 如果使用代码，可以下载附件修改为.py即可

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2017年3月24日

@author: fWX457893
'''
# 类的封装  
class Student(object):
    # __ 双下划线可使变量私有变成private，只有在函数每部可以访问，外部不能访问，    
    def __init__(self, name, score, **kw):
        self.__name = name
        self.__score = score
        self.kw = kw
    
    # 如果还想要让外部访问，可是添加方法  get_name, get_score, get_kw
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    # 又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：
    def set_name(self, name):
        self.__name = name
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else :
            raise ValueError('bad score')
    
    def print_score(self):
        print('%s: %s \t %s' % (self.__name, self.__score, self.kw))
        
    def get_grade(self):
        if self.__score >= 90:
            return 'A'
        elif self.__score >= 60:
            return 'B'
        else :
            return"C"

bart = Student('fyh', 100, address='bj')

bart.print_score()

bart.set_score(10)
bart.print_score()

grade = bart.get_grade()
print grade
# 表面上看，外部代码“成功”地设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量！
# 内部的__name变量已经被Python解释器自动改成了_Student__name，而外部代码给bart新增了一个__name变量。不信试试：
bart.__name = 'new name'
print bart.__name
bart.print_score()

# -------------------------------------------------------------------------------
# OOP 的 继承和多态
class Animal(object):
    def run(self):
        print 'Animal is running...'
    def eat(self):
        print('Eating food...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Dog eating meat...')


class Cat(Animal):
    def run(self):
        print('Cat is running...')

    def eat(self):
        print('Cat eating fish...')


ani = Animal()
ani.run()

cat = Cat()
cat.run()

def run_eat(animal):
    animal.run()
    animal.eat()

run_eat(Animal())
run_eat(Dog())
run_eat(Cat())

'''
对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，
而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，
这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，
只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。

'''

# 
'''
静态语言 vs 动态语言

对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：

class Timer(object):
    def run(self):
        print('Start...')
这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。
许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。
'''

class Husky(Dog):
    def run(self):
        print('Husky is running...')

    def eat(self):
        print('Husky eating meat...')
        
# 使用isinstance()
# 对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。
# object -> Animal -> Dog -> Husky
animal = Animal()
dog = Dog()
husky = Husky()

print isinstance(husky, Husky), isinstance(husky, Dog), isinstance(husky, Animal)
# True True True  husky 是husky dog object 但是 dog 不是husky 是dog object


#定义一个父类一个子类
class Province(object):
    def __init__(self,proname):
        self.proname=proname
    def ps(self):
        print('I am in %s'%self.proname)

class City(Province):
    def __init__(self,proname,cityname):
        self.cityname=cityname
        Province.__init__(self,proname)
    def ps1(self):
        print('I\'m in %s-%s' %(self.proname,self.cityname))

#定义一个独立的类
class Timer(object):
    def ps(self):
        print('我不属于Province类或其子类，但我有ps方法我同样可以被调用')
    def ps1(self):
        print('我不属于Province类或其子类，但我有ps1方法我同样可以被调用')

#定义一个函数
def func(x):
    x.ps()
    x.ps1()

#调用部分
func(City('北京','海淀'))
func(Timer())

# 部分参考廖神的python教程。