精华内容
下载资源
问答
  • 下面小编就为大家带来一篇浅谈Python中的可变对象和不可变对象。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 可变对象不可变对象

    万次阅读 2018-08-12 22:22:48
    ”中,因为在调用方法时与方法内部,输出id是相同,所以能理解官方的那句话 Remember that arguments are passed by assignment in Python.  要记住,Python 里的参数是通过赋值传递的。  之后...

      在之前的一篇文章“python中的赋值 值传递?”中,因为在调用方法时与方法内部,输出id是相同,所以不能理解官方的那句话

    Remember that arguments are passed by assignment in Python.  要记住,Python 里的参数是通过赋值传递的。

      之后还是从内存模拟上理解的。其实是我有一点搞错了,官方的话是没问题的,我论证的姿势是错的—两个地方输出id是相同的,并不能说明python是传值还是传地址。官方说只有传值,那去反驳的话,得在调用方法的地方和方法内部,都输出值,两个地方的值不同,这才是正确的反驳姿势。调用id()方法,只是输出内存地址,两个内存地址相同,并不能说明python就不是传值。

      好了,现在开始讲本文的主题–可变对象和不可变对象,在python中,可变对象包括:list、set、dict、自定义对象,不可对对象包括:int、float、str、bool、tuple等。不可变对象步允许自身内容进行修改。如果我们队一个不可变对象进行赋值,实际上是生成一个新对象,再让变量指向这个对象。哪怕这个对象简单到只是数字0和1

        a=0
        print('a',id(a))
        a=1
        print('a',id(a))

    输出:

        a 4453151440
        a 4453151472

    因为对象不可变,所以为了提高效率,python会使用一些公共对象,比如

    a=1
    print('a',id(a))
    b=1
    print('b'),id(b))
    print(a==b)
    print(a is b )
    c='hello world'
    print('c',id(c))
    d='hello world'
    print('d',id(d))
    print(c==d)
    print(c is d)

    输出:

        a 442376776
        b 442376776
        True
        True
        c 4430180912
        c 4430180912
        True
        True

    Tips: is 这个操作符,判断是否为同一个对象,也就是地址是否一致。 == 操作符只判断“值”是否相等

      如果我们需要产生一个list对象的副本,可以通过[:]来获得,对副本赋值一个变量,进行修改,不会影响到之前的list,因为他们已经不是同一个对象了。

      那么如果是下面请看呢:

        m=[1,2,[3]]
        n=m[:]
        n[1]=4
        n[2][0]=5
        print(m)

    输出结果是 [1,2,5],为什么会是这样呢?因为对象的赋值是通过浅拷贝的。

    展开全文
  • 关于可变对象不可变对象,变量

    千次阅读 2018-04-14 20:24:20
    上面我们讲了,str是不变对象,而list是可变对象。对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:&...而对于不可变对象,比如str,对str进行操作呢:>>> a = 'ab...

    上面我们讲了,str是不变对象,而list是可变对象。

    对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:

    >>> a = ['c', 'b', 'a']
    >>> a.sort()
    >>> a
    ['a', 'b', 'c']
    

    而对于不可变对象,比如str,对str进行操作呢:

    >>> a = 'abc'
    >>> a.replace('a', 'A')
    'Abc'
    >>> a
    'abc'
    

    虽然字符串有个replace()方法,也确实变出了'Abc',但变量a最后仍是'abc',应该怎么理解呢?

    我们先把代码改成下面这样:

    >>> a = 'abc'
    >>> b = a.replace('a', 'A')
    >>> b
    'Abc'
    >>> a
    'abc'
    

    要始终牢记的是,a是变量,而'abc'才是字符串对象!有些时候,我们经常说,对象a的内容是'abc',但其实是指,a本身是一个变量,它指向的对象的内容才是'abc'

    ┌───┐                  ┌───────┐
    │ a │─────────────────>│ 'abc' │
    └───┘                  └───────┘
    

    当我们调用a.replace('a', 'A')时,实际上调用方法replace是作用在字符串对象'abc'上的,而这个方法虽然名字叫replace,但却没有改变字符串'abc'的内容。相反,replace方法创建了一个新字符串'Abc'并返回,如果我们用变量b指向该新字符串,就容易理解了,变量a仍指向原有的字符串'abc',但变量b却指向新字符串'Abc'了:

    ┌───┐                  ┌───────┐
    │ a │─────────────────>│ 'abc' │
    └───┘                  └───────┘
    ┌───┐                  ┌───────┐
    │ b │─────────────────>│ 'Abc' │
    └───┘                  └───────┘
    

    所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

    展开全文
  • 1. 命名规范:  1) 类:由多个单词连缀而成,单词之间不要分隔符,每... 3) 方法:应该以英文动词开头,命名规则数据成员相同; 2. 方法重载:  1) 重载在所有语言中的最基本要求是一致的,必须、至少要求方法名

    1. 命名规范:

        1) 类:由多个单词连缀而成,单词之间不要分隔符,每个单词首字母大写,其余小写;

        2) 数据成员:应该是名词,多个单词连缀而成,首字母小写,其余单词首字母大写,其余小写,中间不要使用分隔符;

        3) 方法:应该以英文动词开头,命名规则和数据成员相同;


    2. 方法重载:

        1) 重载在所有语言中的最基本要求是一致的,必须、至少要求方法名要相同才会有重载的可能;

        2) 重载的条件——方法签名:

             i. 不同语言的方法签名不太相同,像Swift把返回值类型也加入到了方法签名中了,而有些语言像Java就不是;

             ii. Java规定的方法签名:就只有参数列表(参数个数、类型,但是不管形参名,形参名忽略),只有参数列表不同才会形成重载(不包括返回类型和方法修饰)!

        3) 为什么不加入返回值类型呢?Java是这样解释的,如果参数列表相同但返回值类型不同的方法,Java是允许调用方法不利用返回值的(即单独调用方法,例如对于int f();可以int a = f(); 也可以f();这样调用),即如果出现f()这样的调用方式编译器就无法判断应该使用哪个重载版本,即发生歧义,因此会编译报错!所以Java不把返回值类型加入方法签名中;


    3. 方法的参数传递机制:值传递

        1) Java的方法参数传递全部采用值传递;

        2) 基本类型直接创建器副本作为参数,对于引用类型(对象,只能用引用来访问它)也是值传递,参数仅仅就是指针的副本;

        3) 因此swap方法只对基本类型有效,但是对引用类型无效,因为在内部交换的仅仅是两个副本引用,并不影响外部真正的实参;


    4. 可变参数方法:

        1) 即printf那种参数个数不确定(可变)的方法;

        2) 定义语法:

             i. 可变参数的类型必须写成type...;

             ii. 例如:public void func(int a, String... args);

    !! 传参的时候可变参数可以接受0个或多个实参!!

        3) 规则:和其它语言中的可变参数的规定还是基本一致的

             i. 可变参数必须是最后一个参数;

             ii. 可变参数最多只能有一个;

    !!违反这两个规定都会导致调用时产生歧义,很容想明白;

        4) 可变参数底层使用数组实现的!!

             i. 上面的public void func(int a, String... args);可以这样调用:obj.func(5, new String[]{"abc", "def", "xyz"});

             ii. 因为可变参数实质上使用数组实现的,但是这里不能传入多个数组(只能传一个):obj.func(5, new String[]{"abc"}, new String[]{"xyz"});  // 错误!!!

        5) 尽量不要重载可变参数方法!!

             i. 原因是这样的,例子:test(int arg);  和  test(int... args);

             ii. 歧义发生在这样调用:test(5),这样会调用test(int arg),但由于两种方法执行内容可能相差很大,因此如果你想在只有一个参数时强制使用test(int... args)版本时就必须使用数组调用,test(new int[]{5});,但这样很麻烦;

             iii. 因此为了避免上述这种歧义的情况就尽量不要重载可变参数方法!!


    2. static和this:

        1) 用static修饰的数据成员和方法都属于类,即静态成员,而没有static修饰的成员都属于对象;

        2) this:

             i. 是一个关键字,和C++的this指针一样,Java的this是引用;

             ii. 用来表示当前的对象本身的引用;

             iii. 在对象内部(方法、块)中可以通过this来引用自己,因此可以在方法中返回this等,例如:public MyType func() { return this; }

             iv. 通过this可以轻松地引用(在块或者方法中引用其他成员)对象自己的成员(数据、方法);

        3) this的另一个常见的用途:当方法形参和数据成员重名时可以用this明确指定身份,例如构造器中常见,Person(String name, int age) { this.name = name; this.age = age; }

        4) 对象方法和类方法的本质区别:

             i. 对象方法有一个隐藏参数this(是方法的第一个参数,但不过是隐藏的,用户看不见,底层作为方法的第一个参数传入),因此对象方法可以通过this来识别现在调用的是哪个对象的方法(对象只保存数据成员,所有对象都共享一份方法代码,而方法就是通过this指针来识别调用者的);

             ii. 而static修饰的类方法就没有this参数,因此静态方法不能访问非静态成员,但是对象方法就能访问静态成员;

        5) 省略this访问其他对象成员:

             i. Java语言本身规定,访问任何对象数据或者方法都必须加上对象前缀,即“obj.data、obj.func(...)"的形式;

             ii. 因此理论上在一个方法中调用另一个对象方法或者访问一个对象数据成员时应该都加上this前缀,即"this.func()"的形式;

             iii. 但这样大量地使用this会显得代码很臃肿,因此Java允许在对象本身的范围内引用对象的其它成员可以不加this前缀;

             iv. 所有没有对象前缀的成员引用编译器都会默认成使用this作为前缀!!因此可以省略this前缀;

        6) 为什么Java允许通过对象引用来访问类成员?!

             i. 讲道理的话在任何地方(不管是类内(外),还是对象内(外))访问类成员(静态成员,数据或方法)都应该使用类名作为前缀,即"MyType.data、MyType.func()"的形式;

             ii. 但Java也允许用对象应用来访问静态成员,即"obj.static_data、obj.static_func()",这显然非常不合理,容易造成误解!把静态成员错认为是对象成员!

             iii. 其实这也是由苦衷的!因为Java允许在类(对象)内部访问其他对象成员(静态、非静态)都可以省略前缀,而这些省略都将默认为是通过this引用的!因此那些省略前缀的静态成员也默认使用this作为前缀的,而为了准确地识别它们是静态成员,也就允许通过this来引用静态成员了,而this刚好是对象引用!

    !也就是说这种别扭的漏洞是因为this的省略而引起的!!

         7) 总结:也就是说,如果用对象引用来访问静态成员那其实背后也是用类名来代理的,这就会有一个小问题,那就是用空的引用来放问静态成员也是能正常访问的!!

    MyType a = null;
    a.static_member;
    !因为其背后还是用类名来代理的;

    !!像这样的代码就非常误导人,因此一定要养成用类名来访问静态成员的好习惯!!

    展开全文
  • 关于面向对象的真面目

    千次阅读 2021-02-25 16:45:32
    面向对象包含了各种技术,几乎涵盖了从 Java、Ruby 等编程语言到需求规格书设计内容的图形表示、重用的软件构件群、优秀设计的技术窍门、业务分析需求定义的有效推进方法、顺利推进系统开发的开发方法等软件...

    关于面向对象的真面目

    面向对象是软件开发的综合技术

    我们先从一个简单的问题开始介绍。

    “为什么要基于面向对象来开发软件?”

    不管谁问这样的问题,笔者都会这样回答:

    “为了轻松地开发软件。”

    可能有的人听到“轻松”二字会感觉很意外。这是因为当提到面向对象时,不少人仍感觉“很难,难以对付”。

    面向对象包含了各种技术,几乎涵盖了从 Java、Ruby 等编程语言到需求规格书和设计内容的图形表示、可重用的软件构件群、优秀设计的技术窍门、业务分析和需求定义的有效推进方法、顺利推进系统开发的开发方法等软件开发的所有领域。

    不过,这些技术单独来看是完全不同的。如果要找出它们的共同点,大概就是它们都是软件开发相关的技术,都是用来顺利推进软件开发的。

    因此,如果用一句话来概括面向对象,那就是“能够轻松地进行较难的软件开发的综合技术”。

    以对象为中心编写软件的开发方法

    面向对象的英文是 Object Oriented,直译为“以对象为中心”。

    在面向对象普及之前,主流的开发方法是“面向功能”的,具体地说,就是把握目标系统整体的功能,将其按阶段进行细化,分解为更小的部分。如果采用面向功能的开发方法来编写软件,当规格发生改变或者增加功能时,修改范围就会变得很广,软件也很难重用。

    面向对象技术的目的是使软件的维护和重用变得更容易,其基本思想是重点关注各个构件,提高构件的独立性,将构件组合起来,实现系统整体的功能。通过提高构件的独立性,当发生修改时,能够使影响范围最小,在其他系统中也可以重用。

    从编程语言演化为综合技术

    面向对象最初是以编程语言的身份出现的,经过不断发展,逐渐被应用到了开发的各个领域。这里我们来简单回顾一下面向对象的全貌和发展过程。

    面向对象的全貌和发展过程

    在这里插入图片描述

    面向对象起源于 1967 年在挪威设计的 Simula 67 编程语言。该语言拥有类、多态和继承等以往的编程语言中没有的优良结构,被称为最早的面向对象编程语言(Object Oriented Programming language,OOP 1)。后来,艾伦·凯率领的团队开发的 Smalltalk 沿用了该结构,确立了“面向对象”的概念。此后,具有相同结构的 C++、Objective-C、Java、C# 和 Ruby 等诸多编程语言相继被开发出来,并延续至今。

    严格来说,正确的表达方式是,将面向对象编程语言(Object Oriented Programming Language)称为 OOPL,使用 OOPL 进行编程的操作称为面向对象编程(OOP)。

    OOP 使得大规模软件的可重用构件群的创建成为可能,这些被称为类库或者框架。另外,创建可重用构件群时使用的固定的设计思想被提炼为设计模式。

    另外,使用图形来表示利用 OOP 结构创建的软件结构的方法称为统一建模语言(Unified Modeling Language,UML)。在此基础上,还出现了将 OOP 思想应用于上流工程的建模,以及用于顺利推进系统开发的开发流程。

    如今,面向对象已经成为一门覆盖软件开发整体的综合技术。虽然这些技术所涉及的领域和内容并不相同,但目的都是顺利推进软件开发。因此,通过以各种形式灵活运用前人的研究和技术窍门,有助于我们提高软件的质量和开发效率。

    在混乱的状态下去理解,就会觉得很难

    尽管面向对象是众多优秀技术的集大成,却经常被认为很难理解,难以对付。也有人认为不擅长抽象思考的人在学习面向对象时会感觉很难,要经过很多年才能掌握,等等。不管是多么方便的工具,如果很难理解其内涵,无法熟练使用,那就没有办法了。

    不过,笔者认为,相较于技术本身的复杂性,面向对象让人感觉很难的更主要的原因在于混乱的现状。造成混乱的主要原因大致有三点:术语洪流、比喻滥用和“一切都是对象”综合征。下面我们就来分别介绍一下。

    混乱之一:术语洪流

    第一点是术语洪流。

    想必很多人在最开始接触面向对象时都是被灌输大量陌生的术语吧。下面列举了一些具有代表性的术语,但其实人们被灌输的术语远不止这些。

    继承、泛化、特化、超类、子类、接口、多重继承、属性、关联、集合、委托、重写、重载、访问控制、构造函数、包、异常、垃圾回收机制、框架、类库、组件、设计模式、用例、建模、UML、重构、敏捷开发流程、RUP、XP……

    对大量术语感到混乱的开发者

    在这里插入图片描述

    简直就是术语大集合!在深入了解技术内容之前就被这么多术语吓退的人应该不在少数吧。

    存在如此大量的术语的原因如下所示。

    首先是面向对象所涉及的范围很广。如今面向对象几乎涵盖了软件开发的所有领域,在这些领域中,之前没有的新结构和新思想层出不穷。这些术语中也有不少英文词汇,可以说这是以欧美为中心迅速发展起来的技术的宿命。此外,还有一些词语被作为业界的宣传用语而被过度解释。像这样,术语多少本身源自该技术的广度,从一定意义上来说也是没有办法的事情。

    而更本质的问题是基本术语的定义混乱,我们将在随后的第三点中对此进行讨论。

    混乱之二:比喻滥用

    第二点是比喻滥用。

    这与其说是技术本身的问题,倒不如说是说明方法的问题。一般来说,比喻并不一定就是不好的。使用恰当的比喻能够直截了当、形象地说明内容;反之,如果比喻不恰当或者使用过度,就有可能造成混乱。尤其是在仅通过比喻来说明编程语言等的具体结构的情况下,由于每个人的理解各不相同,所以特别容易造成误解。

    我们来举例说明一下。面向对象的基本结构有时会像下面这样说明。

    对使用比喻进行的说明感到混乱的开发者

    在这里插入图片描述

    “动物是超类,哺乳类和鱼类是子类。既产卵又用乳汁哺乳幼仔

    的鸭嘴兽也就相当于爬虫类和哺乳类的多重继承。”“人具有‘出生年月日’的属性。如果给小王这样具体的一个人发

    出‘请告诉我你的年龄’的消息,就会得到‘28 岁’的回答。”

    “正如医院里的医生、护士和药剂师互相联系、协同工作一样,对象也是通过在计算机中互相发送消息来进行工作的。”

    从直观理解 OOP 的结构来说,这样的讲解也不一定就是不好的做法。不过,如果只强调比喻而不详细介绍编程语言的结构和目的,那么就只有比喻能给人留下深刻的印象,而且听众很有可能会根据自己的理解,对实际的结构产生错误的认识。特别是在不考虑系统化范围,即计算机的作业范围的情况下乱用比喻,再加上随后介绍的“一切都是对象”综合征的影响,读者就有可能会产生“当使用面向对象时,可以直接将现实世界表示为程序”的重大误解。

    混乱之三:“一切都是对象”综合征

    第三点是“一切都是对象”综合征。

    面向对象的含义是“以对象为中心”。如果按照字面意思进行解释,那么现实世界的人、组织、事件、计算机系统的功能、系统管理的信息和程序的构成元素等一切事物都可以说是对象。这里,我们将这种极端的抽象称为“一切都是对象”综合征。

    “一切都是对象”综合征

    在这里插入图片描述

    这种极端看法大概源自“万物都是变化的”这一点。立足于这种观点是很难说明和理解编程语言的结构,以及现实世界中业务流程的整理方法等具体技术的。尽管如此,但就像“正如现实世界是由对象(物)组成的,在面向对象中,程序也是以对象为中心创建的”这句话所说的那样,我们经常会见到实际上不同的对象都被解释为“对象”这一个词语的情况。这样的解释的确会对直观理解面向对象的结构有所帮助,但反过来也有可能引起“只要使用面向对象,就可以直接将现实世界表示为程序”的误解。

    不过,这种混乱并不只是说明方法的问题,也是面向对象本身的问题。这是因为面向对象的技术范围很广,比如对象和类等词语有时指编程语言的结构,但在其他情况下也指管理的信息、现实世界的人和物。

    “一切都是对象”综合征才是造成面向对象混乱的最大原因)。

    三种混乱增大了理解的难度

    在很多情况下,以上为大家介绍的三点引发混乱的原因,即术语洪流、比喻滥用和“一切都是对象”综合征会同时出现。也就是说,在讲解面向对象时,讲解的人往往会一下子介绍很多陌生的术语,并以比喻为中心,只强调现实世界和程序结构的共同之处。然而,这样的讲解非但不能让人正确地理解该技术,反而会容易引起混乱和误解。

    由于面向对象以范围很广、难度较大的软件开发为对象,所以在技术层面上原本就非常复杂,而以上几点混乱又进一步增大了理解该技术的难度,使其本质难以被看透。

    因为不理解,所以才感觉神秘

    不理解的事情有时会为我们带来意外的惊喜。

    如果某项技术只是比较难,让人无法理解,那么放弃学习也没什么,而面向对象所涉及的编程语言、UML 以及大规模的可重用构件等技术都很基础,而且这些技术正在不断地渗透到软件开发的实际应用场景,所以现阶段很难完全避开面向对象。

    “虽然将现实世界直接表示为程序这种解释我怎么都想不通,但是由于 Java 和 UML 使用起来比较方便,所以我正在使用。”“虽然其中的个别技术非常有用,但是整体上却很难理解。”……想必抱有这些想法的人不在少数吧。

    面向对象有时会被比作魔法,虽然无法用道理解释清楚,但效果很好,或者被解释为一般人难以触及的理想的开发方法。这是将“不理解但有用的事物”神秘化,并推崇为“超越人类智慧的存在”的心理在起作用。

    不过,面向对象的目的是驱动逻辑电路组成的计算机,是具有实践性的一门极为有用的技术,因此完全不存在无法解释的内容。

    消除这三种混乱,就能看到面向对象的真面目

    展开全文
  • 昨晚有同学问了一个非常有意思的问题。问题本身很简单,却包含了初学者不易理解、编码实践中又处处可见的几个知识点。如果对这些知识点理解有偏差,即便是经验丰富的Python程序员,稍留神也会掉进坑里。
  • 重新认识java(一) ---- 万物皆对象

    万次阅读 多人点赞 2016-11-27 21:39:37
    如果你现实中没有对象,至少你在java世界里会有茫茫多的对象,听起来是不是很激动呢?
  • 浅谈一下JAVA对象对象引用以及对象赋值

    万次阅读 多人点赞 2013-09-19 00:50:29
    浅谈一下JAVA对象对象引用以及对象赋值   今天有班级同学问起JAVA对象的引用是什么。... 初学Java,总是会自觉或自觉地把JavaC++相比较。在学习Java类与对象章节的时候,发现教科书许多参考
  • C99可变长数组VLA详解

    千次阅读 2014-10-12 11:27:03
    C90及C++的数组对象定义是静态联编的,在编译期就必须给定对象的完整信息。但在程序设计过程中,我们常常遇到需要根据上下文环境来定义数组的情况,在...C99的可变长数组为这个问题提供了一个部分解决方案。   可
  • JAVA 对象引用以及对象赋值

    千次阅读 2013-05-21 11:16:35
    后来才知道,在许多Java书中,把对象和对象的引用混为一谈。可是,如果我分对象对象引用,  那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。
  • 回头看——面向对象

    千次阅读 热门讨论 2013-08-07 18:43:44
    前段时间,八期给我们讲设计模式学术交流,由于设计模式大家都学的不是很好,所以,我们九期听的也非常费力,就算费力,也只限于弄明白理论上的了,也不是太会用。后来米老师又给我们讲,结合我们实际的项目,来讲...
  • session创建时间保存位置;session如何在一个会话中的多次请求保持不变,即如何识别是一次会话的多个请求;session在分布式环境中如何保持共享;session分布式环境中使用遇到的问题解决。
  • C++中对象和对象指针的区别

    千次阅读 2018-12-24 11:44:12
    对象指针,而不是指针对象。因为这个被公司大佬们搞得很尴尬!!! 相同点:  1. 都是地址的概念;  指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。  ★ 区别:  1. 指针是一个...
  • Linux内核驱动中面向对象的基本规则实现方法 - 内核版本 Linux Kernel 2.6.34, 与 Robert.Love的《Linux Kernel Development》(第三版)所讲述的内核版本一样 - 源代码下载路径: ...
  • 面向对象的意义

    千次阅读 多人点赞 2017-05-03 10:54:06
    作者:知乎用户 ... 来源:知乎 著作权归作者所有。商业转载请联系作者获得授权,非商业转载...似乎很简单,但实际又很简单:面向对象三要素封装、继承、多态 (警告:事实上,从业界如此总结出这面向对象三要素的
  • UML八大误解

    千次阅读 2014-09-07 10:31:44
    我从2002年开始专门从事研究推广UML的工作,在为软件组织提供UML相关需求设计技能服务时,经常会发现软件开发人员对UML建模存在种种误解。本文归纳了最典型的八个误解加以剖析。 误解一:UML是开发团队用来...
  • 通过允许就地更改对象的类,提供一种更安全的机制来生成在Leonie运行时中实现可变参数类型的代码。 句法 此Xcode项目生成一个名为“ objk”的命令行工具,该工具将指向“ .ok”源文件的路径作为其唯一参数,并将其...
  • java基础 第一章 对象入门

    千次阅读 2015-04-21 21:54:29
    第1章 对象入门   “为什么面向对象的编程会在软件开发领域造成如此震憾的影响?”   面向对象编程(OOP)具有多方面的吸引力。对管理人员,它实现了更快更廉价的开发与维护过程。对分析与设计人员,建模...
  • 浅谈java对象引用及对象赋值

    千次阅读 多人点赞 2017-01-05 15:11:46
    可是,如果分对象对象引用, 那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。  为便于说明,我们先定义一个简单的类:  c
  • 第1章 对象入门——Thinking-in-Java

    千次阅读 2016-03-24 11:31:01
    第1章 对象入门“为什么面向对象的编程会在软件开发领域造成如此震憾的影响?”面向对象编程(OOP)具有多方面的吸引力。对管理人员,它实现了更快更廉价的开发与维护过程。对分析与设计人员,建模处理得更加...
  • //缓存的下界,-128,不可变 static final int low = -128; //缓存上界,暂为null static final int high; //缓存的整型数组 static final Integer cache[]; static { // 缓存上届,可以...
  • 语言理论的概念和误解

    千次阅读 2014-09-06 00:45:58
    本着“理论指导实践”,既然要做,可不先做好工作。。。装逼结束,其实这篇东西跟要写一个语言直接关系不大,主要来由是在群里或其他人的一些讨论。有人说,引起程序员战争的最好办法就是宣称某某语言好或者不好...
  • 学习Java的过程中,很容易将对象对象....Java语言中通过对象的引用来操纵对象,要注意的一点是对象和对象的引用是存储在不同的地方的,因为对象往往所占的空间要求比较大,所以对象存储在堆中,而为了便于操作,对
  • QingStor 对象存储服务提供无限扩展的存储空间、快速的数据存取性能、高度的可靠性数据的安全性、细粒度的权限控制及简单易用的接口,以向广大用户提供廉价、可靠的存储系统。 本次分享,QingCloud 系统工程师 ...
  • 认识封装对象 在开始之前,我们先看一个例子,以便之后更轻松的理解封装对象的概念。"tick".toUpperCase //function toUpperCase() String.prototype.toUpperCase //function toUpperCase() "tick".toUpperCase...
  • 误解的MVC被神化的MVVM

    千次阅读 2015-12-12 11:04:40
    误解的 MVC MVC 的历史 MVC,全称是 Model View Controller,是模型 (model)-视图 (view)-控制器 (controller) 的缩写。它表示的是一种常见的客户端软件开发框架。 MVC 的概念最早出现在二十世纪八十...
  • 智能合约中存在的3种最常见的误解

    千次阅读 2019-10-16 17:17:57
    那么问题是,尽管我们现在了解了关于比特币区块链的三大强势用例(出处,公司之间记录轻量级的融资),但我们尚未找到以太坊智能合约的等价物。 这并不是说人们缺乏想要利用智能合约的想法。相反,这些想法很多是...
  • Java中的类和对象【三】

    千次阅读 2017-05-19 21:37:03
    本文目录:【蓝色部分为本章的目录】 1.基本概念 2.Java变量相关 1)Java变量分类 ...3)Java变量修饰符访问域 4)Java类修饰符[包含内部类] 3.Java涉及OO的关键知识点【主体】 1)继承的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,526
精华内容 11,410
关键字:

关于可变对象和不可变对象下面的理错误解是