一个初学者的辛酸路程-面向对象-7

前言：

轮对象的重要性

主要内容：

面向对象编程：

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、

字段：

　　普通字段（保存在对象中）

　　静态字段（保存在类中）

方法：

　　普通方法（保存在类中，调用者对象）

　　

　　静态方法（保存在类中，调用者类（无需创建对象），可以有任意个参数）