Python面向对象编程

目录

• 什么是对象
• 面向对象编程
• 如何模拟
• 如何编程
• 类的属性和方法的种类
• 属性和方法的私有化
• 面向对象编程的三大特性

什么是对象

世间万物皆对象

面向对象编程

把我们生活中的对象以及对象之间的关系模拟到程序中。
目的是为了让程序完成生活中的一些事情。

如何模拟

• 属性
• 方法：动作（行为）

如何编程

1.类：就是一个模板，设计属性和方法。
2.对象：也叫类的实例化，类的实体。
3.通过对象调用属性和方法。

# 格式：
class 类型:
    类的主体

# 举例：
class Person:

    #属性
    def __init__(self,n,s,a):    # __init__构造方法
        self.name = n
        self.sex = s
        self.age = a

    #方法
    def run(self):
        print("跑步")
				
    def study(self):
        print("学习")

if __name__ == '__main__':
    p = Person("路飞","男","18")    # 创建对象时默认会调用构造方法
    print(p.name,p.age+10,p.sex)
    p.run()
    p.study()

类的属性和方法的种类

属性（类属性，实例属性，内置属性）
方法（类方法，实例方法，内置方法，静态方法）

class Person:

    # 实例属性
    def __init__(self,n,s,a):    # __init__构造方法
        self.name = n
        self.sex = s
        self.age = a

    # 类属性（类属性由类名调用）
    code=100

    # 内置属性:是类自带的不需要定义，本质也是类属性。
    # print(Person.__dict__)
    # print(Person.__doc__)
    # print(Person.__name__)
	
    # __init__是构造方法，在初始化对象时自动调用。作用是：初始化实例属性。
    # self是当前类的对象。类似于java中的this。具体是：谁调用了带有self的方法，那么self就是那个对象。self不需要传参。

    # 实例方法
    def run(self):
        print("跑步"+self.name)
				
    def study(self):
        print("学习")

    # 类方法:必须有装饰器@classmethod，并且第一个参数是cls，cls代表当前类
    # 类方法是用于操作类属性的，不能操作实例属性。
    @classmethod    #装饰器
    def setCode(cls,c):
        cls.code = c;

    @classmethod  # 装饰器
    def getCode(cls):
        return cls.code

    #静态方法(必须有装饰器@staticmethod，它既没有self也没有cls，其实就是一个函数)
    @staticmethod
    def smthod():
        print("我是静态方法")

if __name__ == '__main__':
    # p = Person("路飞","男","18")    # 创建对象时默认会调用构造方法
    # print(p.name,p.age+10,p.sex)
    # p.run()
    # p.study()
    
    # s = Person("鸣人", "男", 18)    # 创建对象时默认会调用构造方法
    # s.run()

    # print(Person.__dict__)
    # print(Person.__doc__)
    # print(Person.__name__)

    # Person.setCode(300)
    # print(Person.getCode())

    # p = Person("路飞", "男", 18)
    # p.smthod()

属性和方法的私有化

在属性和方法的前面加上__表示对属性和方法私有化。
原则上只能在本类调用，在其他类无法调用。
但是python提供了对象，__类名__属性名(__方法名)的机制访问私有属性和方法。

class Test:
    def test_private(self):
        p=Person("路飞","男",18)
        #print(p.age,p.sex)
        #print(p._Person__name)
        #p.study()
        #p._Person__run()

if __name__ == '__main__':
    t = Test()
    t.test_private()

面向对象编程的三大特性

1.封装
第一层含义：把属性和方法放入一个类作为模板就是一种封装。
第二层含义：把属性和方法私有化也是一种封装。

2.继承的特点
1）在Python中，如果父类和子类都重新定义了构造方法__init__( )，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。
Parent.init(self,n)

2）如果需要在子类中调用父类的方法：可以使用self.方法名()或者是super().方法名()
3）当出现重写时，Python总是首先查找子类，然后在查找父类，然后在查询爷爷类，以此类推。
4）父类私有的属性和方法不能被继承。
5）Python支持多继承。
6) 继承当中的两个方法。
print(isinstance(c,Child)) #判断一个对象是否是一个类的实例。
print(issubclass(Child,Parent)) #判断一个类是否是另一个类的子类。

class Parent:
    def __init__(self,n):
        self.name = n
        print("这是父类的构造方法")

    def study(self):
        print("父类学习的方法"+self.name)

class Child(Parent):
    def __init__(self,n):
        #如果想要继承父类的属性，那么必须在子类的构造方法中手动的调用父类的构造方法。
        Parent.__init__(self,n)
        print("这是子类的构造方法")

    def child_func(self):
        print("这是子类的方法"+self.name)

if __name__ == '__main__':
    c = Child("张三")
    #c.child_func()
    c.study()

7. 重写和重载
   重写：子类重写父类的方法，方法名，参数都相同。
   重载：是在一个类中，方法名相同，参数的个数，类型，顺序不一样。python不支持。

3.多态
同样的行为(方法)因为执行者不一样而得到不同的结果，呈现多种形态叫多态。
作用是：提高程序的扩展性。

class weixin:
    def zhifu(self):
        print("通过微信支付")

class zhifubao:
    def zhifu(self):
        print("通过支付宝支付")

class yinlian:
    def zhifu(self):
        print("通过银联支付")

#开始支付(多态)
def start_pay(obj):
    obj.zhifu()

if __name__ == '__main__':
    #创建三个对象
    wx = weixin()
    zfb = zhifubao()
    yl = yinlian()
    #调用
    start_pay(wx)
		
# ------------------
class mysql:
    def add_product(self):
        print("通过mysql的insert语句增加")
class oracle:
    def add_product(self):
        print("通过oracle的insert语句增加")
class sqlserver:
    def add_product(self):
        print("通过sqlserver的insert语句增加")
#增加(多态)
def add(obj):
    obj.add_product()
if __name__ == '__main__':
    #创建三个对象
    ms = mysql()
    ol = oracle()
    ss = sqlserver()
    #调用
    add(ol)