OOP-类的基础

OOP

• 思想
  • 以模块化思想解决工程问题
  • 面向过程 vs 面向对象
  • 由面向过程转向面向对象
  • 例子，开一个学校，叫编程学院，主讲少儿编程：
    • 讲师
    • 学生
    • 班主任
    • 教室
    • 学校
• 常用名词
  • OO:面向对象
  • OOA：分析
  • OOD：设计
  • OOP：编程
  • OOI：实现
  • OOA->OOD->OOI
• 类 vs 对象
  • 类：抽象，描述的一个集合，侧重于共性
  • 对象：具象，描述的是个体
• 类的内容：
  • 动作，函数
  • 属性，变量
• is-a
• 定义类：class关键字
• 类命名：
  • 遵循大驼峰
  • 第一个字母大写

## 定义学生类，和几个学生

class Student():
    # 此处定义一个空类
    # pass是关键字，表示占位用的，无意义
    pass

class StudentNoPass():
    pass

# 定义一个对象
xb = Student()

#
class PythonStudent():
    name = "NoOne"
    age = 18
    course = "Python"
    '''
    定义类中的函数
    一般需要有self关键字
    其余跟普通函数基本相同
    '''
    def giveMeMoney(self):
        print("show me the money")
        return None
    
xb = PythonStudent()
print(xb.name)
print(xb.age)
print(xb.course)

NoOne
18
Python

类的属性

#  类的列子
# 注意类的定义
class Student():
    name = "wcp"
    age = 19
    
    def sayHi(self):
        print("爱编程，爱生活")
        return None
    

# 实列化
# 中文能否当作变量名称
古铜 = Student()

print(古铜)

<__main__.Student object at 0x00000167ABD9C4A8>

self

• self可以用别的名称
• self不是关键字
• 作用是指代本身

class A():
    name = "caipo"
    age = 18
    
    # 注意say的写法，参数有一个self
    def say(self):
        self.name = "aaa"
        self.age = 200
        
# 此案例说明
# 类实例的属性和其对象的实例的属性在不对对象的实例属性赋值的前提下
# 指向同一个变量

# 此时，A称为类实例
print(A.name)
print(A.age)
# id可以鉴别一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))

print("*"*20)
a = A()

print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

caipo
18
1544777061632
140715847751008
********************
caipo
18
1544777061632
140715847751008

# 此时，A称为类实例
print(A.name)
print(A.age)
# id可以鉴别一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))

print("*"*20)
a = A()
# 查看A内所有属性
print(A.__dict__)
print(a.__dict__)

a.name = "aaa"
a.age = 20
print(a.__dict__)

print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

cp
18
1544746067200
140715847751008
********************
{'__module__': '__main__', 'name': 'cp', 'age': 18, '__init__': <function A.__init__ at 0x00000167ABE39A60>, 'say': <function A.say at 0x00000167ABE39F28>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
{'name': 'aaaa', 'age': 20}
{'name': 'aaa', 'age': 20}
aaa
20
1544777061744
140715847751072

class Student():
    name = "cp"
    age = 18
    
    # 注意say的写法，参数有一个self
    def say(self):
        self.name = "aaaa"
        self.age = 20
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))
        
    def sayAgain(this):
        print("My name is {0}".format(this.name))
        print("My age is {0}".format(this.age))
        
yy = Student()
yy.say()
yy.sayAgain()

My name is aaaa
My age is 20
My name is aaaa
My age is 20

class Teacher():
    name = "cp"
    age = 18
    
    def say(self):
        self.name = "aaaa"
        self.age = 20
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))
        
    def sayAgain():
        print(__class__.name)
        print(__class__.age)
        print("Hello,nice to see you again")
        
t = Teacher()
t.say()
# 错误案例
# t.sayAgain()

# 调用绑定类函数使用类名
Teacher.sayAgain()

My name is aaaa
My age is 20
cp
18
Hello,nice to see you again

# self举例
# 实例调用函数
class Student():
    name = "wcp"
    age = 19
    
    def sayHi(self):
        print("爱编程，爱生活")
        return None
    def sayHi(mimi):
        print("爱咪咪，爱生活")
        return None

guton = Student()
# 调用sayHi没有输入参数
# 因为默认实例作为第一个参数传入
guton.sayHi()

爱咪咪，爱生活

a = 11
# 参看sayHi的定义，说明self的名称可更改
guton.sayHi()

爱咪咪，爱生活

# 关于self的案例

class A():
    name = "cp"
    age = 18
    def __init__(self):
        self.name = "aaaa"
        self.age = 20
        
    def say(self):
        print(self.name)
        print(self.age)
        
class B():
    name = "bbb"
    age = 19
    
a = A()
# 此时，系统会默认把a作为第一个参数传入函数
a.say()

# 此时，self被a替换
A.say(a)
# 同样可以把A作为参数传入
A.say(A)

# 此时，传入的是类实例B，因为B具有name和age属性，所以不会报错
A.say(B)

# 以上代码，利用了鸭子模型

aaaa
20
aaaa
20
cp
18
bbb
19

类的变量作用域的问题

• 类变量：属于类自己的变量
• 实例变量：属于实例的变量
• 访问实例的属性，如果实例没有定义属性，则自动访问类的属性，如果类也没用定义，报错

# 注意类的定义
class Student():
    # name，age是类的变量
    # 注意类的变量定义位置和方法
    # 不需要前缀
    name = "wcp"
    age = 19
    
    def sayHi(self):
        print("My name is {},I am {} years old".format(self.name,self.age))
        return None

# 以下案例说明，实例变量可以借用类的变量
rj = Student()
rj.sayHi()

My name is wcp,I am 19 years old

# 注意类的定义
class Student2():
    # name，age是类的变量
    # 注意类的变量定义位置和方法
    # 不需要前缀
    name = "wcp"
    age = 19
    
    def sayHi(self,n,a):
        self.name = n
        self.age = a
        print("My name is {},I am {} years old".format(self.name,self.age))
        return None

# 以下案例说明，实例变量可以借用类的变量
rj = Student2()
#注意观察下面语句打开和关闭后的区别
#rj.sayHi("rj",17)
print("My name is {},I am {} years old".format(Student2.name,Student2.age))
print("My name is {},I am {} years old".format(rj.name,rj.age))

# 如果访问实例的属性没有定义，则自动访问类的属性
# 如果类也没有定义，报错

My name is wcp,I am 19 years old
My name is wcp,I am 19 years old

访问类的属性

• 在类里面如果强制访问类的属性，则需要使用 class ,（注意前后两个下划线）
• 类方法：
  • 定义类的方法的时候，没有self参数
  • 类的方法中只允许使用类的内容
  • 两种用法
    • ClassName
    • class

# 注意类的定义
class Student():
    # name，age是类的变量
    # 注意类的变量定义位置和方法
    # 不需要前缀
    name = "wcp"
    age = 19
    
    def sayHi(self,n,a):
        self.name = n
        self.age = a
        
        print("My name is {},I am {} years old".format(self.name,self.age))
        return None
    
    # sayHai是类的方法
    # 如何访问类的变量
    def sos():
        # 类的方法中不允许访问实例的任何内容
        # 如果访问类的内容，注意两种用法
        print("My name is {},I am {} years old".format(Student.name,__class__.age))
        return None
    
# 体验类的方法
s = Student()
s.sayHi("gt",26)

# 调用类方法的例子
Student.sos()

My name is gt,I am 26 years old
My name is wcp,I am 19 years old

构造函数

• 类在实例化的时候，执行一些基础性的初始化的工作
• 使用特殊的名称和写法
• 在实例化的时候自动执行
• 是在实例化的时候第一个被执行的函数

# 注意类的定义
class Student():
    name = "NoName"
    age = 0
    
    # 构造函数名称固定，写法相对固定
    def __init__(self):
        print("我是构造函数")
    
ej = Student()
print("————————————")
print(ej.name)
print(ej.age)

我是构造函数
————————————
NoName
0