# 定义一个学生类
class Student:
"""学生类"""
pass
class Student:
"""学生类"""
def study(self, course_name):
print(f'学生正在学习{course_name}')
def sleep(self):
print(f'学生正在睡觉')
# 创建实例对象
s1 = Student()
# 方式一：对象.方法
s1.sleep()
# 学生正在睡觉
s1.study('Python')
# 学生正在学习Python程序设计
# 方式二:类.方法（参数1，参数2）
# 参数1：接收消息的对象，参数2：你要发的消息。
Student.study(s1, 'Python')
# 学生正在学习Python程序设计
class Student:
"""学生类"""
# 初始化方法
def __init__(self, name, age):
self.name = name
self.age = age
def study(self, course_name):
print(f'{self.name}正在学习{course_name}')
def sleep(self):
print(f'{self.name}正在睡觉')
# 创建实例对象
s1 = Student('是靖不是静', 22)
s1.study('Python')
# 是靖不是静正在学习Python
s1.sleep()
# 是靖不是静正在睡觉
# 案例：传入三条边，判断能否构成三角形，并且计算出三角形的面积和周长
class Triangle:
"""三角形类"""
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
# 要在实例化之前先判断三条边能否组成三角形
# 定义类方法（装饰器）
# 语法糖@
# @classmethod
# def is_valid(cls, a, b, c):
# return a + b > c and a + c > b and b + c > a
# 这里静态方法和类方法实现的效果是一样的
# 定义静态方法
@staticmethod
def is_valid(a, b, c):
return a + b > c and a + c > b and b + c > a
# 对象方法
def perimter(self):
"""计算三角形周长"""
return f'周长：{self.a + self.b + self.c}'
# 对象方法
def area(self):
"""计算三角形面积"""
# 海伦公式（秦九韶公式）:根据三条边计算面积
p = (self.a + self.b + self.c) / 2
return f'面积：{(p * (p - self.a) * (p - self.b) * (p - self.c)) ** 0.5}'
a, b, c = 1, 1, 5
# 这里先用类方法或者静态方法去判断三条边是否能组成三角形，如果可以再创建实例对象
if Triangle.is_valid(a, b, c) == True:
t1 = Triangle(a, b, c)
print(t1.perimter())
print(t1.area())
else:
print('三条边不能组成三角形')
# 三条边不能组成三角形
# 如果是a, b, c = 3, 4, 5则输出
# 周长：12
# 面积：6.0
from abc import abstractmethod, ABC
# Employee 类是一个抽象类，其中定义了一个抽象方法 get_salary，表示获取员工工资的接口。
# 抽象类不能被实例化，而是用于定义其他类的共同接口。
class Employee(ABC):
"""员工（抽象类）"""
# 初始化方法
def __init__(self, name):
self.name = name
# @abstractmethod被用于标记Employee类中的get_salary方法（Python中用于定义抽象方法的装饰器）
# 这表示Employee类是一个抽象类，并且所有继承自Employee的子类都必须实现这个get_salary方法
# 否则会导致子类无法实例化。
@abstractmethod
def get_salary(self):
pass
# Manager类继承自Employee类，实现了get_salary方法。
# 部门经理的工资是固定的，为15000元。
class Manager(Employee):
"""部门经理"""
def get_salary(self):
return 15000
# Programmer类也继承自Employee类，但它在构造函数中添加了一个属性working_hour表示工作小时数。
class Programmer(Employee):
"""程序员"""
def __init__(self, name):
# 这里的super().__init__(name)表示调用父类Employee的构造函数，并传递name参数进行初始化。
# 这样做的好处是，子类可以在自己的构造函数中执行一些特定于子类的初始化操作，而同时确保父类的初始化也得到了执行。
super().__init__(name)
self.working_hour = 0
# get_salary方法计算工资根据工作小时数。
def get_salary(self):
return 200 * self.working_hour
# Salesman类类似，但它有一个属性sales表示销售额，工资计算中包括固定部分和销售提成
class Salesman(Employee):
"""销售员"""
def __init__(self, name):
super().__init__(name)
self.sales = 0
def get_salary(self):
return 2000 + self.sales * 0.05
def main():
# 员工数据
emps = [Manager('曹操'), Manager('刘备'), Programmer('荀彧'),
Salesman('典韦'), Salesman('张飞'), Programmer('庞统'),
Salesman('关羽')]
# 遍历整个数据列表拿到每个员工
for emp in emps:
# 判断员工的类型，如果是程序员则要输入一个工作时间
if isinstance(emp, Programmer):
emp.working_hour = int(input(f'输入{emp.name}本月工作时间: '))
# 判断是否为销售员，如果是则输入销售额
elif isinstance(emp, Salesman):
emp.sales = int(input(f'输入{emp.name}本月销售额: '))
# 其他的都是部门经理直接输出
print(f'{emp.name}: {emp.get_salary():.2f}元')
if __name__ == '__main__':
main()
# 曹操: 15000.00元
# 刘备: 15000.00元
# 输入荀彧本月工作时间: 180
# 荀彧: 36000.00元
# 输入典韦本月销售额: 50000
# 典韦: 4500.00元
# 输入张飞本月销售额: 60000
# 张飞: 5000.00元
# 输入庞统本月工作时间: 200
# 庞统: 40000.00元
# 输入关羽本月销售额: 3000
# 关羽: 2150.00元
面向对象编程的优点包括代码的重用性、可维护性、灵活性和抽象能力。通过使用类和对象，程序可以更自然地模拟真实世界中的问题，并更容易理解和扩展，在解决一些大型项目或者比较困难的问题时使用，具体问题具体分析，简单的问题是不推荐使用面向对象编程进行解决的。