新濠天地 > c语言 > 一套流水生产线或许流程正是来化解贰个标题,

原标题:一套流水生产线或许流程正是来化解贰个标题,

浏览次数:114 时间:2019-09-20

一、面向对象

Python之面向对象计算,python面向对象

一、面向对象

   1、面向进度

       a、优点:极大的下跌了写程序的复杂度,只供给顺着试行的手续,堆成堆代码就能够

       b、瑕玷:一套流水生产线或然流程便是来化解三个标题,代码就是牵一发而萨格勒布全身

   2、面向对象

       a、优点:化解程序的扩大性,对某多少个对象单独修改,会立即反应到一切种类中

       b、短处:可控性差,无法向面向过程的前后相继设计流水生产线式的能够很精准的揣测难题的管理流程与结果,面向对象的次序一旦开首就有目的之间的交互消除难题。

   3、 类:具备同等特征的一类东西(人、狗、孟加拉虎)

   4、对象/实例:具体的某贰个东西(隔壁阿花、楼下旺财)

   5、实例化:类——>对象的长河

   6、 在python中,用变量表示特征,用函数表示技巧,由此具备同等特征和本领的一类东西就是‘类’,

   7、对象是则是这一类东西中实际的四个

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

class 类名:
    类属性 = None
    def __init__(self,对象属性):
        self.对象属性 = 对象属性

    def 方法名(self):
        pass

实例 = 类名(10)
实例.方法名()

    8、类的二种意义:属性援用和实例化

    9、属性援引(类名.属性)

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

    10、例化:类名加括号正是实例化,会自动触发__init__函数的周转,能够用它来为各类实例定制本身的特征

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

    11、

类名
    类名.类属性
   类名.方法名

实例 = 类名(参数,参数)  #实例就是对象

实例
    实例.方法名()
   实例.对象属性

实例增加属性
实例.新的属性名 = 1000
print(实例.新的属性名)

   12、关于self

self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字.

对象/实例只有一种作用:属性引用

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                  #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

dir(类) #返回类中的所有名字列表
isinstance(对象,类) #判断对象是否为类的实例
print(Person.__dict__) # 返回一个字典 key是属性名,value是属性值
print(Person.__module__)  #person类所在的模块
print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名

     13、类命名空间与指标、实例的命名空间

           a、常见三个类就能够创建三个类的名称空间,用来积累类中定义的拥盛名字,这个名字改成类的质量

           b、而类有二种属性:静态属性和动态属性

  •  静态属性正是平昔在类中定义的变量
  • 动态属性正是概念在类中的方法

创造二个目的/实例就能够创设三个对象/实例的称号空间,寄存对象/实例的名字,称为对象/实例的质量

姿容对象的整合用法:

组合指的是,在三个类中以其它二个类的目标作为数据属性,称为类的组

列子:

图片 1

from  math  import pi
class Circular:
    def __init__(self,radius):
        self.radius=radius
    def area(self):
        return self.radius **2 * pi
    def perimeter(self):
        return 2 * self.radius * pi
circu=Circular(10)
print(circu.area())
print(circu.perimeter())

圆的周长与面积

     14、面向对象的三大特征

           a、继承

class Animal:      #父类  基类  超类
    def __init__(self,name,life_value,aggr):
        self.name = name
        self.life_value = life_value
        self.aggr = aggr


class Person(Animal):  #子类  派生类
    pass

class Dog(Animal): #子类  派生类
    pass

egg = Person('egon',1000,50)
print(egg.name)
print(egg.aggr

       

python2
class Dad:  #经典类
class Dag(object)  #新式类

python3
class Dad  ==  class Dag(object) #新式类

              1、承接的语法

 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

继承、抽象、派生
继承 是从大范围到小范围
抽象 小范围到大范围
派生 就是在父类的基础上又产生子类——派生类
        父类里没有的 但子类有的 ——派生方法
        派生属性
方法的重写
    父类里有的方法,在子类里重新实现

 

              2、承继的三种用途:                

                  b:承继基类的不二秘籍,并且做出自个儿的改造只怕扩充(代码重用)***  ***

                  a:注脚有些子类包容于某基类,定义贰个接口类Interface,接口类中定义

                         ** 了部分接口名(正是函数名)且未有完结接口的功能,子类继承袭口类,并且完毕接口中的功用**

           b、封装

                  1、优点:

                              a、将转移隔离

                              b、封装使用

                              c、进步复用性

                              d、提升安全性

                  2、封装原则:

                              a、将无需对外提供的内容都掩盖起来

                              b、把品质都隐敝起来提供公共措施对其访谈

                  3、私有变量和个人方法

                              a、在python中用双写道的先导的的章程降属性掩饰起来(设置个人的)

property属性

property是一种卓殊的天性,访谈它时会实施一段作用(函数)然后再次回到值

  

           c、多态:”多态指的是一类东西有五种样子(举个例子:老师.下课铃响了(),学生.下课铃响了(),老师实行的是下班操作,学生施行的是放学操作,就算双方音讯一点差异也未有于,不过实行的成效分化)

                   多态指的是:一类东西有五种动静

python自带多态:

  多态:同一类事物的多种状态

  python里处处都是多态,只是我们一般发现不了

  操作的时候不需要关心这个对象的数据类型,你只要用就行了

 

    15、反射     

        1、 反射:能够用字符串的措施去做客对象的习性,调用对象的艺术(然而不可能去访谈方法),python中任何皆对象,都能够行使反射。

        2、反射有八种办法:

               hasattr:hasattr(object,name)剖断八个对象是还是不是有name属性或许name方法。有就回来True,未有就回去False

              getattr:获取对象的习性大概措施,假诺存在则打字与印刷出来。hasattr和getattr配套使用

                 需求静心的是,倘使回到的是目标的章程,再次来到出来的是指标的内部存款和储蓄器地址,假如急需周转那几个办法,能够在末端增加一对()

               setattr:给目的的属性赋值,若属性不设有,先创建后赋值

               delattr:删除该对象钦定的三个属性

          a、内置方法:isinstance和issubclass

               isinstance(obj,cls)检查是否obj是还是不是是类 cls 的对象

class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))

        b、内置方法:issubclass(sub, super)检查sub类是不是是 super 类的派生类 

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

 

       c、python面向对象中的反射:通过字符串的花样操作对象相关的个性,python中全数事物都是指标(都能够用反射)

检查是否含有某属性---hasattr 返回布尔值
获取属性---getattr   没有就会报错
设置属性---setattr
删除属性---delattr

       d、内置方法:__del__

析构方法,当对象在内部存款和储蓄器中被释放时,自动触发实践。

注:此办法一般不要定义,因为Python是一门高档语言,程序猿在动用时没有须求关切内部存款和储蓄器的分配和假释,因为此工作都以付诸Python解释器来实施,所以,析构函数的调用是由解释器在扩充垃圾回收时自动触发实践的。

class Foo:
    def __del__(self):
        print('fgs')
f=Foo()
print(123)
print(123)
del f
print(123)
print(123)
print(123)

 

     e、内置方法:item系列

   1、面向进度

__getitem____setitem____delitem__

    __new__

class A:
    def __init__(self):  #有一个方法在帮你创造self
        print('in init function')
        self.x=1
    def __new__(cls, *args, **kwargs):
        print('in init funct')
        return object.__new__(A,*args,**kwargs)
a=A()

     f、__str__和__repr__更换目标的字符串呈现

图片 2

class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4     def __repr__(self):
 5         return 'obj in str'  #这里只能是return
 6     # def __str__(self):
 7     #     return '%s obj in str'%self.name
 8 f = Foo('egon')
 9 print(f)  #优先执行__str__里面的内容
10 # 那么你是不是据地__repr__没用呢?
11 # print('%s'%f)  #执行的是__str__里面的返回值
12 # print('%r'%f)  #执行的是__repr__里面的返回值
13 print('==============')
14 print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
15 print(repr(f))
16 #1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
17 # 2.当__str__没有被实现的时候,就会调用__repr__方法
18 # 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
19 # 4.不管是在字符串格式化的时候还是在打印对象的时候,
20 # __repr__方法都可以作为__str__方法的替补,但反之则不行
21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__

__str__,__repr__

    15、内置方法

           a、静态方法和类措施

               1、类方式:有个私下认可参数cls,並且能够直接用类名去调用,能够与类属性交互(约等于能够运用类属性)

               2、静态方法:让类里的点子直接被类调用,如同符合规律调用函数一样

           b、类格局和静态方法的同样点:都能够直接被类调用,无需实例化

           c、类措施和静态方法的分化点:

          类方法必得有贰个cls参数表示那一个类,能够运用类属性

           静态方法不须求参数

           d、绑定方法:分为普通方法和类方式

     普通方法:暗中认可有四个self对象传进来,况兼只可以被对象调用-------绑定到目的

     类方法:默许有二个cls对象传进来,而且能够被类和目标(不引入)调用-----绑定到类

            e、非绑定方法:静态方法:未有安装暗许参数,而且能够被类和对象(不引入)调用-----非绑定

    16、接口类与抽象类

             a、 接口类:(在抽象类的功底上)

         在python中,暗许是未曾接口类的           

                    接口类无法被实例化(要是实例化会报错)

          接口类中的方法无法被完结

接口也就是做约束,让下面的类的方法都按照接口类中给出的方法去定义。如果接口类里面有的方法类里面没有,那么那个类就不能被实例化。(字面理解)

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

           b、抽象类

在python中,默认是有的

    父类的方法,子类必须实现

    抽象类(父类)的方法可以被实现

抽象类和接口类的区别:接口类不能实现方法,抽象类可以实现方法里面的内容

抽象类和接口类的相同点:都是用来做约束的,都不能被实例化

抽象类和接口类的使用:

  当几个子类的父类有相同的功能需要被实现的时候就用抽象类

  当几个子类有相同的功能,但是实现各不相同的时候就用接口类

 

一、面向对象 1、面向过程a、优点:非常大的骤降了写程序的复杂度,只需求顺着实践的步调,堆放代...

       a、优点:非常大的降落了写程序的复杂度,只必要顺着执行的步子,堆集代码就能够

       b、劣势:一套流水生产线可能流程正是来消除叁个标题,代码正是牵一发而北京全身

   2、面向对象

       a、优点:消除程序的扩张性,对某三个目的单独修改,会及时反应到一切系统中

       b、瑕疵:可控性差,不可能向面向过程的前后相继设计流水生产线式的能够很精准的前瞻难点的拍卖流程与结果,面向对象的次序一旦最初就有目的之间的互相消除问题。

   3、 类:具有同等特征的一类东西(人、狗、华南虎)

   4、对象/实例:具体的某一个东西(隔壁阿花、楼下旺财)

   5、实例化:类——>对象的进度

   6、 在python中,用变量表示特征,用函数表示本事,因此具备同等特征和手艺的一类东西就是‘类’,

   7、对象是则是这一类东西中切实的三个

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法,也叫动态属性
        print("person is walking...")

class 类名:
    类属性 = None
    def __init__(self,对象属性):
        self.对象属性 = 对象属性

    def 方法名(self):
        pass

实例 = 类名(10)
实例.方法名()

    8、类的两种功能:属性引用和实例化

    9、属性援用(类名.属性)

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

    10、例化:类名加括号正是实例化,会自动触发__init__函数的运维,能够用它来为种种实例定制本人的表征

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;

    def walk(self):  #人都可以走路,也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法,注意,这里不是在调用

    11、

类名
    类名.类属性
   类名.方法名

实例 = 类名(参数,参数)  #实例就是对象

实例
    实例.方法名()
   实例.对象属性

实例增加属性
实例.新的属性名 = 1000
print(实例.新的属性名)

   12、关于self

self:在实例化时自动将对象/实例本身传给__init__的第一个参数,你也可以给他起个别的名字.

对象/实例只有一种作用:属性引用

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例,代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类,相当于调用了__init__方法
                  #括号里传参数,参数不需要传self,其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性,直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可

dir(类) #返回类中的所有名字列表
isinstance(对象,类) #判断对象是否为类的实例
print(Person.__dict__) # 返回一个字典 key是属性名,value是属性值
print(Person.__module__)  #person类所在的模块
print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名

     13、类命名空间与目的、实例的命名空间

           a、常见一个类就会创设一个类的名称空间,用来储存类中定义的具有名字,那些名字改成类的性质

           b、而类有二种属性:静态属性和动态属性

  •  静态属性就是一直在类中定义的变量
  • 动态属性就是概念在类中的方法

制造三个指标/实例就能够创制叁个对象/实例的称号空间,存放对象/实例的名字,称为对象/实例的性质

姿容对象的重组用法:

重组指的是,在一个类中以另外贰个类的目的作为数据属性,称为类的组

列子:

图片 3图片 4

from  math  import pi
class Circular:
    def __init__(self,radius):
        self.radius=radius
    def area(self):
        return self.radius **2 * pi
    def perimeter(self):
        return 2 * self.radius * pi
circu=Circular(10)
print(circu.area())
print(circu.perimeter())

圆的周长与面积

     14、面向对象的三大特征

           a、继承

class Animal:      #父类  基类  超类
    def __init__(self,name,life_value,aggr):
        self.name = name
        self.life_value = life_value
        self.aggr = aggr


class Person(Animal):  #子类  派生类
    pass

class Dog(Animal): #子类  派生类
    pass

egg = Person('egon',1000,50)
print(egg.name)
print(egg.aggr

       

python2
class Dad:  #经典类
class Dag(object)  #新式类

python3
class Dad  ==  class Dag(object) #新式类

              1、承继的语法

 class 类名(父类名):
      想在子类中实现调用父类的方法
      在类内 ——super(子类名,self).方法名()
      在类外面 ——super(子类名,对象名).方法名()
      如果不指定继承的父类,默认继承object
      子类可以使用父类的所有属性和方法
      如果子类有自己的方法就执行自己的的
      如果是子类没有的方法就执行父类的
      如果子类父类都没有这个方法就报错

继承、抽象、派生
继承 是从大范围到小范围
抽象 小范围到大范围
派生 就是在父类的基础上又产生子类——派生类
        父类里没有的 但子类有的 ——派生方法
        派生属性
方法的重写
    父类里有的方法,在子类里重新实现

 

              2、承袭的二种用途:                

                  b:承袭基类的秘籍,而且做出自身的改换或许增添(代码重用)***  ***

                  a:申明有些子类包容于某基类,定义二个接口类Interface,接口类中定义

                         ** 了一些接口名(就是函数名)且未有达成接口的功用,子类承承继口类,並且达成接口中的效能**

           b、封装

                  1、优点:

                              a、将转变隔开分离

                              b、封装使用

                              c、升高复用性

                              d、提升安全性

                  2、封装原则:

                              a、将没有供给对外提供的剧情都遮蔽起来

                              b、把质量都遮掩起来提供公共措施对其访谈

                  3、私有变量和私家方法

                              a、在python中用双写道的发端的的办法降属性遮盖起来(设置个人的)

property属性

property是一种特有的习性,访谈它时会实行一段作用(函数)然后再次来到值

  

           c、多态:”多态指的是一类东西有二种造型(举例:老师.下课铃响了(),学生.下课铃响了(),老师实行的是下班操作,学生施行的是放学操作,即使双方音讯没有差别于,然而实行的功用不一样)

                   多态指的是:一类东西有四种状态

python自带多态:

  多态:同一类事物的多种状态

  python里处处都是多态,只是我们一般发现不了

  操作的时候不需要关心这个对象的数据类型,你只要用就行了

 

    15、反射     

        1、 反射:能够用字符串的办法去寻访对象的性质,调用对象的点子(然则无法去访谈方法),python中总体皆对象,都得以行使反射。

        2、反射有三种方法:

               hasattr:hasattr(object,name)决断三个对象是还是不是有name属性可能name方法。有就重回True,未有就回来False

              getattr:获取对象的质量恐怕措施,即使存在则打印出来。hasattr和getattr配套使用

                 须求潜心的是,假使回到的是目的的办法,重临出来的是目的的内部存款和储蓄器地址,要是急需周转那些法子,能够在后头增添一对()

               setattr:给指标的天性赋值,若属性不真实,先创建后赋值

               delattr:删除该指标内定的一个属性

          a、内置方法:isinstance和issubclass

               isinstance(obj,cls)检查是或不是obj是还是不是是类 cls 的对象

class Foo:
    pass
class Son(Foo):
    pass
s=Son()

print(isinstance(s,Son))

        b、内置方法:issubclass(sub, super)检查sub类是或不是是 super 类的派生类 

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

 

       c、python面向对象中的反射:通过字符串的样式操作对象相关的性质,python中一切事物都以目的(都得以用反射)

检查是否含有某属性---hasattr 返回布尔值
获取属性---getattr   没有就会报错
设置属性---setattr
删除属性---delattr

       d、内置方法:__del__

析构方法,当目的在内部存款和储蓄器中被放出时,自动触发实践。

注:此方法一般不要定义,因为Python是一门高端语言,程序员在动用时没有要求关心内部存款和储蓄器的分红和释放,因为此干活都是提交Python解释器来实施,所以,析构函数的调用是由解释器在开展垃圾回收时自动触发试行的。

class Foo:
    def __del__(self):
        print('fgs')
f=Foo()
print(123)
print(123)
del f
print(123)
print(123)
print(123)

 

     e、内置方法:item系列

__getitem____setitem____delitem__

    __new__

class A:
    def __init__(self):  #有一个方法在帮你创造self
        print('in init function')
        self.x=1
    def __new__(cls, *args, **kwargs):
        print('in init funct')
        return object.__new__(A,*args,**kwargs)
a=A()

     f、__str__和__repr__变动指标的字符串彰显

图片 5图片 6

class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4     def __repr__(self):
 5         return 'obj in str'  #这里只能是return
 6     # def __str__(self):
 7     #     return '%s obj in str'%self.name
 8 f = Foo('egon')
 9 print(f)  #优先执行__str__里面的内容
10 # 那么你是不是据地__repr__没用呢?
11 # print('%s'%f)  #执行的是__str__里面的返回值
12 # print('%r'%f)  #执行的是__repr__里面的返回值
13 print('==============')
14 print(str(f))  #当执行str(f)时,会去找__str__这个方法,如果找不到的时候,__repr__这个方法就给替补了
15 print(repr(f))
16 #1.当打印一个对象的时候,如果实现了__str__方法,打印__str__中的返回值
17 # 2.当__str__没有被实现的时候,就会调用__repr__方法
18 # 3.但是当你用字符串格式化的时候,%s和%r会分别调用__str__和__repr__方法
19 # 4.不管是在字符串格式化的时候还是在打印对象的时候,
20 # __repr__方法都可以作为__str__方法的替补,但反之则不行
21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个:先实现__repr__

__str__,__repr__

    15、内置方法

           a、静态方法和类情势

               1、类情势:有个私下认可参数cls,並且能够直接用类名去调用,能够与类属性交互(也正是足以应用类属性)

               2、静态方法:让类里的艺术直接被类调用,就好像平常调用函数同样

           b、类格局和静态方法的一样点:都得以平昔被类调用,无需实例化

           c、类情势和静态方法的分歧点:

          类方法必得有三个cls参数表示那些类,能够应用类属性

           静态方法没有要求参数

           d、绑定方法:分为普通方法和类情势

     普通方法:暗许有三个self对象传进来,而且只好被对象调用-------绑定到指标

     类方法:暗许有三个cls对象传进来,并且能够被类和对象(不引入)调用-----绑定到类

            e、非绑定方法:静态方法:未有设置暗中认可参数,况兼能够被类和对象(不推荐)调用-----非绑定

    16、接口类与抽象类

             a、 接口类:(在抽象类的底子上)

         在python中,暗中同意是绝非接口类的           

                    接口类无法被实例化(假如实例化会报错)

          接口类中的方法不可能被实现

接口也就是做约束,让下面的类的方法都按照接口类中给出的方法去定义。如果接口类里面有的方法类里面没有,那么那个类就不能被实例化。(字面理解)

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

           b、抽象类

在python中,默认是有的

    父类的方法,子类必须实现

    抽象类(父类)的方法可以被实现

抽象类和接口类的区别:接口类不能实现方法,抽象类可以实现方法里面的内容

抽象类和接口类的相同点:都是用来做约束的,都不能被实例化

抽象类和接口类的使用:

  当几个子类的父类有相同的功能需要被实现的时候就用抽象类

  当几个子类有相同的功能,但是实现各不相同的时候就用接口类

 

本文由新濠天地发布于c语言,转载请注明出处:一套流水生产线或许流程正是来化解贰个标题,

关键词:

上一篇:新濠天地打开之后看了一下,NET平台的核心内容

下一篇:【新濠天地】是一种软件中断,SIGKILL   终止进