面相对象

面向对象的三大特性：继承、封装、多态



#面向对象的开发语言
#一切皆对象

#面向过程

#面向对象：包含面向过程

#类 ：一个模型，一类东西
#实例 ：通过这个模型造出的东西
#对象 ：实例
#实例化：造实例的过程
#封装 ：就是把零散的代码封装成一个函数或类

#继承 ：就是把父类有的东西，他也有

#多态：一种方法多种实现。

class Student:#经典类（）
    pass
class Student2(object):#新式类(pyth3一般都用这个)
    pass

class BuyCar(object):#定义一个类
    add='昌平'#这就是类变量
    def fourS(self):
        print('这里是4s店')
    def dsj(self):
        print('这里是地税局')
    def cgj(self):
        print('这里是车管局')
    def jgj(self):
        print('这里是交管局')
daliuliu=BuyCar()#实例化
#类名加括号就是对这个类实例化
#实例化后的东西就是 对象 也就是实例 （daliuliu就是对象）
# daliuliu.fourS()
# daliuliu.dsj()

class Person(object):
    def __init__(self,name,sex):#构造函数
        print('这个是名字%s'%name)
        print('这个是性别%s' %sex)
    def cry(self):
        print('哭啦。。。。')
# red=Person('小红','女')
# red.cry()
class Yuebing(): #
    def __del__(self):#析构函数 (当程序走完后再自动执行这个函数)
        print('销毁这个实例')

# bad=Yuebing()
# del bad  #直接将bad这个实例销毁
# red.cry()

class Car(object): #self 代表这个本类对象(实例本身)通过self可以调用这个类下面所有的函数、变量
    def __init__(self,color):
        self.color=color
        self.run()
    def run(self):
        print('跑步哈哈哈')
        print(self.color)
        self.go()
    def go(self):
        print('gogogo')
        
my_car=Car('yellow') #实例化时color传入yellow
my_car.color='blue' #将color改为blue
my_car.run() #运行run 方法

#类变量，实例变量

 1 #类变量：在类里面定义的变量,一般写公共的，不会变的用类变量
 2 #实例变量：在实例化时需要传入的参数
 3 class Student(object):
 4     country='china' #类变量
 5     def __init__(self,name):
 6         self.name=name #实例变量
 7         self.sex='男'
 8         print('%s的国籍是%s'%(self.name,self.country))
 9 xixi=Student('嘻嘻')
10 print(xixi.sex)
11 xixi.sex='不知道'
12 print(xixi.sex)
13 print(Student.country)

#属性方法

 1 #属性方法
 2     #属性方法也是一个实例方法，需要实例后才能使用
 3     #属性方法也可以通过实例方法实现
 4     #如果你使用属性方法时，必须有返回值，并且不能传参
 5         #吧一个方法变成一个变量,实例对象调用时函数名不需要加括号就可以将函数内代码执行
 6 
 7 class Car(object):
 8     def __init__(self,a,b):
 9         self.a=a
10         self.b=b
11     def add(self):
12         return self.a+self.b
13     @property #吧一个方法变成一个变量，实例对象调用时函数名不需要加括号就可以将函数内代码执行
14     def add2(self):
15         return self.a+self.b
16 me=Car(1,2)
17 r=me.add()
18 h=me.add2  #实例对象调用时函数名不需要加括号就可以将函数内代码执行
19 print(r)
20 print(h)

 

#私有变量，私有方法

 1 #方法或变量在前面加上__（两个下划线）就是私有方法或私有变量，只能在类中使用，出了类就不能使用
 2 class My(object):
 3     __car='小汽车'
 4     def __init__(self):
 5         self.__cup='青花瓷' #变量名前加两个下划线__为私有变量，可以在类中随意使用，但不可实例对象使用
 6         print(self.__cup)
 7         print(self.__car)
 8 
 9     def change(self):
10         self.__cup='塑料杯'
11         print('这是修改后的杯子%s'%self.__cup)
12     def __money(self):
13         print('这个函数是个私有函数')
14     def xiaohei(self):
15        self.__money()
16 me=My()
17 me.change()
18 me.xiaohei()
19 # print(My.__cup)
20 # print(me.__cup) #因为__cup私有变量，所以在用实例调用时会报错

 

#各种方法

class My(object):
    country='china'
    __car='小汽车'
    def __init__(self):
        self.__cup='青花瓷' #变量名前加两个下划线__为私有变量，可以在类中随意使用，但不可实例对象使用
        print(self.__cup)
        print(self.__car)

    def change(self):
        self.__cup='塑料杯'
        print('这是修改后的杯子%s'%self.__cup)
    def __money(self):
        print('这个函数是个私有函数')
    def xiaohei(self):
       self.__money()

    @classmethod #类方法不需要实例化，直接用类名加函数名就可以调用
    def hh(cls):
        print('我是类方法')
        print(cls.country)

    @staticmethod
    def daliliu(): #静态方法就是写在类里面的一个普通函数，直接用类名就可以调用
        print('这是静态方法')

    @property  # 属性方法 吧一个方法变成一个变量，实例对象调用时函数名不需要加括号就可以将函数内代码执行
    def cup(self):
        return '将一个函数变成一个变量' + self.country
me=My()
# print(me.country)
# me.change()
# me.xiaohei()
My.hh()  #类方法的调用
My.daliliu() #静态方法的调用
print(me.cup) #属性方法的调用

 

#继承

#当多个东西含有一个共同的特性时，使用继承

class Father(object):
    addr='鲁'
    def __init__(self,name):
        self.name=name
    def work(self):
        print('我的工作是',self.name)
class My(object): #类名后的括号中写另一个类的类名就是继承，可以将这个类下面所有的变量、方法都继承过来
    money='100'
    def me(self):
        print('我是大刘刘')
class Nini(My,Father):#在括号中填写多个类名，就是继承多个类
    pass
#
me=My()
nini=Nini('farm')
me.money='500'  #(修改父类的变量) #继承后父类修改属性或方法不会改变子类继承的原始状态
print(me.money)
print(nini.money)
# nini.work()
# print(me.addr)

class Father(object):
    def money(self):
        print('挣了1000w')
class me(Father):
    def money(self): #重写父类的方法
        print('挣了50元')#

f=Father()
f.money()

 

#修改父类构造函数

#修改父类构造方法：当父类构造方法不能满足时，在父类构造方法的基础上添加新的功能
class Father(object):
    def __init__(self,op):
        print('这个是父类的构造函数',op)
    def make_money(self):
        print('我兜里有一千万')

class Xiaohei(Father):
    def __init__(self,op,name):
        Father.__init__(self,op) #修改父类的构造方法，就是在新的构造方法中调用一下父类的构造方法
        # super(Xiaohei,self).__init__(op) #这个和上面的修改构造方法都可以修改父类的构造方法
        #以上两种修改父类构造方法在Python3中都可使用，但在Python2中就只能使用第一种
        print('这个是小黑的构造函数',name)
        self.name=name
a=Xiaohei('就是帅','大脸')

 

转载于:https://www.cnblogs.com/liushuxian/p/11344877.html