Java工程师学快速Python(5) 面向对象

类对象

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

__init__() 方法：

相当于java中的构造函数

class MyClass:
    i=3
    j=4
    def __init__(self,i,j)://类初始化调用，self相当于java中的this关键字
        self.i=i
        self.j=j
    def __init__(self)://和java不同的是python不支持构造函数重载，默认下面这个会覆盖上面的构造函数
        pass

x=MyClass()
print(x.i,x.j)

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

class MyClass:
    i=3
    j=4

    def __init__(self1,i,j):
        self1.i=i
        self1.j=j
        print(self1.__class__) //相当于java 中的class
        print(self1) //相当于地址


x=MyClass(1,3)
print(x.i,x.j)

继承

与java不同的是，python支持多继承，如果要跨模块就必须导入模块

class f1:
    def speak(self,s):
        print(s)
    def talk(self,s):
        print("f1"+s)

class f2:
    def speak(self,s,r):
        print(s,r)
    def talk(self,s):
        print("f2"+s)

class f3(f2,f1):
     pass




f4= f3()
f4.speak(3,3)
f4.talk("321")

python的多继承方式从左右到右，左边的方法会覆盖右边同名的方法，python中没有方法重载概念，但是有方法重写的概念

上面这段代码代码中，f2中的speak方法覆盖了f1中speak的方法，f2中的talk方法重写了f1中的talk方法，如果换成f3（f1,f2）

则f1中的方法会覆盖或者重写f2中的方法

强转

上面一段函数中如果要调用f2中的speak方法可以采用

super(f3,a).speak("23")

这就调用了f2中的speak方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用  python 和java一样有自动回收的功能， del 对象，就会掉用这个方法 
• __repr__ : 打印，转换   相当于java中的toString方法 注意这个方法有返回值
• __setitem__ : 按照索引赋值   
• __getitem__: 按照索引获取值
• __len__: 获得长度         属性变量的个数
• __cmp__: 比较运算       
• __call__: 函数调用    
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

上面的方法中说一下__call__方法

在python中万物皆对象，函数可以调用，对象也可以进行吊椅哦那个

class Reader():
     def __init__(self,name,nationality):
            self.name = name
            self.nationality = nationality
     def __call__(self):
         print('Reader: %s    Nationality: %s' % (self.name, self.nationality))

r=Reader("213","!@3")
r()

上面的r对象通过Reader new出来，然后可以直接调用r()执行的就是Reader对象的__call__方法

装饰器：

这是python中最重要的一种语法糖

下面函数做了个蛋糕

def makecake():
    print("make cakes")

如果我要在做蛋糕后插下蜡烛

常规的做法是

def makecake():
    print("make cakes")
    print("插蜡烛")

但是这样做是会有问题，违反了开闭原则

java中有一种做法就是装饰器模式，python中同样有方法，叫装饰器

def makecake():
    print("make cakes")


def makecakeChalazhu(func):
    def wrap():
        func()
        print("chalazhu")
    return wrap


a=makecakeChalazhu(makecake)#记得不要带括号
a()

这是不是很像java的装饰器模式

python中还有更进一步的写法

def makecakeChalazhu(func):
    def wrap():
        func()
        print("chalazhu")
    return wrap

@makecakeChalazhu
def makecake():
    print("make cakes")