面向对象的简单理解以及代码

面向对象
面向对象的四大特性：封装 继承 多态 抽象

简单介绍面向对象的四大特性，主要是根据代码理解。

封装

隐藏对象的属性和实现细节，仅对外提供公共的访问方式

好处：
1.将变化隔离
2.便于使用
3.提高复用
4.提高安全性

原则：
1.将不需要向外提供的的数据内容隐藏
2.把属性都隐藏，只提供对外访问的公共接口

多态

多态是指同一事物的不同形态，例如动物可以分为：猫，狗，猪。其中动物是事物，猫狗猪是形态。

抽象
如果说类是在一堆对象中抽取相同的内容，那么抽象类就是在一堆类中抽取相同的内容而来，内容就包括数据属性和相同属性。
抽象的特征是只能被继承，而不能被实例化。

继承
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

python中类的继承分为：单继承和多继承

单继承：

一个子类只继承一个父类。

子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类

多继承：

一个子类继承多个父类。

多继承可以继承多个父类，也继承了所有父类的属性和方法
注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法

多个父类中，不重名的属性和方法，不会有任何影响。

注意！
父类的私有属性和方法不会被继承。

当前类或者父类继承了object类，那么该类称之为新式类，否则称之为经典类。

Python的类可以继承多个类，Python的类如果继承了多个类，那么其寻找方法的方式有两种
当类是经典类时，多继承情况下，会按照深度优先方式查找 py3
当类是新式类时，多继承情况下，会按照广度优先方式查找 py2
简单点说就是：经典类是纵向查找，新式类是横向查找
经典类和新式类的区别就是，在声明类的时候，新式类需要加上object关键字。在python3中默认全是新式类

代码

#  封装 

class Student(object):
    def __init__(self, name, score): 
         self.name = name
         self.score = score

    def print_score(self):
         print("{self.name}'s score is: {self.score}".format(self=self))       
        
    def compare(self,s):
         if self.score>s:
             print("better than %d" %(s))
         elif self.score==s:
             print("equal %d" %(s))
         else:
            print("lower than %d" %(s))
 
May = Student("May",90)        
Peter = Student("Peter",85)        
 
May.print_score()
Peter.print_score()

May.compare(100)
May.compare(90)
May.compare(89)



# 多态


#创建汉堡的父类，并根据父类创建几个子类
class Hamburger:
    def make(self):
        print("您没有正确选择要制作的汉堡，请重新输入")
class FishHamburger(Hamburger):
    def make(self):
        print("您的鱼肉汉堡已经制作好了")
class BeafHamburger(Hamburger):
    def make(self):
        print("您的牛肉汉堡已经制作好了")
class ChickenHamburger(Hamburger):
    def make(self):
        print("您的鸡肉汉堡已经制作好了")
#工厂类，用来判断用户输入的值并创建相应的对象
class HamburgerFactory:
    @classmethod
    def getinput(cls,temp):
        if temp=="1":
            ch=FishHamburger()
        elif temp=="2":
            ch=BeafHamburger()
        elif temp=="3":
            ch=ChickenHamburger()
        else:
            ch=Hamburger()
        return ch
#主方法，通过用户输入的值调用工厂的类方法
while True:
    temp=input("请输入您要制作汉堡的序号，1.鱼肉汉堡，2.牛肉汉堡，3.鸡肉汉堡")
    if temp=="1" or temp=="2" or temp=="3":
        ch=HamburgerFactory.getinput(temp)
        ch.make()
        break
    else:
        ch=Hamburger()
        ch.make()
        continue



# 单继承

class  Master(object):
  def __init__(self):
      self.kongfu="古法煎饼果子配方"

  def  make_cake(self):
      print("按照<%s>只做了一份煎饼果子"%self.kongfu)


class  Prentice(Master):
       pass

laoli=Master()
print(laoli.kongfu)
laoli.make_cake()

damao=Prentice()
print(damao.kongfu)
damao.make_cake()


# 多继承
class Master(object):
   def  __init__(self):
       self.kongfu="古法煎饼果子配方"

   def  make_cake(self):
        print("按照<%s>只做了一份煎饼果子"%self.kongfu)

class  School(object):
     def  __init__(self):
          self.kongfu="现代煎饼果子配方"

     def make_cake(self):
          print("[现代]按照<%s>只做了一份煎饼果子"%self.kongfu)

class Prentice(Master,School):#多继承，继承了多个父类
     def __init__(self):
          self.kongfu="猫氏煎饼果子配方"

     def make_cake(self):
          print("[猫氏]按照<%s>只做了一份煎饼果子"%self.kongfu)

damao=Prentice()
print(damao.kongfu)
damao.make_cake()

print(Prentice.__mro__)


 
# 抽象

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass


class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()