python面向对象实例

---

——王宇阳 总结 （Code_boy）2018年11月16日

 class Person:
     name='xxx'
     age=20

 p=Person()  #p为实例对象
 print(p.name,p.age)
 p.name="yyy"
 p.gender='male'
 print(p.name,p.gender,p.age)
 print(Person.name,Person.age)

#p（实例对象）对值得修改不影响Person类中的内容
Person.age='30'
print(Person.age)
#class Person （类） 对值得修改将该影响Person类中的内容
'''

#访问权限(类的属性)
'''
class Person:   #Person中的name和age公有的
    name = 'james'
    age=20
#在python中规定在前面加两个下划线，就变为私有的
'''
'''
class Person:
    __name = 'james'        #私有的__name
    age = 20

def show(self):     #self >> 自己
        print(self.__name,self.age)     #自己访问自己 正常返回

p=Person ()
p.show()      #需要调用除show（）函数，否则会拒绝class中的show的执行
print(Person.__name)            # 访问类中的私有属性 异常返回
print(p.age)
#出现私有的函数调用时，结果同样如此！私有的函数，元素只能在class中被使用
#常用的方法就是通过调用公有的函数来执行函数内的私有属性的调用
'''

#案例：编写个人信息并建立对象访问属性

 class Person:
     name = 'xxx'
     gender = 'x'
     age = 0

 p=Person()
 print(p.name,p.gender,p.age)
 print(Person.name,Person.gender,Person.age)

 p.name = 'A'
 p.gender = 'Male'
 p.age = 20

 Person.name = 'B'
 Person.gender = 'Female'
 Person.age = 21

 print(p.name,p.gender,p.age)    #p实例对象属性
 print(Person.name,Person.gender,Person.age) #Person类属性

#实例方法
'''

 class Person:
     age = 20
     def show(self):
         print (self.age)

 p.Person()

#实例方法至少有一个参数，一般以名为（self）的变量作为该参数（名称可自定义）
#实例方法通过实例对象调用，例如：p.show()
#如果使用类名称调用，需要人为传递实例参数，例如：Person.show(p)
#实例方法被调用是要向他的第一个参数传递实例对象

 class Person:
     name = 'james'
     age = 12

     def getName(self):
         return self.name

     def getAge(self):
         return self.age

 p=Person()
 print(p.getName(),p.getAge())   #实例属性对象调用
 print(Person.getAge(p)) #类名称调用

  def show(self,s):   #参数传递
         print(self,s)

 p.show('hi')    #'hi'值传递给s
 Person.show(p,'hello')  #hello 给 s'''

#类方法

 class Person:
     age = 20
     @classmethod
     def show(cls):
         print(cls.age)

 p=Person()

#类方法要使用 @classmethod 来修饰，而且第一个参数一般命名为cls（可另定名）
#类方法通常使用类的名称调用，例如：Person.show()
#类方法也可实例方法调用，例如：p.show()
#类方法调用时会向它的第一个参数传递类的名称

 class Person:
     __name = 'james'
     __age = 12

     @classmethod
     def show(self):
         print(self)
         print(self.__name,self.__age)

 Person.show()
 p=Person()
 p.show()'''

#静态方法
'''
定义：

 class Person:
     age = 20
     @staticmethod
     def show():
         print(Person.age)

 p = Person()

#静态变量函数通过@staticmethod修饰
#通常采用类的名称或者实例来调用静态方法，例如：Person.show(),p.show()
#在调用静态函数时不会向函数传递任何参数

 class Person:
     __name = 'james'
     __age = 12

     @staticmethod
     def show():     #静态不带参数
         print(Person.__name)

 p = Person()
 Person.show()
 p.show()

#类、实例、静态方法 不同——Person

 class Person:
     name = 'xxx'
     gender = 'x'
     age = 0
                     #实例方法
     def instanceShow(self):
         print(self.name,self.gender,self.age)

     @classmethod    #类方法
     def classShow(cls):
         print(cls.name,cls.gender,cls.age)

     @staticmethod   #静态方法
     def staticShow():
         print(Person.name,Person.gender,Person.age)

 p=Person()
 p.instanceShow()        #实例方法调用
 Person.classShow()      #类方法调用
 Person.staticShow()     #静态方法调用

实例方法一般用实例对象调用
类方法和静态方法一般用类名称调用

#对象初始化
'''
构造方法（函数）...>完成函数初始化
@ 构造方法__init__(self, ... )在生成对象时调用，
可以用来进行一些初始化操作，不需要显示去调用，系统默认执行
如果用户自己没有定义构造方法，系统就自己执行默认的额构造方法
__init__(self)在生成对象时调用
__del__(self)在释放对象时调用

 class Person:
     def __init__(self,n,a):
         self.name=n
         aelf.age=a

 p=Person('xxx',20)
 print(p.name,p.age)

@ 析构方法__del__(self)在释放对象时调用，可以在里面进行一些释放资源的操作
不需要显示调用

 class Person:
     def __init__(self,n,a):
         self.name = n
         self.age = a
     def __del__(self):
         print('__del__',self.name,self.age)

 p=Person('xxx',20)
 print(p.name,p.age)

 class Person:
     def __init__(self):
         print("__init__",self)
     def __del__(self):
         print("__del__",self)

 p=Person()

#__init__完成对象初始化

 class Person:
     def __init__(self,n,g,a):       #n,g,a 传参单位
         self.name = n
         self.gender = g
         self.age = a

     def show(self):
         print(self.name,self.gender,self.age)

 p=Person('james','male',20)     #p对象确定后，p对象的初始化（n，a，m）就完成了
 p.show()

#python规定：类中只能有一个构造函数
#...__init__中设置默认参数

 class Person:
     def __init__(self,n='',g='male',a=0):
         self.name = n
         self.gender = g
         self.age = a

     def show(self):
         print(self.name,self.gender,self.age)

 a = Person('james')
 b = Person('james','fenmale')
 c = Person('james','male',20)
 a.show()    #结果：james male 0
 b.show()    #结果：james fenmale 0
 c.show()    #结果：james male 20
 # __init__参数中如果设置了默认值，得到新的内容传参后则覆盖原值'''

#案例:日期类 MyDate

 class MyDate:
     __months = [0,31,28,31,30,31,30,31,31,30,31,30,31]
     def __init__(self,y,m,d):
         if (y<0):
             print("Error:无效年份")
         if (m<1 or m>12):
             print("Error:无效月份")
         if (y%400 == 0 or y%4 == 0 and y%100!=0):
             MyDate.__months[2] = 29
         else:
             MyDate.__months[2] = 28

         if d<1 or d>MyDate.__months[m]:
             print("Error:无效日期")
         #日期，月份，年份均合法后，创建类的属性（内容）
         self.year = y
         self.months = m
         self.day = d
     def show(self,end='\n'):
         print("%d-%d-%d"%(self.year,self.months,self.day),end = end)

 p = MyDate(2018,11,19)
 p.show()

#类的继承
#派生与继承：Student：name gender age

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

     def show(self,end='\n'):
         print(self.name,self.gender,self.age)

 class Student(Person):
     def __init__(self,name,gender,age,major,dept):
         Person.__init__(self,name,gender,age)
         self.major = major
         self.dept = dept

     def show(self):
         Person.show(self,'')
         print(self.major,self.dept)

 s = Student('james','male',20,'softwart','computer')
 s.show()

 '''
 结果：
 james male 20
 softwart computer
 '''

#继承类构造函数：

从上面的Strdent类的定义可以看除派生类的构造函数除了要完成自己的新增加的
major,dept属性的初始化外，还要调用基类的Person的构造函数，而且还要显示调用
    即： Person.__init__(self,neme,gender,age)
通过类名称Person直接调用Person的__init__函数，并提供所要的4个函数
继承类时不会自动调用基类的构造函数的，必须显示调用

#属性方法的继承：
如果一个基类中有一个实例方法，在继承类中也可以重新定义完全一样的实例方法。
例如 Person有show方法，在Student中也有一样的show方法，它们是不会混淆的
我们称Student类的show重写了Person的show
—当然，一个基类的实例方法也可以不被重写，派生类会继承这个基类的实例方法
-派生类也可以增加自己的新实例方法

 class Person:
     className = 'Person'    #自己的实例属性
     def __init__(self,name,gender,age):
         self.name = name
         self.gender = gender
         self.age = age

     def show(self,end='\n'):
         print(self.name,self.gender,self.age)

     @classmethod        #类方法修饰
     def classClassName(cls):
         print(cls.className)

     @staticmethod       #静态方法修饰
     def staticClassName():
         print(Person.className)

     def display(self):
         print('display')

 class Student(Person):
     #className = 'Student'
     def __init__(self,name,gender,age,major,dept):
         Person.__init__(self,name,gender,age)
         self.major = major
         self.dept = dept

     def show(self):
         Person.show(self,'')
         print(self.major,self.dept)

 s = Student('A','male',20,'software','computer')
 s.show()
 print(Student.className)    #Student本身没有，则显示上一级（Person）
 Student.classClassName()
 Student.staticClassName()

 s.display() #实例调用

 #结果说明：Student继承了Person的实例、静态、类（属性）方法
 #结果：
 '''
 A male 20
 software computer
 Person
 Person
 Person
 display
 '''

#案例 ：年月日 + 时分秒

 class MyDate:
     __months = [0,31,28,31,30,31,30,31,31,30,31,30,31]
     def __init__(self,y,m,d):
         if (y<0):
             print("Error:无效年份")
         if (m<1 or m>12):
             print("Error:无效月份")
         if (y%400 == 0 or y%4 == 0 and y%100!=0):
             MyDate.__months[2] = 29
         else:
             MyDate.__months[2] = 28

         if d<1 or d>MyDate.__months[m]:
             print("Error:无效日期")
         #日期，月份，年份均合法后，创建类的属性（内容）
         self.year = y
         self.months = m
         self.day = d
     def show(self,end='\n'):
         print("%d-%d-%d"%(self.year,self.months,self.day),end = end)

 class MyDateTime(MyDate):
     def __init__(self,y,mo,d,h,mi,s):
         MyDate.__init__(self,y,mo,d)
         if (h<0  or  h>23  or  mi<0  or  mi>59  or  s<0  or  s>59):
             print("Error:无效时间")
         self.hour = h
         self.minute = mi
         self.second = s

     def show(self):
         MyDate.show(self,'\t')
         print("%d:%d:%d"%(self.hour,self.minute,self.second))

 p = MyDateTime(2018,11,19,21,21,54)
 p.show()

 #结果：    2018-11-19  21:21:54

---