什么是对象
世间万物皆对象
面向对象编程
把我们生活中的对象以及对象之间的关系模拟到程序中。
目的是为了让程序完成生活中的一些事情。
如何模拟
- 属性
- 方法：动作（行为）
如何编程
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()
- 重写和重载
重写：子类重写父类的方法，方法名，参数都相同。
重载：是在一个类中，方法名相同，参数的个数，类型，顺序不一样。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)