python中的类与对象（2）

news2024/12/25 1:10:10

目录

一. 类的基本语法

二. 类属性的应用场景

三. 类与类之间的依赖关系

（1）依赖关系

（2）关联关系

（3）组合关系

四. 类的继承

一. 类的基本语法

先看一段最简单的代码：

class Dog():
    d_type = "二哈"  # 属性，类属性，类变量

    def say_hi(self):  # 在类里面的函数称为方法，第一个参数必须是self，代表实例本身
        print("hello,i am a dog,my type is",self.d_type)

dog1 = Dog()  # 生成了一个实例
dog1.say_hi()  # 实例.方法
# hello,i am a dog,my name is 二哈
print(dog1.d_type)  # 实例.属性
# 二哈

这段代码定义了一个名为Dog的类，其中有一个类属性d_type设置为"二哈"，以及一个实例方法say_hi用于打印一句话。然后创建了一个名为dog1的实例，并调用了say_hi方法和打印了实例属性d_type的值。

这里d_type是Dog类的属性（类属性/类变量/公共属性），从Dog类生成的对象都自带这个属性，如果我们想要定义每条狗的实例属性/实例变量/成员变量，如姓名，年龄，主人信息等，则使用__init__方法定义私有属性。我们并没有调用__init__(self,xxxx)，但它会自动执行。因为它叫初始化函数，就是在实例化的时候，用来初始化一些数据的，比如初始化实例的名字、年龄等私有属性。

这些写在__init__(self,xxxx)里name，age等实例变量，跟公共属性d_type有什么区别呢?换句话说私有属性和共有属性有什么区别？区别就是，d_type是存在Dog类自己的内存里，self.name，self.age是存在每个实例自己的内存里。

class Dog():
    d_type = "二哈"
    def __init__(self, name, age):  # __init__函数称为初始化方法，构造方法，构造函数，在创建对象时自动调用
        # 第一个参数必须是self，代表实例本身
        # 要想把私有属性name, age真正的存到实例里，就要把2个值和实例绑定
        self.name = name  # 绑定__init__参数值到对象
        self.age = age

    def say_hi(self):  # 第一个参数必须是self
        print("hello,i am a dog,my name is",self.name)

dog1 = Dog("zhaopeng",4)  # 实例化对象，相当于__init__(dog1, "zhaopeng", 4)
dog1.say_hi()  # 相当于类中say_hi(dog1)
print(dog1.name, dog1.d_type)  # 打印对象的公共属性和私有属性
print(id(dog1.d_type), id(Dog.d_type))  # 公共属性，对象和类共享内存
dog1.name = "zhangsan"
dog1.d_type = "藏獒"
print(dog1.name, dog1.d_type)  # 对象属性可以在类外重写

这里需要重点搞明白self什么意思，我们先搞明白实例化的过程：

step 1，d=Dog("毛毛"，2,"Alex")，会申请一会内存空间，指向变量名d

step 2，__init__这个初始化方法需要把接收到参数存下来， 存到这个d的内存空间里

step 3，传给初始化方法里的name,age想绑定到d的空间里，怎么存呢？就得把d的内存空间传到这个方法里，所以self就是用来接收d的地址的。d=Dog(“毛毛”，2,"AIex”)相当于Dog(d,"毛毛",2,"Aex”)，那self.name=name 也就相当于d.name =name。我们在实例时没有手动传递d到Dog类里，只写了d=Dog(“毛毛”,2,"Alex”)，是Python解释器帮你自动干了这个事。

到此，我们终于明白，原来self就是代表实例本身。实例化时python会自动把这个实例本身通过self参数传进去。接下来看第二个方法：

def say_hi(self):  # 第一个参数必须是self
    print("hello,i am a dog,my name is",self.name)

这里为何也要加入self参数？那是因为，你自己也看到了， 这个类的方法其实就是函数。函数被一个实例调用时，它需要知道是谁在调用它？函数内部要用到一些实例的属性的时候去哪里取呢？比如在say_hi函数里怎么取到d.name，d.age？只能你先传递给它。所以这就是为何类下的每个方法第一个参数都要是self，因为为了接收实例这个对象本身。

*注意：self在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做，因为你瞎改别人就不认识。

二. 类属性的应用场景

仍然是通过一段代码说明如何调用和修改类属性，实例属性：

class People():
    nationality = "CN"  # nationality是公共属性
    def __init__(self, name, age, sex):  # name, age, sex是私有属性
        self.name = name
        self.age = age
        self.sex = sex
# 实例化
p1 = People("zhangsan",31,"M")
p2 = People("lisi",25,"M")
p3 = People("wangwu",21,"F")
# 调用公共属性
print(People.nationality)
print(p2.nationality)
# 调用实例属性
print(p1.age)  # 实例属性不能在类中调用，只能在实例中调用
print(People.age)  # AttributeError: type object 'People' has no attribute 'age'
# 修改私有属性
p1.age = 22  # 修改私有属性
print(p1.age)
# 修改公共属性
p1.nationality = "TW"  # 修改公共属性
print(p1.nationality)  # TW
print(p2.nationality,People.nationality)  # CN CN
# 修改p1的公共属性不改变People类，实际上是因为p1.nationality = "TW" 这句相当于为p1增加了实例属性nationality

搞懂了这个我们就可以重写上一节的引子，利用类方法来写：

class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]咬了[%s]一口，人掉血[%s]，剩余血量[%s]"%(self.name, person.name, self.attack_val, person.life_val))

class Person():
    life_val = 100
    def __init__(self, name, age, attack_val):
        self.name = name
        self.age = age
        self.attack_val = attack_val
    def beat(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s]一棒，狗掉血[%s]，剩余血量[%s]"%(self.name, dog.name, self.attack_val, dog.life_val))

dog1 = Dog("FWE", "二哈", 10)
person1 = Person("zhaopeng", 25, 30)
dog1.bite(person1)
# 狗[FWE]咬了[zhaopeng]一口，人掉血[10]，剩余血量[90]
person1.beat(dog1)
# 人[zhaopeng]打了狗[FWE]一棒，狗掉血[30]，剩余血量[70]

三. 类与类之间的依赖关系

大千世界，万物之间皆有规则和规律。类和对象是对大千世界中的所有事物进行归类，事物之间存在着相对应的关系，类与类之间也同样如此。类与类中存在以下关系：

  • 依赖关系，狗和主人的关系。
  • 关联关系，你和你的女友之间的关系就是关联关系。
  • 聚合关系，电脑的各部件组戒完整的电脑，电脑里有CPU，硬盘，内存等。每个组件有自己的生命周期，电脑挂了，CPU还是好的，还是完整的个体。
  • 组合关系，比聚合还要紧密。比如人的大脑，心脏，各个器官，这些器官组合成一个人。这时人如果挂了，其他的东西也跟着挂。
  • 继承关系，类的三大特性之一，子承父业。
（1）依赖关系
class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val, master):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
        self.master = master  # 人作为一个对象，和狗产生依赖关系
        self.say_hi()
    def say_hi(self):
        print("Hello, i am a dog, my name is [%s], and my master is [%s]"%(self.name, self.master.name))

class Person():
    life_val = 100
    def __init__(self, name, age, attack_val):
        self.name = name
        self.age = age
        self.attack_val = attack_val
    def beat(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s]一棒，狗掉血[%s]，剩余血量[%s]"%(self.name, dog.name, self.attack_val, dog.life_val))

person1 = Person("zhaopeng", 25, 30)
dog1 = Dog("FWE", "二哈", 10, person1)
（2）关联关系

构造男生和女生谈恋爱的关联：如果直接加一个partner实例属性：

class Person():
    def __init__(self, name, age, sex, partner):
        self.name = name
        self.age = age
        self.sex = sex
        self.partner = partner
    
person1 = Person("zhaopeng", 25, "M", person2)  # NameError: name 'person2' is not defined.
person2 = Person("wangwu", 25, "F", person1)

因为实例化person1时，需要向里传person2，而此时person2还没创建出来，所以此时会报NameError。我们可以先把self.partner初始为None，然后再建立联系：

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.partner = None
    
person1 = Person("zhaopeng", 25, "M")  
person2 = Person("wangwu", 25, "F")
person1.partner = person2  # 建立联系
person2.partner = person1
print(person1.partner.name,person2.partner.name)  # wangwu zhaopeng

这似乎解决了问题，但是：男生和女生的恋爱关系是一个双向的过程，这种写法我们必须同时写两句，来建立或者删除联系。如何只用一条指令就同时建立和删除双方之间的联系？一种思路是，单独写一个类relationship专门处理，存储2个人的关系状态，2个人在查自己的感情状态时，都到这个单独的实例里来查：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    
person1 = Person("zhaopeng", 25, "M")  
person2 = Person("wangwu", 25, "F")
relationship = Relationship()
relationship.make_couple(person1, person2)
# [zhaopeng]和[wangwu]确定了恋爱关系

现在我们再做一点改进，我们希望能在人的属性里面查到自己的男朋友/女朋友，这里就需要对Person类进行修改：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))

class Person():
    def __init__(self, name, age, sex, relation):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation  # 把对象是谁加到实例属性里面
    
relationship = Relationship()
person1 = Person("zhaopeng", 25, "M", relationship)  
person2 = Person("wangwu", 25, "F", relationship)
relationship.make_couple(person1, person2)
print(person1.relation.relationship)
# 这里person1.relation其实就是之前建立的relationship = Relationship()
# 然后再.relationship输出的是那个列表

但是这样显示是个列表，我们再优化Relationship类，使得它更完整：

class Relationship():
    def __init__(self):
        self.relationship = []  # 生成空列表
    def make_couple(self, p1, p2):  # 建立恋爱关系
        self.relationship = [p1, p2]
        print("[%s]和[%s]确定了恋爱关系"%(p1.name, p2.name))
    def get_partner(self, person):  # 找寻另一半
        # 这里还要传入person是因为，self.relationship列表里有两个人，需要确定具体是显示哪一个的另一半
        if len(self.relationship) == 0:
            print("[%s]没有对象！" % person.name)
        else:
            for i in self.relationship:
                if i != person:
                    print("[%s]的对象是[%s]" % (person.name, i.name))
    def break_up(self):  # 模拟分手
        if len(self.relationship) == 0:
            print("两人已经分手了")
        else:
            print("[%s]和[%s]分手了"%(self.relationship[0].name, self.relationship[1].name))
            self.relationship = []
            

class Person():
    def __init__(self, name, age, sex, relation):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation  # 把对象是谁加到实例属性里面

# 实例化
relationship = Relationship()
person1 = Person("zhaopeng", 25, "M", relationship)  
person2 = Person("wangwu", 25, "F", relationship)

relationship.make_couple(person1, person2)  # 建立恋爱关系
# [zhaopeng]和[wangwu]确定了恋爱关系
person1.relation.get_partner(person1)  # 找到person1的另一半是谁
# [zhaopeng]的对象是[wangwu]
person1.relation.break_up()  # 分手
# [zhaopeng]和[wangwu]分手了
person2.relation.get_partner(person2)  # 此时获取person2的对象，显示无
# [wangwu]没有对象！

以上我们就同步了两个人的恋爱关系，同时导演了一部恋爱到分手的大戏（大雾）。

（3）组合关系
# 组合关系：由一堆组件构成一个完整的实体，组件本身独立但又不能自己运行，必须跟宿主组合在一起运行
# 这里的武器类就必须依赖人来运行，人实例化对象的同时也实例化武器
class Weapon():
    def gun(self, dog):
        self.attack_val = 50
        self.name = "枪"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))

    def knife(self, dog):
        self.attack_val = 20
        self.name = "匕首"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))

    def AK47(self, dog):
        self.attack_val = 80
        self.name = "AK47"
        dog.life_val -= self.attack_val
        print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]"%(dog.name, self.name, self.attack_val, dog.life_val))
        

class Person():
    life_val = 100
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.weapon = Weapon()  # 把对象是谁加到实例属性里面

class Dog():
    life_val = 100
    def __init__(self, name, d_type, attack_val):
        self.name = name
        self.d_type = d_type
        self.attack_val = attack_val
    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]把人[%s]咬了,人掉血[%s],现在人剩余血量[%s]"%(self.name, person.name, self.attack_val, person.life_val))

dog1 = Dog("zhangsan", "二哈", 5)
person1 = Person("Alex", 25, "M")
person1.weapon.gun(dog1)
# [zhangsan]被[枪]攻击了，掉血[50]，还剩血量[50]
dog1.bite(person1)
# 狗[zhangsan]把人[Alex]咬了,人掉血[5],现在人剩余血量[95]

四. 类的继承

现在我们写人和猫。众所周知人和猫有很多相似之处，如它们都有姓名，性别，有2只眼睛，都会呼吸，会拉粑粑；也有不同之处，例如人会看书，猫会挠人的沙发，写成代码就是这样的：

class Person():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
        self.has_tails = False
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
    def read(self):
        print(self.name,"在读书")

class Cat():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
        self.has_tails = True
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉臭臭")
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()
cat1.scratch_sofa()

现在我们要实现代码的重复利用，就可以使用类的继承，首先提取其公共部分写成mammul类：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")

然后重写Person()和Cat()类，在括号内填写继承的父类名称，这个时候父类的__init__构造函数，还有breathe和poop方法都被继承了过来，虽然我们没有在Person()和Cat()类下面写他们。现在创建一个猫猫实例，由于Cat类没有__init__构造函数，系统会自动调用它继承的父类Mammul的构造函数，让实例具有姓名，性别，眼睛数等属性（我们先不写实例属性has_tails）：

class Person(Mammul):
    def read(self):
        print(self.name,"在读书")

class Cat(Mammul):
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()  # Alex 在拉粑粑
cat1.scratch_sofa()  # MiaoMiao 在挠主人的沙发

然而，如果我们在子类里面写了专属于人的拉屎方法，就会优先调用子类的，没有的话才去父类找同名方法用：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
   
class Person(Mammul):
    def poop(self):
        print(self.name,"在拉shi")
    def read(self):
        print(self.name,"在读书")

person1 = Person("Alex", "M")
person1.poop()  # Alex 在拉shi

注意到我们还没有写实例属性has_tails，而如果在子类直接写：

class Person(Mammul):
    def __init__(self):
        self.has_tails = False
    def poop(self):
        print(self.name,"在拉shi")
    def read(self):
        print(self.name,"在读书")

则根据前面的，系统会直接调用子类的__init__构造函数，所以父类的姓名，性别，2只眼属性都没办法继承过来，为了解决这个问题，标准写法应该加上super()，它也是一个类，既不是方法也不是函数。super会返回当前类的父类，在子类的构造函数中写super().__init__就会调用父类的构造函数。所以本节最开始的代码优化后可以这样写：

class Mammul():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        self.num_eyes = 2
    def breathe(self):
        print(self.name,"在呼吸")
    def poop(self):
        print(self.name,"在拉粑粑")
   
class Person(Mammul):
    def __init__(self, name, sex):
        super().__init__(name, sex)
        self.has_tails = False
    def read(self):
        print(self.name,"在读书")

class Cat(Mammul):
    def __init__(self, name, sex):
        super().__init__(name, sex)
        self.has_tails = True
    def scratch_sofa(self):
        print(self.name,"在挠主人的沙发")

person1 = Person("Alex", "M")
cat1 = Cat("MiaoMiao", "F")
person1.poop()  # Alex 在拉shi
cat1.scratch_sofa()  # MiaoMiao 在挠主人的沙发
print(cat1.num_eyes)  # 2

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1472513.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

JS防抖函数

JS防抖函数

场景 频繁触发耗时操作，仅关心最后一次的触发时使用防抖函数 代码 function debounce(fn , delay){let timer;return () > {clearTimeout(timer);timer setTimerout(()>{fn()},delay)} } 详解 触发一次函数，然后执行后续操作 function deboun…
阅读更多...
消息中间件之RocketMQ源码分析(十七)

消息中间件之RocketMQ源码分析(十七)

Broker CommitLog索引机制的数据结构 ConsumerQueue消费队列 主要用于消费拉取消息、更新消费位点等所用的索引。源代码参考org.apache.rocketmq.store.ConsumerQueue.该文件内保存了消息的物理位点、消息体大小、消息Tag的Hash值 物理位点:消息在CommitLog中的位点值消息体…
阅读更多...
音乐格式转换软件有哪些？5款必备神器

音乐格式转换软件有哪些？5款必备神器

音乐格式转换软件有哪些？音乐，作为人类情感的载体，伴随着我们生活的每一个角落。在享受音乐的同时，我们有时也面临着音乐格式不兼容的问题。不用担心，今天我将为大家揭秘五款音乐格式转换软件，让你的音乐之…
阅读更多...
开发一套智慧工地系统需要多久时间？

开发一套智慧工地系统需要多久时间？

什么是智慧工地？ 智慧工地是智慧地球理念在工程领域的行业具现，是一种崭新的工程全生命周期管理理念。它运用信息化手段，通过三维设计平台对工程项目进行精确设计和施工模拟，围绕施工过程管理，建立互联协同、智能生产…
阅读更多...
投资黄金在哪里买比较好？

投资黄金在哪里买比较好？

黄金，作为一种传统的避险资产，历来受到投资者的青睐。在全球经济波动的大背景下，黄金的价值愈发凸显。那么，投资黄金在哪里买比较好呢？本文将重点探讨在香港黄金平台投资黄金的优势，并以金田金业为例&#…
阅读更多...
外包工作两个月，技术退步让我决心改变

外包工作两个月，技术退步让我决心改变

大家好，我是一名大专生，2019年通过校招进入了湖南的一家软件公司。在这里，我从事了接近4年的功能测试工作。然而，今年8月份，我深刻地意识到，我不能继续这样下去了。 长时间在一个舒适的环境里，…
阅读更多...
ThreadLocal从使用到实现原理与源码详解

ThreadLocal从使用到实现原理与源码详解

ThreadLocal概述 ThreadLocal是多线程中对于解决线程安全的一个操作类，它会为每个线程都分配一个独立的线程副本从而解决了变量并发访问冲突的问题。ThreadLocal 同时实现了线程内的资源共享。 案例：使用JDBC操作数据库时，会将每一个线程的…
阅读更多...
Linux环境基础开发工具使用篇(三) git 与 gdb

Linux环境基础开发工具使用篇(三) git 与 gdb

一、版本控制器-git 1.简单理解: ①git既是服务端，又是客户端 ②git会记录版本的变化 ③git是一个去中心化的分布式软件 git/gitee 是基于git仓库搭建的网站，让版本管理可视化 2.git 三板斧提交代码 查看安装的git版本 git--version 命令行提交代…
阅读更多...
ACM题解Day8 | 最小公倍数 GCD 模块 |最小共倍数,等差数列,后缀表达式

ACM题解Day8 | 最小公倍数 GCD 模块 |最小共倍数,等差数列,后缀表达式

学习目标： 博主介绍: 27dCnc 专题 : 数据结构帮助小白快速入门算法 👍👍👍👍👍👍👍👍👍👍👍👍 ☆*: .｡. o(≧▽…
阅读更多...
线性表——单链表的增删查改（上）

线性表——单链表的增删查改（上）

本节复习链表的增删查改 首先， 链表不是连续的， 而是通过指针联系起来的。 如图： 这四个节点不是连续的内存空间， 但是彼此之间使用了一个指针来连接。 这就是链表。 现在我们来实现链表的增删查改。 目录 本节函数接口列表…
阅读更多...
飞机订票系统

飞机订票系统

飞机订票系统 获取源码——》公主号：计算机专业毕设大全
阅读更多...
历尽千辛万苦，终于将CSDN博客等级提升到6级，拥有了自定义域名

历尽千辛万苦，终于将CSDN博客等级提升到6级，拥有了自定义域名

近些时间感觉百度对我们个人博客网站不太友好，不单是低质站点被清退，而且正常的站点sitemap.xml权限也被收回或仅剩1条，API普通收录提交数量也猛跌到10条，所以只能多发展其他自媒体平台了。 幸好boke112百科以前玩过一段时间的CS…
阅读更多...
紫外-可见吸收光谱法（UV-Vis）是最常用吸收光谱技术 市场持续扩大

紫外-可见吸收光谱法（UV-Vis）是最常用吸收光谱技术 市场持续扩大

紫外-可见吸收光谱法（UV-Vis）是最常用吸收光谱技术 市场持续扩大 紫外-可见吸收光谱法，也称为紫外-可见分光光度法，简称UV-Vis，利用样品分子在紫外和可见光激发下产生电子能级跃迁形成的吸收光谱，对元素进行…
阅读更多...
qt debug和release运行都没问题打包之后运行不了

qt debug和release运行都没问题打包之后运行不了

💂 个人主页:pp不会算法^ v ^ 🤟 版权: 本文由【pp不会算法v】原创、在CSDN首发、需要转载请联系博主 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦 问题 qt debug和release运行都没问题打包之后运行不了 原因 环…
阅读更多...
Jquery中的事件与动画

Jquery中的事件与动画

文章目录 前言一、pandas是什么？二、使用步骤 1.引入库2.读入数据总结 本章目标 使用常用简单事件制作网页特效使用鼠标事件制作主导航特效使用hover()方法制作下拉菜单特效使用鼠标事件及动画制作页面特效 一.Jquery事件概述 二.基础事件 鼠标事件 演示案例&…
阅读更多...
【激光SLAM】基于图优化的激光SLAM 方法(Grid-based)

【激光SLAM】基于图优化的激光SLAM 方法(Grid-based)

文章目录 Graph-based SLAM数学概念 非线性最小二乘(Non-Linear Least Square)解决的问题误差函数线性化流程 非线性最小二乘在SLAM中的应用图的构建（SLAM前端）误差函数误差函数的线性化固定坐标系构建线性系统求解 Cartographer介绍 Graph-based SLAM …
阅读更多...
PROTEL

PROTEL

PROTEL是什么 Protel软件是由Altium公司（原为Protel Technology公司）开发的一款电子设计自动化（EDA）软件，主要用于电子电路设计和印制电路板（PCB）制作。 学习Protel 99 SE的大致过程 原理图文…
阅读更多...
阿里云服务器ECS u1实例性能怎么样？

阿里云服务器ECS u1实例性能怎么样？

阿里云服务器ECS u1实例，2核4G，5M固定带宽，80G ESSD Entry盘优惠价格199元一年，性能很不错，CPU采用Intel Xeon Platinum可扩展处理器，购买限制条件为企业客户专享，实名认证信息是企业用户即可&a…
阅读更多...
BIO实战、NIO编程与直接内存、零拷贝深入辨析

BIO实战、NIO编程与直接内存、零拷贝深入辨析

BIO实战、NIO编程与直接内存、零拷贝深入辨析 长连接、短连接 长连接 socket连接后不管是否使用都会保持连接状态多用于操作频繁，点对点的通讯，避免频繁socket创建造成资源浪费，比如TCP 短连接 socket连接后发送完数据后就断开早期的http服…
阅读更多...
mybatis总结传参三

mybatis总结传参三

十、（不推荐）多个参数-按位置传参 参数位置从 0 开始， 引用参数语法 #{ arg 位置 } ， 第一个参数是 #{arg0}, 第二个是 #{arg1} 注意： mybatis-3.3 版本和之前的版本使用 #{0},#{1} 方式， 从 myba…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023