[已收纳]python之面对对象

15195775117

python的面对对象与Java别无二致，几乎一样


面对对象编程：
实例叫“对象”，实例的集合是“类”，类具有“属性”和“方法”。
面对对象编程3大特征：封装，继承，多态。
封装指类中的属性和方法的封装。
继承：子类继承父类的属性和方法。
定义类：
class ClassName:
‘’’......’’’
类体


一般，类名用“驼峰式命名法”，即单词首字母大写；
引用类时，输出类名+(时会弹出三引号的信息（跟函数一样）；
类的实例化：duck=Animal(参数...)
print(dick)可以查看其类是什么。


每个类都有个__init__()方法，=Java的构造方法，每创建一个类的实例，python都会自动执行它。
__init__()方法必须包含一个self参数，且必须是第一个参数。
Self参数是一个指向实例本身的引用，用于访问类中的属性和方法，在方法调用时会自动传递实参self，当__init__()方法只有一个参数时，在创建实例时就不需要指定实际参数了。
class C:
    '''这是个例子'''
    def __init__(self):
        print(999)
x=C()

__init__()方法除self还可有其他参数：
class C:
    '''这是个例子'''
    def __init__(self,x,y):
        print(x+y)
x=C(1,2)
结果：3

看来，这个self只是形式上多余的累赘，可以看做函数写法的一部分。
方法名以小写字母开头。

案例：
class FirstClass:
    '''这是个例子'''
    def __init__(self,x,y):
        print(x+y)
    def f(self,x,y):
        return x-y
    def g(self,x,y):
        return x*y
c=FirstClass(2,3)
print(c.f(2,3))
print(c.g(2,3))
结果：
5
-1
6

构造方法和一般方法的第一个参数都是self。

属性的修改：
class FirstClass:
    '''这是个例子'''
    num=0
    def __init__(self):
        FirstClass.num=FirstClass.num+1
c=FirstClass()
print(c.num)
c=FirstClass()
print(c.num)
c=FirstClass()
print(c.num)
c=FirstClass()
print(c.num)
结果：1 2 3 4

添加和修改类的属性：
class FirstClass:
    '''这是个例子'''
    a=1
    b=2
    def __init__(self):
        pass
FirstClass.a=999
x=FirstClass()
print(x.a)
FirstClass.c=3
x=FirstClass()
print(x.c)
结果：999 3

实例中也可以添加属性：实例名.属性=...

15195775117

属性和方法的访问权限


“保护”类型的属性或方法名以单下划线开头：只支持类本身和子类访问，不能用from module import*导入。


私有类型的属性和方法名以双下划线开头，只支持类本身访问，不支持“实例名.属性/方法”的访问方式，但支持“实例名._类名__xxx”的形式访问。（这岂不就不安全了？）



私有属性的访问方式：
class FirstClass:
    '''这是个例子'''
    __a=999
    def __init__(self):
        pass
    def __f(x,y):
        return x+y
x=FirstClass()
print(x._FirstClass__a)
结果：999

15195775117

方法转属性
class FirstClass:
    __a=999
    def __init__(self,x,y,z):
        self.x=x
        self.y=y
        self.z=z
    @property
    def f(self):
        return self.x+self.y+self.z
x=FirstClass(2,3,4)
print(x.f)
结果：9
这种操作的步骤是：把参量在__init__()中导入，然后后面转为属性的方法调用这些参量。方法写成属性的样子，在类之外改动时就会误会，把函数当变量来改就会出错，实现了“安全”。

继承
python的基类-派生类对应Java的父类-子类
class Father:
    x=111
    y=222
    def __init__(self):
        pass
    def f(x):
        return x*2
    def g(x):
        return x*3
class Son(Father):
    x=0
    def __init__(self):
        pass
    def f(self,x,y):
        return x+y
s=Son()
print(s.x,s.y,s.f(3,4))
结果：0 222 7

15195775117

python类的访问权限不像Java那么严格，有通融的渠道
class Fine:
    """
    书山有路勤为径
    学海无涯苦作舟
    床前明月光
    疑是地上霜
    """
    _protect=11
    __private=22
    def __init__(self,x,y,z):
        self.a1=x
        self.a2=y
        self.a3=z
        print('程序开始！')
    def f(self):
        return self.a1*self.a2
    def g(self):
        return self.a2+self.a3
    def __h(self):
        return self.a1+self.a3
a=Fine(1,2,3)
print(a.g())
print(a.f())
#输出注释：
print(Fine.__doc__)
#保护类型可以直接访问：
print(a._protect)
#私有类型可以通过加类名访问：
print(a._Fine__private)
print(a._Fine__h())
输出：
程序开始！
5
2

    书山有路勤为径
    学海无涯苦作舟
    床前明月光
    疑是地上霜

11
22
4

总结：
（1）变量用self.XXX表示可以跨方法使用
（2）类名.__doc__是输出注释的
（3）保护类型可以直接访问，私有类型可以通融访问

hanf