精华内容
下载资源
问答
  • 大概是这样的,多个客户端可以连接到同一个服务器,客户端之间也可相互通信,但是先要借助服务器把相互通信的2个客户端的socket对象分别传给对方。没有什么方法可以传递socket对象呢?
  • 一、 面向对象,这个...对象的定义是人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅表示具体的事物,还表示抽象的规则、计划或事件。也的定义为“一切都是对象”然而面向对象

    一、 面向对象,这个对象到底是什么?

     

        这个对象不是C#中的实例,C#中我们把一个类的实例也叫做对象,这种对象严格的说应该是面向对象的编程实现(OOP)中的对象,面向对象编程,也不是面向类的实例编程。对象的定义是人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅能表示具体的事物,还能表示抽象的规则、计划或事件。也有的定义为“一切都是对象”然而面向对象也不能简单的等价理解成面向任何事物编程,面对一切编程?开玩笑,呵呵。

    因此面向对象这个对象,指的是客体。所谓客体是指客观存在的对象实体和主观抽象的概念。 

     

    二、 为什么要面向对象?

     

    面向对象是为了解决系统的可维护性,可扩展性,可重用性,我们再进一步思考,面向对象为什么能解决系统的可维护性,可扩展性,可重用性? 

    面向对象产生的历史原因有下面两点: 

    1、 计算机是帮助人们解决问题的,然而计算机终究是个机器,他只会按照人所写的代码,一步一步的执行下去,最终得到了结果,因此无论程序多么的复杂,计算机总是能轻松应付,结构化编程,就是按照计算机的思维写出的代码,但是人看到这么复杂的逻辑,就无法维护和扩展了。

    2、 结构化设计是以功能为目标来设计构造应用系统,这种做法导致我们设计程序时,不得不将客体所构成的现实世界映射到由功能模块组成的解空间中,这种转换过程,背离了人们观察和解决问题的基本思路。 

        可见结构化设计在设计系统的时候,无法解决重用、维护、扩展的问题,而且会导致逻辑过于复杂,代码晦涩难懂。于是人们就想,能不能让计算机直接模拟现实的环境,用人类解决问题的思路,习惯,步骤来设计相应的应用程序?这样的程序,人们在读它的时候,会更容易理解,也不需要再把现实世界和程序世界之间来回做转换。 

        与此同时,人们发现,在现实世界中存在的客体是问题域中的主角,所谓客体是指客观存在的对象实体和主观抽象的概念,这种客体具有属性和行为,而客体是稳定的,行为不稳定的,同时客体之间具有各种联系,因此面向客体编程,比面向行为编程,系统会更稳定,在面对频繁的需求更改时,改变的往往是行为,而客体一般不需要改变,所以我们就把行为封装起来,这样改变时候只需要改变行为即可,主架构则保持了稳定。 

    于是面向对象就产生了。 

    然而人们追求的系统可维护性,可扩展性,可重用性又是怎么在面向对象中体现出来的呢? 

    首先看看面向对象的三大特征: 

    封装:找到变化并且把它封装起来,你就可以在不影响其它部分的情况下修改或扩展被封装的变化部分,这是所有设计模式的基础,就是封装变化,因此封装的作用,就解决了程序的可扩展性。 

    继承:子类继承父类,可以继承父类的方法及属性,实现了多态以及代码的重用,因此也解决了系统的重用性和扩展性,但是继承破坏了封装,因为他是对子类开放的,修改父类会导致所有子类的改变,因此继承一定程度上又破坏了系统的可扩展性,所以继承需要慎用,只有明确的IS-A关系才能使用,同时继承在在程序开发过程中重构得到的,而不是程序设计之初就使用继承,很多面向对象开发者滥用继承,结果造成后期的代码解决不了需求的变化了。因此优先使用组合,而不是继承,是面向对象开发中一个重要的经验。 

    多态:接口的多种不同的实现方式即为多态。接口是对行为的抽象,刚才在封装提到,找到变化部分并封装起来,但是封装起来后,怎么适应接下来的变化?这正是接口的作用,接口的主要目的是为不相关的类提供通用的处理服务,我们可以想象一下。比如鸟会飞,但是超人也会飞,通过飞这个接口,我们可以让鸟和超人,都实现这个接口,这就实现了系统的可维护性,可扩展性。 

        因此面向对象能实现人们追求的系统可维护性,可扩展性,可重用性。面向对象是一种编程思想,起初,“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法,但面向对象的思想已经涉及到软件开发的各个方面,比如现在细分为了面向对象的分析(OOA),面向对象的设计(OOD),面向对象的编程实现(OOP) 

     

    三 面对对象编程,分为几个步骤? 

     

    面向对象是一种思想,他让我们在分析和解决问题时,把思维和重点转向现实中的客体中来,然后通过UML工具理清这些客体之间的联系,最后用面向对象的语言实现这种客体以及客体之间的联系。它分为面向对象的分析(OOA),面向对象的设计(OOD),面向对象的编程实现(OOP)三个大的步骤。

    1、首先是分析需求,先不要思考怎么用程序实现它,先分析需求中稳定不变的客体都是些什么,这些客体之间的关系是什么。

    2、把第一步分析出来的需求,通过进一步扩充模型,变成可实现的、符合成本的、模块化的、低耦合高内聚的模型。

    3、使用面向对象的实现模型 

     

    四 面向过程到面向对象思维如何转变? 

     

        当我们习惯了面向过程编程时,发现在程序过程中到处找不到需要面向对象的地方,最主要的原因,是思维没有转变。程序员通常在拿到一个需求的时候,第一个反应就是如何实现这个需求,这是典型的面向过程的思维过程,而且很快可能就实现了它。而面向对象,面对的却是客体,第一步不是考虑如何实现需求,而是进行需求分析,就是根据需求找到其中的客体,再找到这些客体之间的联系。因此面向过程和面向对象的思维转变的关键点,就是在第一步设计,拿到需求后,一定先不要考虑如何实现它,而是通过UML建模,然后按照UML模型去实现它。这种思路的转变,可能需要个过程。 

     

    五 面向对象和基于对象的区别 

     

        “面向对象”和“基于对象”都实现了“封装”的概念,但是面向对象实现了“继承和多态”,而“基于对象”没有实现这些。因此在我们进行WEB开发,普通三层开发中,基本上是基于对象的实现,因为只是实现了封装,但是没有使用继承和多态,不过这也正常,WEB开发,大部分功能就是简单的增删改查,中间的BLL层基本就是直接New一个DAL的实例就return了,关系数据库已经为我们做了很多工作,所以大部分的工作,就是简单读取然后显示了,因此没有复杂的需求的时候,基于过程也没什么不对,面向过程也没什么不对,实用是压倒一切的因素。

     


    原帖:http://www.cnblogs.com/seesea125/archive/2012/04/03/2431176.html

    展开全文
  • 怎样使用类和对象

    2018-03-08 08:57:39
    调用类里的方法常用的new一个新对象通过对象调用如果方法为静态的,直接类名().方法();c++不实例化一个类调用他的成员方法普通的方法必须通过实例化的对象调用,但声明为static类型的方法属于类,不是对象的可以...

    调用类里的方法常用的有

    • new一个新对象通过对象调用
    • 如果方法为静态的,直接类名().方法();

    c++不实例化一个类能调用他的成员方法

    普通的方法必须通过实例化的对象调用,但声明为static类型的方法属于类,不是对象的可以直接类名调用。


    类方法可以通过类名或实例进行访问,这是语法规定,一个类方法不管是通过类名或实例访问,访问多少次他们始终都是指向同一段代码。



    声明类时对数据成员初始化是错误的,因为类不是一个实体,而是一种抽象类型。不占空间,无处容纳数据。

    构造函数:

    • 声明类定义成员函数,向数据成员赋值。
    • 声明类时不允许对数据成员赋值,
    • 可在构造函数中赋值,作用是对对象初始化,构造函数可在类内或类外定义,类外定义时要加类名和域限定符::,
    • 在建立对象时为对象分配存储单元

    构造函数的重载:构造函数函数名相同,参数不同

    对象指针:指向对象的指针

    • 定义指向公用成员函数指针变量的一般形式:数据类型名 (类名::*指针变量名)(参数列表);

    void (time::*p2)();//p2为指向time类中公用成员函数的指针变量。

    • 指针变量名=&类名::成员函数名;

    this指针:指向本类对象的指针,它的值是当前被调用的成员函数所在的对象的起始地址





    展开全文
  • 注:本文来源 《 java怎样将一组对象传入Oracle存储过程 》java怎样将一组对象传入Oracle存储过程 java怎样将一组对象传入Oracle存储过程。须要注意的是jar包是要求的,假设使用不当会导致仅仅数字传过去,...

    注:本文来源 《  java怎样将一组对象传入Oracle存储过程  》

    java怎样将一组对象传入Oracle存储过程

    java怎样将一组对象传入Oracle存储过程。须要注意的是jar包是有要求的,假设使用不当会导致仅仅有数字能传过去,字符串传只是去。

    假设是Oracle11g则须要选用例如以下的jar包,F:\app\Administrator\product\11.2.0\dbhome_1\jlib\orai18n.jar、D:\program\weblogic\oracle_common\modules\oracle.jdbc_11.2.0\ojdbc6.jar

     

    1:存储过程

      1 CREATE OR REPLACE TYPE TEST_OBJECT AS OBJECT
      2 (
      3   id number,
      4   name varchar2(32)
      5 );
      6 CREATE OR REPLACE TYPE TABLES_ARRAY AS VARRAY(100) OF TEST_OBJECT;
      7 drop table test purge;
      8 create table test
      9 (
     10   id number,
     11   name varchar2(32)
     12 );
     13 create or replace procedure t_list_to_p(arr_t in tables_array)
     14 is
     15 begin
     16   for i in 1..arr_t.count loop
     17       insert  into test values(arr_t(i).id,arr_t(i).name);
     18   end loop;
     19   commit;
     20 end t_list_to_p;


    2:Java 实现逻辑代码

      1 import java.sql.CallableStatement;
      2 import java.sql.Connection;
      3 import java.sql.DriverManager;
      4 import java.sql.SQLException;
      5 import java.util.ArrayList;
      6 import java.util.List;
      7 import oracle.sql.ARRAY;
      8 import oracle.sql.ArrayDescriptor;
      9 import oracle.sql.STRUCT;
     10 import oracle.sql.StructDescriptor;
     11 
     12 public class TestListToProcedure {
     13     static final String driver_class  = "oracle.jdbc.driver.OracleDriver";
     14     static final String connectionURL = "jdbc:oracle:thin:@10.150.15.150:1521:orcl";
     15     static final String userID        = "test";
     16     static final String userPassword  = "test";
     17     public void runTest() {
     18         Connection  con = null;
     19         CallableStatement stmt = null ;
     20         try {
     21             Class.forName (driver_class).newInstance();
     22             con = DriverManager.getConnection(connectionURL, userID, userPassword);
     23             StructDescriptor tDescriptor = StructDescriptor.createDescriptor("TEST_OBJECT", con);
     24         	List<STRUCT> structs = new ArrayList<STRUCT>();
     25         	Object[] 	tObject  = null ;
     26         	//能够将系统中VO,DTO转化成Object对象,先创建struts
     27         	for(int i = 0; i<10; i++){
     28         		tObject = new Object[2];
     29         		tObject[0] = i;
     30         		tObject[1] = "name"+i;
     31                 STRUCT tStruct = new STRUCT(tDescriptor, con, tObject);
     32                 structs.add(tStruct);
     33         	}
     34         	ArrayDescriptor arrayDescriptor = ArrayDescriptor.createDescriptor("TABLES_ARRAY", con);
     35         	ARRAY tArray = new ARRAY(arrayDescriptor, con, structs.toArray());
     36             stmt = con.prepareCall("{call t_list_to_p(?
     37 )}");  
     38             stmt.setArray(1, tArray);
     39             stmt.execute();
     40         }  catch (SQLException e) {
     41             e.printStackTrace();
     42         } catch (Exception e) {
     43             e.printStackTrace();
     44         }finally{
     45         	if(stmt != null){
     46         		try {
     47 					stmt.close();
     48 				} catch (SQLException e) {
     49 					e.printStackTrace();
     50 				}
     51         	}
     52         	if(con != null){
     53         		try {
     54         			con.close();
     55 				} catch (SQLException e) {
     56 					e.printStackTrace();
     57 				}
     58         	}
     59         }
     60     }
     61     public static void main(String[] args) {
     62     	TestListToProcedure testListToProcedure = new TestListToProcedure();
     63     	testListToProcedure.runTest();
     64     }
     65 
     66 }
     67 
     68 

    转载于:https://www.cnblogs.com/ios9/p/8857402.html

    展开全文
  • 在计算机发展的早期阶段,硬件的发展速度慢,容量小,所以软件开发人员写起代码里对 byte、bit 都是「斤斤计较」,这才使用写出来的应用在我们今天看起来那么小的,配置那么低的硬件中运行...

    在计算机发展的早期阶段,硬件的发展速度慢,容量小,所以软件开发人员写起代码里对 byte、bit 都是「斤斤计较」,这才使用写出来的应用能在我们今天看起来那么小的,配置那么低的硬件中运行良好,同时效果惊人。

    那么计算机发展到今天,硬件看似配置越来越高,但依然架不住你随意写,搞不好应用就挂了。另外像游戏等一些行业还是「锱铢必较」,让应用能 稳定的运行。在Java 应用里,要想精确计算,需要对于对象的占用大小做到心里有数。那这篇文章一起来看看, 在 Java 的世界里,一个对象的大小究竟是多少呢?有哪些方式能够计算对象大小。

    要看一个对象的大小,首先需要看Java 运行的平台是 32位还是 64位的 ,其次还要看对象内有多少属性(field)。最后还有一些 JVM 自身需要 在对象里记录的信息,比如说有GC的状态、同步状态、数组长度等等多种信息。这些项汇总求和,基本就是一个对象的大小了。不过VM为了效率,会采用固定长度,比如 8 位的整数倍来统一存储。这种情况下,如果原对象大小不足时,就会扩展对齐来存储。

    好的,下面来看下 JVM 里,一个Java 对象大小占用多少。

    由于现在基本操作系统基本都是64位,咱们后面都以64位 JVM 来说明。

    首先来看两个例子

    public class App {}
    
     public class App {    private byte a;    private int b;}
    

    例子1里, App 这个对象占用内存大小是多少 byte 呢?答案是 16。例子2 又是多少呢?答案是 24。

    这里是怎么计算的呢?

    计算方式

    和开头的文字描述类似,在Java 里一个对象大小,是由这些内容组成

    一个对象Object 大小 = Header + Primitive Fields + Reference Fields + Alignment & Padding`

    其中的 Header 部分,就是 JVM 用于记录特定信息的,一版也叫做 object header,在 OpenJDK 的汇总页里,描述是这样的:

    Common structure at the beginning of every GC-managed heap object. (Every oop points to an object header.) Includes fundamental information about the heap object's layout, type, GC state, synchronization state, and identity hash code. Consists of two words. In arrays it is immediately followed by a length field. Note that both Java objects and VM-internal objects have a common object header format.

    我们看到 object header 由这些部分组成:

    • mark word

    • klass pointer

    • (Optinal) 如果是数组,会记录数组的长度

    mark word

    The first word of every object header. Usually a set of bitfields including synchronization state and identity hash code. May also be a pointer (with characteristic low bit encoding) to synchronization related information. During GC, may contain GC state bits.

    klass pointer

    The second word of every object header. Points to another object (a metaobject) which describes the layout and behavior of the original object. For Java objects, the "klass" contains a C++ style "vtable".

    总结一下,对象头里,基本是 GC的状态、同步状态、identity hash code,数组长度,以及 class 元信息的指针。

    header 的长度由两个 word 组成。mark word 在 64位VM里,长度是 8 bytes。klass pointer 的长度64位VM下受参数-XX:+UseCompressedOops配置控制, 可能是 4 bytes,也可能是8 bytes。

    例子1,我们看关闭情况-XX:-UseCompressedOops

    OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           38 c4 6a 97 (00111000 11000100 01101010 10010111) (-1754610632)
         12     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    

    16 bytes 全都是对象头。

    如果打开,则 object header 占 12 个bytes, 另外4个会补齐。

    OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           05 c0 00 f8 (00000101 11000000 00000000 11111000) (-134168571)
         12     4        (loss due to the next object alignment)
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    

    例子2,输出是这样:

    OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
         12     4    int App.b                                     0
         16     1   byte App.a                                     0
         17     7        (loss due to the next object alignment)
    Instance size: 24 bytes
    Space losses: 0 bytes internal + 7 bytes external = 7 bytes total
    

    增加了 field 的占用, 这里的占用大小,就是咱们常说的 基本数据类型 的大小。如果有对象引用类型,就再加上这些的大小即可。

    工具

    下面的这些工具及方式,可用来计算对象的大小。

    1. JOL

    JOL 是 OpenJDK 提供的一个工具,在项目中添加依赖后可直接使用。

    <dependency>
        <groupId>org.openjdk.jol</groupId>
        <artifactId>jol-core</artifactId>
        <version>0.9</version>
    </dependency>
    

    然后代码里直接输出即可

    public class App {
        private byte a;
        private int b;    
        public static void main(String[] args) {
            // 这里就会输出和上面类似的内容
            System.out.println(ClassLayout.parseClass(new App()).toPrintable()); 
        }
    }
    
    1. Instrument

    在 Instrument 包的 Instrumentation类内,有一个可以直接获取对象大小的方法,注释如下

     /**
         * Returns an implementation-specific approximation of the amount of storage consumed by
         * the specified object. The result may include some or all of the object's overhead,
         * and thus is useful for comparison within an implementation but not between implementations.
         *
         * The estimate may change during a single invocation of the JVM.
         *
         * @param objectToSize     the object to size
         * @return an implementation-specific approximation of the amount of storage consumed by the specified object
         * @throws java.lang.NullPointerException if the supplied Object is <code>null</code>.
         */
    

    那怎样拿到 Instrument,从而调用这个方法,一般是通过 Agent attach 到 VM上来得到,一种是Agent 实现premain方法,一种是agentMain方法,区别在于attach的时机。

    比如你自己定义了一个Agent 的 jar

    import java.lang.instrument.Instrumentation;
    
    
    public class ObjectSizeFetcher {
        private static Instrumentation instrumentation;
    
    
        public static void premain(String args, Instrumentation inst) {
            instrumentation = inst;
        }
    
    
        public static long getObjectSize(Object o) {
            return instrumentation.getObjectSize(o);
        }
    }
    

    后面咱们在代码里直接静态调用 getObjectSize 方法就行了。

    1. SA

    我之前的文章(Java虚拟机的显微镜 Serviceability Agent)里介绍过 SA(Serviceablity Agent), 通过 SA,可以做到许多剖析 JVM 的事情。观察对象的组成和大小当然也不在话下。

    通过SA来观察上面例子2,效果是这样的:

    咱们能看到,整个对象先是_mark(mark word), 之后是 compressed klass(klass pointer ), 再后面是实例包含的属性。 如果红框所示,在  klass pointer 里面包含一个 _layout_helper,显示的就是该对象的大小。

    此外,在SA里的 Console 里,可以像命令行一样交互,也可以显示对象的大小。

    PS: 对于对象的大小,JVM在初始化分配的时候,会对 field 有个「重排序」,给 field 的分配排序,从而节省空间。比如先分配byte 或者 boolean 之后,再分配 int 这些,那 byte 之后可能需要增加 3 bytes 进行 padding,重排序可以减小空间占用。

    比如有这些属性:

    public class App {    private byte a;    private int b;    private boolean c;    private float d;    private char e = 'a';}
    
    OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
          0     4           (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4           (object header)                           61 c1 00 f8 (01100001 11000001 00000000 11111000) (-134168223)
         12     4       int App.b                                     0
         16     4     float App.d                                     0.0
         20     2      char App.e                                     a
         22     1      byte App.a                                     0
         23     1   boolean App.c                                     false
    Instance size: 24 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    

    在输出对象内容,我们发现,并不是按属性的声明顺序来分配的,这样只占用24 bytes,如果按声明顺序,那应该先分配byte, 之后再分配 int 这样为了对齐,会额外增加 3 个 bytes的(alignment/padding gap)最后可能会占用到32bytes。

    为了减少空间浪费,一般情况下,field分配的优先依次顺序是:

    double > long > int > float > char > short > byte > boolean > object reference。

    这里有个基本的原则是:尽可能先分配占用空间大的类型。


    我们公司不少部门都在招聘,另外看到不少前同事,朋友等所在公司也都在招聘,有社招,也有应届生和实习招聘,基本都是BATJ等大厂,所以特意创建了一个免费的知识星球「互联网求职」圈子。如果你在求职中,在招聘或在找内推,欢迎加入

    我会把这些招聘的信息发布到里面。后面有时间的话,会把关于简历、求职等一些共性的问题提提建议之类的。大家也可以一起交流,也更便于历史内容保存与查找。

    当然也欢迎加我微信,拉个微信群实时交流。 

    看点别的

    IO 多路复用是什么意思?

    问题诊断神器BTrace

    Java七武器系列霸王枪 -- 线程状态分析 jstack

    官方App,GitHub 能随身携带了

    Tomcat的异步Servlet实现原理

    阿里问题定位神器 Arthas 的骚操作,定位线上BUG,超给力

    监控诊断工具 Arthas 源码原理分析

    自学三个月,成功面试大厂路线图

    Java虚拟机的显微镜 Serviceability Agent

    怎样回答技术面试题?

    怎样了解你的线程在干嘛?

    从0到1的微服务实践和优化思路

    怎样设计一个好用的短链接服务?

    更多常见问题,请关注公众号,在菜单「常见问题」中查看。

    源码|实战|成长|职场

    这里是「Tomcat那些事儿

    请留下你的足迹

    我们一起「终身成长」

    展开全文
  • 在ZBrush®中两种方法可以使用复数对象即“多边形组”和“次工具”。  什么是复数对象?  什么是我们常说的复数对象呢?一个在ZBrush里的模型只有一个多边形面组成就是单一对象。模型如果是由两个或更多多边形...
  • 例如,如果您想确认用户是否已从主页进入了您的应用程序,以便收到一个客户 ID,则可以检验他们是否客户 ID 号;如果没有,就可以将其重定向到主页。以下就是具体例子: ("CustomerID") = 0 Then Respon
  • 第二章 找对象 什么让你放心 第一节 司马光的“才德理念” 才德全尽谓之圣人,才德兼亡谓之愚人,德胜才谓之君子,才胜得谓之小人 -------司马光 一个人头脑聪明,洞察力,强悍而又毅力,这是他的能力;...
  • 怎样选择结婚对象(正常人)

    千次阅读 2013-11-21 18:11:58
    今天晚上,得知我最好的朋友离婚了。...我开这个帖的目的,就是希望更多的人把握自己的婚姻。就算我说的都是废话,如果引起朋友们在婚前对婚姻多一些思考,就达到目的了。  每个人对婚姻的
  • 我需要用a2自定义类的中的数据与a1中的数据进行比较.(也就是要把两个对象的值合并到一个对象中进行比较.请问在初始化时该怎么写?) 如果a1=a2,则a1中的数据被a2中的数据库覆盖,为null, 如果a2=a1,则a2中的数据被a1...
  • 3.1 首先不在类的声明中对数据成员进行初始化,因为类只是一种抽象类型并不是一个...否则我们就需要用类似set_time这种成员函数的方式来进行初始化,但是当该类多个对象(外),且类中的数据成员比较多时,程序...
  • 虚拟机遇到一条new指令时,首先将去检查这个指令的参数是否在常量池中定位到这个类的符号引用,并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有,必须先执行相应的类加载过程。 2. 分配...
  • 我们知道拷贝构造函数两种“默默”的方式被调用 1. 想函数传入 值参数 2. 函数返回 值类型 ...2. 当对象的拷贝构造函数声明成为explicit(不被隐式调用时),函数返回时会使用move构造函数。 先看开始的
  • 仅仅说,用C++/Java这样的语法来实现面向对象会更easy、更自然一些。 在本节中。就展示怎样在C语言中实现面向对象编程。这是一件吃力的工作。写这些的目的两个: ① 更好的掌握C++中的class的概念。学习了本章...
  • 关于OOD,我们已经了许多成果丰硕的讨论,我觉得人可能发现这是一个学习OOD有趣的方式,所以我想我应该分享出来。   下面是我们的谈话步骤:   话题:介绍面向对象设计   丈夫:亲爱的,让我们开始学习...
  • 反射做不到.Thread里只提供方法名,不过既然方法名,是不是里面得到过Method对象? 咱也问,方法内部获取当前方法对象?求哪位解答
  • 1.只存在于堆: ...另外,将构造函数定义为private一个副作用:该类不被继承。 2.只存在于栈: 将类中的operator new定义为private即可 参考:https://www.cnblogs.com/conard/p/4857315.html ...
  • 由于我早年在软件开发的经验,我总是发现无论一个技术问题看上去多么难搞,只要从现实生活的角度去解释或用对话的方式去讨论总让它变得更简单。关于OOD,我们已经了许多成果丰硕的讨论,我觉得人可能发现这是...
  • 在看这篇文章之前,啰嗦一句:如果你死记硬背下面所说的流程等于白看,就算现在记住了,一个礼拜后呢,一个月后你又记得多少,因为对象创建过程这个知识点平常的工作中基本不会涉及到,太底层了,背熟的知识点不...
  • 来源开发界 http://www.kaifajie.cn 原文:...   ...在开发中,本人遇到这样问题想在两个activity之间传递某个自定义类对象,但是使用Bundle发现里面只能传送已经封装好的int,float,String等类型,
  • 用来存放数组集合或存放对象(实际存放的是地址),但它长度可变,数组不变。ArrayList添加add(),删除remove(),获取大小xize(),特定元素get()方法。 ArrayList<泛型表达式(数据同一格式)>。...
  • 由于我早年在软件开发的经验,我总是发现无论一个技术问题看上去多么难搞,只要从现实生活的角度去解释或用对话的方式去讨论总让它变得更简单。关于OOD,我们已经了许多成果丰硕的讨论,我觉得人可能发现这是...
  • 由于我早年在软件开发的经验,我总是发现无论一个技术问题看上去多么难搞,只要从现实生活的角度去解释或用对话的方式去讨论总让它变得更简单。关于OOD,我们已经了许多成果丰硕的讨论,我觉得人可能发现这是...
  • 面向对象

    2019-02-24 11:13:00
     面向对象:实现某种功能时,不看重具体的过程和步骤,而是看重谁帮我做这些事情。   类与对象的关系:  类里面属性,行为。  属性:事务的特征信息,是什么 行为:事物的动作行动方案,做什...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,247
精华内容 498
关键字:

怎样能有对象