Python实验三：面向对象程序设计

1.定义一个类描述数字时钟

2.定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法

3.定义一个学生类，并通过继承定义一个研究生类，查看多态性展示效果

4.使用@property装饰器和property方法实现属性

5.静态方法和类方法：定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来。和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象。通过使用@staticmethod和@classmethod装饰器完成

6.所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）。使用抽象类完成一下任务：
某公司有三种类型的员工 分别是部门经理、程序员和销售员。需要设计一个工资结算系统，根据提供的员工信息来计算月薪，部门经理的月薪是每月固定15000元；程序员的月薪按本月工作时间计算，每小时150元；销售员的月薪是1200元的底薪加上销售额5%的提成。

from math import sqrt
from time import sleep, time, localtime
from abc import ABCMeta, abstractmethod

"""
# 定义一个类描述数字时钟
使用@property装饰器和property方法实现属性"""


class Clock(object):
    def __init__(self, hour=0, minute=0, second=0):  # 初始化方法
        self.hour = hour
        self.minute = minute
        self.second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    def run(self):  # 走字
        self.second += 1
        if self.second == 60:
            self.second = 0
            self.minute += 1
            if self.minute == 60:
                self.minute = 0
                self.hour += 1
                if self.hour == 24:
                    self.hour = 0

    def show(self):  # 显示
        print("{}:{}:{}".format(self.hour, self.minute, self.second))
        return '%02d:%02d:%02d' % \
               (self.hour, self.minute, self.second)


"""定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法"""

class Point(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        self._y = value

    def move(self, dx, dy):
        self.x += dx;
        self.y += dy;

    def distance_to(self, Point):
        dx = self.x - Point.x
        dy = self.y - Point.y
        return sqrt(dx ** 2 + dy ** 2)

    def __str__(self):
        return '(%s,%s)' % (str(self.x), str(self.y))


"""定义一个学生类，并通过继承定义一个研究生类，查看多态性展示效果"""


class Student(object):

    def __init__(self, Sname, Sno, Sage):
        self.Sno = Sno
        self.Sname = Sname
        self.Sage = Sage

    @property
    def Sno(self):
        return self._Sno

    @Sno.setter
    def Sno(self, sno):
        self._Sno = sno

    @property
    def Sname(self):
        return self._Sname

    @Sname.setter
    def Sname(self, sname):
        self._Sname = sname

    @property
    def Sage(self):
        return self._Sage

    @Sage.setter
    def Sage(self, sage):
        self._Sage = sage

    def __str__(self):
        return '我叫%s,学号是%s,年龄为%s,是一名学生' % (str(self.Sname), str(self.Sno), str(self.Sage))

    def run(self):
        return '我叫%s,学号是%s,年龄为%s,是一名学生' % (str(self.Sname), str(self.Sno), str(self.Sage))


class Gra_student(Student):
    def __init__(self, Sno, Sname, Sage, Skey):
        super().__init__(Sno, Sname, Sage)
        self.Skey = Skey

    def __str__(self):
        return '我叫%s,学号是%s,年龄为%s,是一名研究生' % (str(self.Sname), str(self.Sno), str(self.Sage))


"""静态方法和类方法：定义一个“三角形”类"""


class Triangle(object):
    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self.b) * (half - self._c))


"""
使用抽象类完成一下任务：

某公司有三种类型的员工 分别是部门经理、程序员和销售员
"""


class Employee(object, metaclass=ABCMeta):
    """员工"""

    def __init__(self, name):
        """
        初始化方法
        :param name:
        """
        self._name = name

    @property
    def name(self):
        return self._name

    @abstractmethod
    def get_salary(self):
        """
        获得月薪
        :return:月薪
        """
        pass


class Manager(Employee):
    """部门经理"""

    def get_salary(self):
        return 15000.0


class Programmer(Employee):
    def __init__(self, name, working_hour=0):
        super().__init__(name)
        self.working_hour = working_hour

    @property
    def working_hour(self):
        return self._working_hour

    @working_hour.setter
    def working_hour(self, working_hour):
        self._working_hour = working_hour if working_hour > 0 else 0

    def get_salary(self):
        return 150.0 * self._working_hour


class Salesman(Employee):
    """销售员"""

    def __init__(self, name, sales=0):
        super().__init__(name)
        self._sales = sales

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, value):
        self._sales = value if value > 0 else 0

    def get_salary(self):
        return 1200.0 + self._sales * 0.05


def TestSalary():
    emps = [
        Manager('刘备'), Programmer('诸葛亮'),
        Manager('曹操'), Salesman('荀彧'),
        Salesman('吕布'), Programmer('张辽'),
        Programmer('赵云')
    ]
    for emp in emps:
        if isinstance(emp, Programmer):
            emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
        elif isinstance(emp, Salesman):
            emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
        # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
        print('%s本月工资为: ￥%s元' %
              (emp.name, emp.get_salary()))

def main():
    a, b, c = 3, 4, 5
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        print(t.area())
    else:
        print('无法构成三角形')


def main1():
    clock = Clock.now()
    while True:
        clock.show()
        # print(clock.show())
        sleep(1)
        clock.run()


def main2():
    P1 = Point()
    P2 = Point()
    P1.x = 0
    P1.y = 0
    print(P1.x, P1.y)
    P2.move(-1, -1)
    print(P2)
    print(P1)
    P3 = P1.distance_to(P2)
    print(P3)


def main3():
    s1 = Student('小明', 1001, 13)
    print(s1)
    s2 = Gra_student('小刚', 1002, 21, 'c009')
    print(s2)