python中级12面向对象下

最新推荐文章于 2024-08-21 22:35:36 发布
最新推荐文章于 2024-08-21 22:35:36 发布
阅读量172 收藏 1
点赞数
分类专栏： python 0基础入门 核心语法 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LonelyDragons/article/details/107266118
版权

1 继承简介


继承
1 让类与类之间产生了关系 有了这层关系才有我们后续要说的多态
2 提高了代码的复用性
在创建类的时候 如果省略了父类 则默认父类为object
object  是所有类的父类

class Person():   
    name = ''    # 军人与医生共有的属性
    age = ''


class Doctor():
    name=''
    age=''
    def study(self):
        print('治病救人...')


class soldier():
    name=''
    age=''
    def study(self):
        print('保卫国家...')

●继承是面向对象三大特性之一
●通过继承我们可以使一个类获取到其他类中的属性和方法
●在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
●继承提供了类的复用性。让类与类之间产生了关系。有了这个关系，才有了
多态的特性

#这是一个动物类
class Animal():
    def sleep(self):
        print('动物会睡觉...')


    def run(self):

        print('动物会跑...')

a=Animal()

a.sleep()



动物会睡觉...

#我们想定义一个狗类
#定义一个思路 直接在动物类上面修改 再添加上狗独有的功能
#这样修改起来会比较麻烦 会违反了ocp原则

#第二种思路 创建一个新的类（狗类）
#创建一个新的类比较麻烦 会出现大量的复制粘贴

#三种思路 直接从Animal 类中继承它的属性和方法
#继承是面向对象的三大特征之一
#在定义类的时候 可以在类名后的括号中指定当前类的父类(超类 基类)

#这是一个动物类
class Animal():
    def sleep(self):
        print('动物会睡觉...')


    def run(self):

        print('动物会跑...')

    # 狗看家的方法

class Dog():
    def sleep(self):
        print('狗会睡觉...')


    def run(self):

        print('狗会跑...')

    def speak(self):
        print('汪汪汪...')

#我们想定义一个狗类
#定义一个思路  直接在动物类上面修改 再添加上狗独有的功能
#这样修改起来会比较麻烦 会违反了ocp原则

#第二种思路   创建一个新的类（狗类）
#创建一个新的类比较麻烦  会出现大量的复制粘贴

#三种思路  直接从Animal 类中继承它的属性和方法
#继承是面向对象的三大特征之一
#在定义类的时候 可以在类名后的括号中指定当前类的父类(超类  基类)


class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')

d=Dog()

d.run()
d.speak()

isinstance() 函数 及其一些补充

—描述
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
—语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)
—参数
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
—返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

父类(基类 超类)

例如：先定义一个类叫车，车有以下属性：车体大小、颜色、轮胎、方向盘、品牌、速度、排气量，由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。
如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。
在这里插入图片描述

class Animal():
    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')

d=Dog()

d.run()
d.speak()

r=isinstance(d,Dog)#   r=isinstance(d,Animal)
 				   #   print(r)    	       
print(r)           #   True

  #Dog 继承了Animal d 是Dog(类) 的实例  也是Dog的父类Animal的实例

动物会跑...
汪汪汪...
True

Dog 继承了Animal d 是Dog(类) 的实例 也是Dog的父类Animal的实例
issubclass
●检查一个类是不是另外一个类的子类

class Animal():
    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')

d=Dog()

#检查一个类是不是另外一个类的子类
# issubclass()
print(issubclass(Dog,Animal))#检查Dog是否为Animal 的子类



True

在创建类的时候 如果省略了父类 则默认父类为object
object 是所有类的父类

class Animal():
    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')

d=Dog()

#检查一个类是不是另外一个类的子类
# issubclass()

print(issubclass(Dog,object)) 

True

如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找 如果父类里也没有就会报错(就是找也得找自己最近的)

class Animal():
    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog()

d.run()


#如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找  如果父类里也没有就会报错(就是找也得找自己最近的)

2方法的重写

●如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用
子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
●当我们调用一个对象的方法时：
—会优先去当前对象中寻找是否具有该方法，如果有则直接调用
—如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中
的方法
—如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依
然没有找到就报错了

class A(object):
    def test(self):
        print('A....')

class B(A):
    pass

class C(B):
    pass

c=C() #创建一个C的实例

c.test()


A....

class A(object):
    def test(self):
        print('A....')

class B(A):
    def test(self):
        print('B....')

class C(B):
    pass

c=C() #创建一个C的实例

c.test()


B....

3super（）用法

super()可以动态获取当前类的父类
并且通过super()返回对象调用父类方法时，不需要传递self

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法

class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog()

d.run()


TypeError: __init__() missing 1 required positional argument: 'name'
#TypeError:“name”缺少1个必需的位置参数

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法

class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog('大秋田')

print(d.name)


大秋田

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法

class Dog(Animal):
    pass
    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog('大秋田')

d.name='黑色小天'
print(d.name)


黑色小天

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法

class Dog(Animal):
    def __init__(self,name,age):   #就是Dog的 父类Animal的__init__(self,name)中  如果还有 sex  weight height 我们还得 一个一个加 否则 d.sex='男'  只是单纯的赋值而已

        self._name=name
        self._age=age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog('大秋田')

d.name='黑色小天'
print(d.name)



TypeError: __init__() missing 1 required positional argument: 'age'
#TypeError:“age”缺少1个必需的位置参数

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法

class Dog(Animal):
    def __init__(self,name,age):
        # self._name = name
        #希望可以直接调用父类的init
        Animal.__init__(self,name)   # 说明这个Animal.__init__(self,name)的操作 与上面的 self._name = name 作用一样 若是注释 它   用self._name = name  结果都是一样的 
        self._age=age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog('大秋田',5)

d.name='黑色小天'
print(d.name,d.age)

当然如果有一天狗的父类变成了犬科 犬科的父类还是动物 这样更加细化 但是我们的Animal.init 就写死了 狗---->犬 ---->动物
所以我们希望有一种动态的获取父类的方式

class Animal():
    def __init__(self,name):
        self._name=name


    def sleep(self):
        print('动物会睡觉...')
    def run(self):
        print('动物会跑...')
    @property
    def name(self):
         return self._name
    @name.setter
    def name(self,name):
        self._name=name

#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法  当然如果有一天狗的父类变成了犬科 犬科的父类还是动物 这样更加细化 但是我们的Animal.__init__  就写死了

class Dog(Animal):
    def __init__(self,name,age):
        # self._name = name
        #希望可以直接调用父类的init
        # Animal.__init__(self,name)
        #super() 可以用来获取当前类的父类
        #通过super()不需要传递self
        super().__init__(name) #是这里不需要传递self  # 这样写后结果扔是不变的 就如果有一天狗的父类变成了犬科  那么这样写会获得犬科 这样没写死
        self._age=age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def speak(self):
        print('汪汪汪...')
    def run(self):
        print('狗会跑...')
d=Dog('大秋田',5)

d.name='黑色小天'
print(d.name,d.age)


黑色小天 5

class A:
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super().add(x)


b = B()
b.add(2)

3

4多重继承

●在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
●可以在类名的()后边添加多个类，来实现多重继承
●多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
●在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
●如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类


class A(object):
    def test(self):
        print('A....')

class B(object):
    def test(self):
        print('B....')

class C(A,B): #每个父类与父类之间用逗号隔开
    pass

#类名.__bases__   这个属性可以获取当前类的所有父类
print(C.__bases__)



(<class '__main__.A'>, <class '__main__.B'>)  #C有两个父类

在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂


#在python 中支持多继承的  也就是我们可以为一个类指定多个父类


class A(object):
    def test1(self):
        print('A....')

class B(object):
    def test2(self):
        print('B....')

class C(A,B): #每个父类与父类之间用逗号隔开
    pass

#类名.__bases__   这个属性可以获取当前类的所有父类

c=C()

c.test1()
c.test2()


A....
B....

例例1

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类


class A(object):
    def test1(self):
        print('A....')

class B(object):
    def test1(self):
        print('B中test1的方法')

    def test2(self):
        print('B....')

class C(A,B): #每个父类与父类之间用逗号隔开
    pass

#类名.__bases__   这个属性可以获取当前类的所有父类

c=C()

c.test1()

例例2

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类


class A(object):
    # def test1(self):
    #     print('A....')
    pass

class B(object):
    def test1(self):
        print('B中test1的方法')

    def test2(self):
        print('B....')

class C(A,B): #每个父类与父类之间用逗号隔开
    pass

#类名.__bases__   这个属性可以获取当前类的所有父类

c=C()

c.test1()



B中test1的方法

从例例1 和例例2 我们可以得出
#如果多个父类中出现同名的方法 则会先会在第一个父类中 寻找 然后是第二个依次类推
在这里插入图片描述
d=D( ) 我们来个d.test 就发现D的爹(父类)太多 会是很麻烦的 所以在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂

多态的简介

●多态是面向对象的三大特性之一。从字面理解就是多种形态
●一个对象可以以不同形态去呈现（多态参考len( )函数的用法 len( )函数可以处理不同类型的对象 这个特征就是多态）
●面向对象三大特性
----封装 确保对象中数据的安全
----继承 保证了对象的扩展性
----多态 保证了程序的灵活性


#多态是面向对象的三大特征之一
#一个对象也是可以有不同的形态去呈现


class A(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class B(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a=A('葫芦娃')

b=B('钢铁侠')

#定义一个函数

def speak(obj):
    print('好好复习%s'%obj.name)
speak(a)


好好复习葫芦娃


class A(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class B(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a=A('葫芦娃')

b=B('钢铁侠')

class C:
    pass
c=C()

#定义一个函数

def speak(obj):
    print('好好复习%s'%obj.name)
speak(c)


AttributeError: 'C' object has no attribute 'name'
“C”对象没有属性“name”

class A(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class B(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a=A('葫芦娃')

b=B('钢铁侠')

class C:
    pass
c=C()

#定义一个函数

def speak(obj):
    print('好好复习%s'%obj.name)
# speak(c)

def speak2(obj):
    #做一个类型检查  检查一个对象是否是另一个类(类也是对象)的实例
    #这样写你当前的函数只适用于A类型的对象 
    if isinstance(obj,A):
        print('好好复习%s'%obj.name)

speak2(a)  #如果传 speak2(b)  则没有结果



好好复习葫芦娃

len() 通过对len()函数的说明 len()函数的用法就是多态类型的一种体验

#len()  通过对len()函数的说明  len()函数的用法就是多态类型的一种体验
#拓展
#len()函数之所以可以获取长度 是因为对象中有一个特殊方法__len__
#len() 检查一个序列的长度 或者检查这个序列有几个元素

lst=[1,2,3,4,5,6,7]  #lst对象的类型是list
print(len(lst))
s='python'  #str
print(len(s))


7
6

多态 只要你满足一个或者几个条件 一能作为参数去传递

class A(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class B(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a=A('葫芦娃')

b=B('钢铁侠')
print(len(b))



TypeError: object of type 'B' has no len()

class A(object):
    def __init__(self,name):
        self._name=name
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class B(object):
    def __init__(self,name):
        self._name=name

    def __len__(self): #################
         #逻辑简写
        return 100
    #getter and setter
    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

a=A('葫芦娃')

b=B('钢铁侠')
print(len(b))


100

复习环节

在这里插入图片描述

烈风回响
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
看懂这篇文章，你就达到了中级Python程序员的水平
04-17 1604
今天在OpenHatch上找到一个涉及到很多Python知识点的问题，这个问题写着适于中级水平的Python程序员自测，需求是编写一个带评分功能的英文填字图版游戏，我尝试用2.7版本的Python对其进行了编码。 如果有想学习python的程序员，可来我的python学习扣qun：835017344，免费送python的视频教程噢！我每晚上8点还会在群内直播讲解python知识，欢迎大家前来学...
python中级10面向对象上
LonelyDragons的博客
07-07 230
1. 面向对象简介 ●python就是一个面向对象的编程语言 ●对象就是内存中用来储存指定数据的一块区域 ●对象的结构 每个对象当中都保存了3种数据 –id(标识) id是由我们的解析器生成的 在Cpython中 id就是对象的内存地址 –类型（） –value ...
Python中级知识梳理（非常详细）从零基础入门到精通，看完这一篇就够了
xx16755498979的博客
09-04 436
Python中的文件操作通常使用内置的open()函数来打开文件。在这个示例中，我们打开了名为"file.txt"的文件，并将其读入变量content中，最后将其打印出来。open()函数的第一个参数是文件名，第二个参数是打开文件的模式。"r""w""a"
一文带你梳理Python的中级知识
ai520wangzha的博客
05-27 737
Python是一种高级编程语言，它在众多编程语言中，拥有极高的人气和使用率。本文主要带大家梳理一下Python中常用的中级知识，希望对大家有所帮助。
Python基础中级
weixin_52539672的博客
12-30 364
Python基础中级=====我的学习之路
python复习之中级
banhute7862的博客
09-12 173
一、函数 A、函数介绍 a.1、什么是函数 函数就是抽象计算过程，调用相应的函数，返回结果； a.2、内置函数 map def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) reduce() def prod(x, y): return x*y pr...
python面向对象-15
Mr.Sheep的博客
07-29 174
文章目录1.面向对象1.1面向过程1.2面向对象1.3面向对象编程1.4类类的定义和使用数据封装类的两个作用：类属性的补充总结对象之间的交互类命名空间与对象、实例空间1.5类的三大特性继承多态封装 1.面向对象 面向过程 函数式编程 面向对象 1.1面向过程 所谓过程就是我们解决问题的步骤，一步步的按照流程走，有先后之分 整个设计好比流水线，思维上比较机械化 优缺点： 优点 复杂的问题流程...
蓝桥杯Python中级集训包.pdf
10-07
蓝桥杯Python中级集训包.pdf 本资源是蓝桥杯Python中级集训包的.pdf文件，旨在为青少年创意编程比赛的选手提供集训教程。该资源涵盖了Python基础知识的方方面面，涉及到Python安装、交互式解释器、输出print()与...
Python中级开发教程.doc
03-15
随着学习深入，你还会遇到更多高级概念，如列表、元组、字典、集合等复合数据类型，以及类和对象等面向对象编程概念。Python的灵活性和易读性使得它成为许多领域的首选语言，包括数据分析、网络编程、自动化任务和...
蓝桥杯Python中级集训包-v2.pdf
01-15
"蓝桥杯Python中级集训包-v2.pdf"是一份专为准备参加蓝桥杯Python组比赛的青少年设计的集训教程。这份资料涵盖了Python语言的基础到进阶的知识点，旨在帮助参赛者全面掌握Python编程技能，提升在比赛中的表现。 一...
python中级试题(含答案)_python选择题及答案
01-08
python中级试题(含答案)
Java职业笔试题-ooprogramming:关于适用于Java和Python语言的面向对象编程的中级课程
06-13
Java职业笔试题面向对象编程（DIEF、UNIMORE） 这是一门中级编程课程，介绍适用于 Java 和 Python 语言的面向对象编程 (OOP) 原则。 我们向具有软件开发经验或计算机科学背景的学习者推荐本课程。 在课程结束时，...
intermediate-python-course:中级Python课程
03-12
8. **面向对象编程**: 高级Python编程往往涉及面向对象编程（OOP）。您可能需要定义类（如`Dice`或`Game`），并理解类的属性和方法，以及如何通过实例化类来创建对象。 9. **版本控制**: 课程资料可能包括关于版本...
python 初级/中级/高级/核心
weixin_30600503的博客
03-07 150
"一等对象": 满足条件：1.在运行时创建 2.能赋值给变量或数据结构中的元素 3.能作为参数传递给函数 4.能作为函数的返回结果 [ 整数、字符串、字典、"所有函数" ]等都是一等对象"什么是函数"调用：直接使用、不需要类或对象进行调用定义：定义在模块中、类体外作用：数据处理"什么是方法"调用：不能直接使用、需要类或对象进行调用定义：定义在类体中作用：状态处理、状态(对象的属性、类的属性)"...
Python中的类和对象（中级）
zbtxblm的博客
12-29 243
进一步了解Python中的类和对象的用法。参照以下链接。 http://python.jobbole.com/81108/
Python中级知识
我是张先生
03-12 3467
参考
python学习中级，纯代码学习版
有梦想的蜗牛
09-17 1044
参考自  http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431928972981094a382e5584413fa040b46d46cce48e000 #map(fun,list) print (list(map(str,list(range(10))))
python中级水平_Python 中级知识点
weixin_39907850的博客
12-21 544
Python 中级同样还是学习@斌叔的程序媛课程的笔记~本节是对初级教程的补充，主要讲解Python中的异常处理，模块，文件I/O，GUI编程等知识异常处理异常就是代码在执行过程中发生的特殊事件，程序就会奔溃无法正确运行异常处理需要用到Try/except 语句异常的基类：BaseExceptionwhile 1:try:num1 = raw_input("输入被除数:")num2 = raw_i...
Android笔试面试题AI答之Kotlin（20）
最新发布
学无止境，止于至善
08-21 215
Elvis操作符（?:）是Kotlin（以及一些其他编程语言）中用于处理可空表达式的一种简洁方式。它允许在表达式的值为null时提供一个默认值，从而简化了空值的处理。在Kotlin中，构造函数（Constructor）是类的一个特殊方法，它用于初始化新创建的对象。与Java不同，Kotlin中的构造函数不是通过名称来定义的，而是与类名相同，并且没有返回类型（即使是void）。Kotlin支持主构造函数和次构造函数（也称为辅助构造函数或二级构造函数）。
蓝桥杯Python中级集训教程：从安装到面向对象
蓝桥杯青少年创意编程Python组赛前集训教程包是一份针对Python中级选手设计的全面学习资料，由蓝桥杯大赛组委会提供，适合对Python语言有一定基础的学习者进一步提升技能。该教程包于2019年9月19日发布，主要围绕...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值