前言：
轮对象的重要性
主要内容：
面向对象编程：
OOP编程，模板和实际的对象来创建各种模型
class类：
就是模板
先写一个模板的原因是，后面会创建多个人，只是想传几个参数来创建多个人。这样大多数功能就不需要重写了。
类，就是对类拥有相同属性的对象的抽象，蓝图，原型。
每个对象可以有不同的属性。
手把手教你写一个简单的类
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Leon xie #类名,这个是必写的定义，简单的定义 #就像定义了一个函数，只是定义了它，不调用它不生效 class Dog(object): # print("hello,I am a dog.") #实例化完了以后，单独写一个功能，功能写在嵌套里面 def sayhi(self): print("hello,I am a dog.") #类是一个模板，写了一个模板，要把它实例化 d = Dog() #内存对象有了，但是我没调用 #print(d) #调用 d.sayhi()
打印结果
hello,I am a dog.
说明：
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author: Leon xie #类名,这个是必写的定义，简单的定义 #就像定义了一个函数，只是定义了它，不调用它不生效 class Dog(object): # print("hello,I am a dog.") def __init__(self,name): #构造函数，构造方法 == 初始化方法 self.NAME = name #实例化完了以后，单独写一个功能，功能写在嵌套里面 def sayhi(self): #类的方法 #类通过函数平起来的，实例化吧lichuang传给了init，但是我 #这个地方调不到上面的函数 print("hello,I am a dog.my name is ",self.NAME) def eat(self,food): print("%s is eating %s" %(self.NAME.food)) #类是一个模板，写了一个模板，要把它实例化 d = Dog("lichuang") #内存对象有了，但是我没调用 #print(d) d2 =Dog("chuang2") #调用 d.sayhi() d2.sayhi() #我无法区分是哪条狗，所以要传点参数区分 #类是一堆函数的组合，打通函数见甭能互相调用的问题 #没实例化，上面定义的类是存在的，以模板形式 #实例化后的对象我们叫做实例，当前类的实例 #self就是实力本身，
类的特性
封装
防止数据被随意修改。
使外部程序不需要关注对象内部的构造，只需要通过对象对外提供的接口进行直接访问即可。
继承
通过父类- 》子类的方式实现 不同角色的共同点和不同点
开发中避免写重复的代码，否则就相当于给自己挖坑。
函数的出现，就帮我们解决了重复代码的问题。
其实OOP编程的主要作用也是
1、代码量少了一半
2、角色和它所具有的功能一目了然
#!/usr/bin/env python # -*- coding: utf-8 -*- #Author: Leon xie class Dog(object): def __init__(self,name): #构造函数，构造方法 == 初始化方法 self.NAME = name def sayhi(self): #类的方法 ，写self原因是把实例本身传进来 print("hello,I am a dog.my name is",self.NAME) ''' 先实例化，然后在调用功能 ''' d = Dog("alex") d2 = Dog("LiChuang") d.sayhi() d2.sayhi() 打印结果 hello,I am a dog.my name is alex hello,I am a dog.my name is LiChuang
self相当于d，d就是实例化后的对象，实例化后产生的对象，叫做实例。当前类的实例。
self就是d，所以self就是实例本身，你生成哪个对象self就是谁
模板如下：
继承
通过父类->子类的方式以最小代码量的方式实现不同的角色
面向对象的特性：
封装
类==>实例化==》实例对象
__init__构造函数
self.name = name #属性，成员变量
def sayhi() #方法，动态属性
共有属性和私有属性
__private_attr_name = value
只能内部访问，外部不能访问
def get_heart(self): #对外部提供只读访问接口
return self.__heart
强制访问
r1._Role__heart 强制访问私有属性
公有属性指所有属于我这个类的对象都可以访问
有多少个对象实例化了我都可以访问的属性
在类里直接定义的就是共有属性
继承
当同一类的对象，有共同属性，又有不同属性的时候，搞一个分类，搞2个子类分别继承。
OO开发范式大致为：
划分对象--> 抽象类-->将类组织成为层次化结构（继承和合成）
接下来需要明白的几个问题：
1、什么是面向对象编程？
用类和对象来实现功能、
以前都写成一个函数，赋予这个函数功能，它帮我完成
2、什么是类，什么是对象，又有什么关系？
class 类：
def 函数1（）：
pass
def 函数2（）：
pass
#obj是对象，实例化的过程
obj = 类（）
obj.函数1（）
有时候，函数编程能实现？比较麻烦，用面向对象非常的简单能实现。
3、什么时候适用面向对象？
- 如果多个函数需传入多个共用的参数时
- 根据一个模板创建某些东西
- 应用场景：
4、self 就是调用当前方法的对象
class Foo:
def __init__(self,name):
self.NAME = name
def bar(self):
pass obj1 = Foo() obj1.bar() obj2 = Foo() obj2.bar()
静态字段的使用场景，每个对象中保存相同的东西的时候，可以使用静态字段。
5、封装？
相当于创建了容器，容器用来装东西，比喻成内存里的一块地址，我把一堆东西放在类里面。
可以说成：类中封装了字段和方法
对象中封装了普通字段的值
6、
字段：
普通字段（保存在对象中）
静态字段（保存在类中）
方法：
普通方法（保存在类中，调用者对象）
静态方法（保存在类中，调用者类（无需创建对象），可以有任意个参数）