【总结】面向对象基础（2022.05.06）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45935989/article/details/124618934

文章目录

【总结】面向对象基础（2022.05.06）

【总结】面向对象基础（2022.05.06）

1. 认识类和对象

1.1 类和对象

类：类是对拥有相同功能和相同属性的对象的集合。（是一个抽象的概念）

对象：对象是类的实例（是类的具体表现）

**从生活的角度来看：**如果杯子是类，具体的某个杯子就是对象

用代码来描述清楚这个类到底是拥有那些**相同功能（函数）和那些相同属性（保存数据的变量）**的对象的集合

语法：
class 类名:
    类的说明文档
    类的内容（包括方法和属性）
    
注解：方法   -  定义在类中的函数
     属性  -   定义在类中的变量
   
说明：
class    -   关键字，固定写法
类名  	-   由程序员自己命名，必须符合命名要求和规范
             要求：是标识符；不能是关键字 
             规范：见名知义；采用驼峰式命名（由多个单词组成，单词之间通过首字母大写来区分），第一个字母大写
             	  不使用系统的函数名、类名或者模块
             	  
类的说明文档  -    本质就是多行注释

类的内容     -    由方法和属性组成；
                 方法包括：对象方法、类方法、静态方法三种
                 属性包括：类属性（字段）和对象属性两种

1.2 定义类（创建类）

# 两个简单例子
class Student:
    """学生类"""
    pass  # 类体

class Dog:
    """狗类"""
    pass	# 类体

1.3 创建对象

语法：
对象 = 类名()

# 创建两个学生类的对象
s1 = Student()
s2 = Student()
print(s1,s2)	# <__main__.Student object at 0x000001F3BA805F70> <__main__.Student object at 0x000001F3BA805970>
# 创建一个狗的对象
dog = Dog()
print(dog)		# <__main__.Dog object at 0x000001F3BA8FA8B0>

2. 方法

类中的方法包含三种：对象方法、类方法、静态方法

class A:
    """无意义的类"""
    def func1(self):		
        print('对象方法')

    @classmethod
    def func2(cls):
        print('类方法')

    @staticmethod
    def func3():
        print('静态方法')

2.1 对象方法

怎么定义：直接定义在类中的函数就是对象方法
怎么调用：通过对象来调用 - *对象.对象方法()*
特点：用对象调用对象方法的时候，参数self不需要传参，系统会自动将当前对象传给self（谁去调用的这个方法当前对象就是谁）

# 创建A的对象(对象方法需要先创建对象)
a1 = A()
# 用对象调用对象方法
a1.func1()

2.2 类方法

怎么定义：定义函数前加 @classmethod 装饰器
怎么调用：通过类来调用 - 类.类方法()
特点：参数cls不需要传参，系统会自动将当前类传给cls

# 用类调用类方法
A.func2()

2.3 静态方法

怎么定义：定义函数前加 @staticmethod 装饰器
怎么调用：通过类来调用 - 类.静态方法()
特点：没有特点

# 用类调用静态方法
A.func3()

2.4 类函数中的参数

和普通函数传参方法一致

class B:
    def func1(self, x, y=10):
        print(f'x:{x}, y:{y}')

    @classmethod
    def func2(cls,x,*,y,z):
        print(f'x:{x}, y:{y}, z:{z}')

    @staticmethod
    def func3(x,y):
        print(x,y)
# 用对象调用        
b = B()
b.func1(100)
b.func1(100,200)
b.func1(x=11 ,y=12)
#用类调用
B.func2(10,y=20,z=30)

2.5 构造函数和`init`方法

构造函数

名字和类名一样，专门用来创建对象的函数就是构造函数，python中创建类的时候系统会自动为我们创建这个类的构造函数。

# 如上例
b = B()

2）__init__方法

当通过类创建对象的时候，类中__init__方法会自动调用(每次通过类创建对象的时候，类中的__init__都会被自动调用)

看例子：

class Student:
    def __init__(self):
        print('init方法')
        
#创建对象时直接打印结果
stu1 = Student()        # 结果：init方法
stu2 = Student()        # 结果：init方法

通过类创建对象的时候需不需要参数，需要几个参数，由这个类中的__init__决定。（看__init__除了self以外有没有额外的参数）

class Dog:
    def __init__(self, x, y):
        print('init方法：',x,y)
        
# 创建两个对象，传入参数
dog1 = Dog(1,2)
dog2 = Dog(x=100,y=200)

3. 属性

3.1 类属性

1）怎么定义：直接在类中定义一个变量,这个变量就是类属性
2）怎么使用：通过类来使用 - 类.类属性
3）什么时候用：属性值不会因为对象不同而不一样就将这个属性定义成类属性

3.2 对象属性

1）怎么定义：以'self.属性名=值'的形式定义在__init__方法中
2）怎么使用：通过对象来使用 - 对象.对象属性
3）什么时候用：属性会因为对象不同而不一样就将这个属性定义成对象属性

class A:
    # x是类属性
    x = 100

    #y是对象属性
    def __init__(self, y):
        self.y = 200

# 通过类使用类属性
print(A.x)      # 100
A.x =200
print(A.x)      # 100

# 通过对象使用对象属性
a = A()
print(a.y)      # 200
a.y = 300
print(a.y)      # 300


class Circle:
    pi = 3.1415926

    def __init__(self):
        self.r = 0

3.3.`init`方法的扩展

如果类需要对象属性，就需要在类中添加__init__
可以通过在__init__中添加参数来实现创建对象的时候直接给属性赋值的目的

class Person:
    def __init__(self,name,gender='男'):
        self.name = name
        self.gender = gender
        self.age = 0

p1 = Person('小花','女')
p2 = Person('张三')

print(p1.name, p1.gender)    # 小花 女
print(p2.name, p2.gender)   # 张三 男

4. 方法的选择

4.1 选择

如果实现函数的功能需要对象（对象属性）就用对象方法；

如果需要类就用类方法；

如果都不需要就用静态方法。

4.2 对象方法的使用

class Rect:
    def __init__(self,width=0,height=0):
        self.width = width
        self.height = height

    # 在实现对象方法的功能的时候如果需要的数据是对象相关数据，那么这个数据就有self来提供。
    def area(self):
        return self.width * self.height


r1 = Rect(10,20)
r2 = Rect(5,8)
print(r1.area())    # 200
print(r2.area())    # 40


# 练习：定义一个圆类，拥有属性半径和圆周率，拥有方法：求面积和求周长
class Circle:
    # 类属性
    pi = 3.1415926

    def __init__(self, r):
        self.r = r

    def area(self):
        # 这个类的对象能做的事情，self都可以做
        return Circle.pi * self.r**2

    def perimeter(self):
        return 2 * Circle.pi * self.r


c1 = Circle(1)
c2 = Circle(10)
print(c1.area(), c1.perimeter())        # 3.1415926 6.2831852
print(c2.area(), c2.perimeter())        # 314.15926 62.831852

        # 这个类的对象能做的事情，self都可以做
        return Circle.pi * self.r**2

    def perimeter(self):
        return 2 * Circle.pi * self.r


c1 = Circle(1)
c2 = Circle(10)
print(c1.area(), c1.perimeter())        # 3.1415926 6.2831852
print(c2.area(), c2.perimeter())        # 314.15926 62.831852