请问JAVA中怎样找对象? (请问jac.是什么牌汽车)
本文目录导航：
请问JAVA中怎样找"对象"?
剖析一下JAVA中对象创立和初始化环节中触及的相关概念疑问，java中栈(stack)与堆(heap)，对象、援用、句柄的概念。
@Author:ZJ 06-11-25Blog:中的数据类型Java中有3个数据类型：基本数据类型(在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型)、援用类型和null类型。
其中，援用类型包括类类型(含数组)、接口类型。
下列语句声明了一些变量：以下是援用片段：int k ; A a; //a是A数据类型的对象变量名。
B b1,b2,…,b;// 假定B是形象类或接口。
String s; 留意：从数据类型与变量的角度看，基本数据类型变量k、类类型变量a和s、形象类或接口类型变量b(1万个)，它们都是变量(标识符)。
2.关于句柄(handle)为了区别援用类型的变量标识符和基本数据类型变量标识符，咱们特意的经常使用Handle来称说援用类型的变量标识符。
上方例子中b1至b、a、s都是Handle。
Handle直观的看就是手柄、把手，咱们采用计算机界罕用的中文翻译“句柄”。
2.1【Windows编程中的】句柄的含意句柄是WONDOWS用来标识被运行程序所建设或经常使用的对象的惟一整数，WINDOWS经常使用各种各样的句柄标识诸如运行程序实例，窗口，控制，位图，GDI对象等等。
WINDOWS句柄有点象C言语中的文件句柄。
从上方的定义中的咱们可以看到，句柄是一个标识符，是拿来标识对象或许名目的，它就象咱们的姓名一样，每团体都会有一个，不同的人的姓名不一样，但是，也或许有一个名字和你一样的人。
从数据类型过去看它只是一个16位的无符号整数。
运行程序简直总是经过调用一个WINDOWS函数来取得一个句柄，之后其余的WINDOWS函数就可以经常使用该句柄，以援用相应的对象。
假构想更透彻一点地意识句柄，我可以通知大家，句柄是一种指向指针的指针。
咱们知道，所谓指针是一种内存地址。
运行程序启动后，组成这个程序的各对象是驻留在内存的。
假设繁难地理解，似乎咱们只需获知这个内存的首地址，那么就可以随时用这个地址访问对象。
但是，假设您真的这样以为，那么您就大错特错了。
咱们知道，Windows是一个以虚构内存为基础的操作系统。
在这种系统环境下，Windows内存治理器经常在内存中来回移动对象，依此来满足各种运行程序的内存须要。
对象被移动象征着它的地址变动了。
假设地址总是如此变动，咱们该到哪里去找该对象呢?
如何了解Java面向对象?
Java是一种面向对象的程序开发言语，准确的了解java的面向对象才干更好更快地把握JAVA的编程思想和方法，本文昌平北大青鸟java培训专家为大家引见java面向对象，协助大家更好的了解java。
1、什么是对象？
首先要说明一点，对象不是java的，理想上他只是一种概念，一种用于处置疑问的程序设计的思想方法。
要了解对象就必需得要和面向对象联合起来。
在面向对象中把某一类事物所共有的属性和行为形象进去之后就构成了一个类。
而类的一个实践的例子就叫做对象。
所以从上可以看出类和对象之间存在着这样一种相关：类是具有独特的属性称号和行为的一组对象的形象，而对象则是一个类的实在的例子。
类是理想环球或思想环球中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一同。
类形容了具有相反个性（数据元素、形态变量）和行为（对数据元素、形态变量的操作）的对象汇合，假设我须要某个具有肯定配置的工具，那么我可自定义这个类，外面有我须要的数据，还有让这个类提供的配置。
对象是具有类类型的变量。
类和对象是面向对象编程技术中的最基本的概念。
类是对象的形象，而对象是类的详细实例。
类是形象的，不占用内存，而对象是详细的，占用存储空间。
类是用于创立对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
JAVA是一种面向对象的程序设计言语，对象是由类形象进去的，一切的疑问都是经过对象来处置，对象可以操作类的属性和方法来处置疑问，所以了解对象的发生、操作和沦亡是十分必要的。
对象可以以为是在一类事物中形象出某一个特例，经过这个特例来处置这类事物出现的疑问，在Java言语中经过new操作符来创立对象。
2、对象和对象援用
如下表白式：Aa1=newA;它代表A是类，a1是援用，a1不是对象，newA才是对象，a1援用指向newA这个对象。
在JAVA里，“=”不能被看成是一个赋值语句，它不是在把一个对象赋给另外一个对象，它的执行环节实质上是将左边对象的地址传给了左边的援用，使得左边的援用指向了左边的对象。
JAVA外表上看起来没有指针，但它的援用其实质就是一个指针，援用外面寄存的并不是对象，而是该对象的地址，使得该援用指向了对象。
在JAVA里，“=”语句不应该被翻译成赋值语句，由于它所执行的确实不是一个赋值的环节，而是一个传地址的环节，被译成赋值语句会形成很多曲解，译得不准确。
再如：Aa2;它代表A是类，a2是援用，a2不是对象，a2所指向的对象为空null;
再如：a2=a1;它代表，a2是援用，a1也是援用，a1所指向的对象的地址传给了a2(传址），使得a2和a1指向了同一对象。
综上所述，可以繁难的记为，在初始化时，“=”语句左边的是援用，左边new进去的是对象。
在前面的左右都是援用的“=”语句时，左右的援用同时指向了左边援用所指向的对象。
再所谓实例，其实就是对象的同义词。
3、Java承袭性剖析
承袭是面向对象最清楚的一个个性。
承袭是从已有的类中派生出新的类，新的类能排汇已有类的数据属性和行为，并能裁减新的才干。
Java承袭是经常使用已存在的类的定义作为基础建设新类的技术，新类的定义可以参与新的数据或新的配置，也可以用父类的配置，但不能选择性地承袭父类。
这种技术使得复用以前的代码十分容易，能够大大缩短开发周期，降落开发费用。
承袭是java面向对象编程技术的一块基石，由于它准许创立分等级档次的类。
承袭可以了解为一个对象从另一个对象失掉属性的环节。
假设类A是类B的父类，而类B是类C的父类，咱们也称C是A的子类，类C是从类A承袭而来的。
在Java中，类的承袭是繁多承袭，也就是说，一个子类只能领有一个父类。
承袭中最经常常使用的两个关键字是extends（IS-A，是一个什么物品）和implements（Has-A，有一个什么配置）。
这两个关键字的经常使用选择了一个对象和另一个对象能否是IS-A(是一个)相关。
昌平北大青鸟java培训专家提示大家，经过经常使用这两个关键字，咱们能成功一个对象失掉另一个对象的属性。
一切Java的类均是由类承袭而来的，所以Object是一切类的后人类，而除了Object外，一切类必需有一个父类。
经过extends关键字可以声明一个类是承袭另外一个类而来的，经过经常使用关键字extends，子类可以承袭父类一切的方法和属性，但是无法经常使用private(私有)的方法和属性。
咱们经过经常使用instanceof操作符，能够确定子类IS-A父类。
Java中对象有什么用？
一切都是对象 “虽然以C++为基础，但Java是一种更纯正的面向对象程序设计言语”。
无论C++还是Java都属于杂合言语。
但在Java中，设计者感觉这种杂兼并不象在C++里那么关键。
杂合言语准许采用多种编程格调；之所以说C++是一种杂合言语，是由于它支持与C言语的向后兼容才干。
由于C++是C的一个超集，所以蕴含的许多个性都是后者不具有的，这些个性使C++在某些中央显得过于复杂。
Java言语首先便假定了咱们只宿愿启动面向对象的程序设计。
也就是说，正式用它设计之前，必需先将自己的思想转入一个面向对象的环球（除非早已习气了这个环球的思想方式）。
只要做好这个预备上班，与其余OOP言语相比，才干体会到Java的易学易用。
在本章，咱们将讨论Java程序的基本组件，并体会为什么说Java乃至Java程序内的一切都是对象。
2.1 用句柄操纵对象 每种编程言语都有自己的数据处置方式。
有些时刻，程序员必需时辰留意预备处置的是什么类型。
您曾应用一些不凡语法直接操作过对象，或处置过一些直接示意的对象吗（C或C++里的指针）？ 一切这些在Java里都失掉了简化，任何物品都可看作对象。
因此，咱们可采用一种一致的语法，任何中央均可照搬不误。
但要留意，虽然将一切都“看作”对象，但操纵的标识符实践是指向一个对象的“句柄”（Handle）。
在其余Java参考书里，还可看到有的人将其称作一个“援用”，甚至一个“指针”。
可将这一情景构想成用遥控板（句柄）操纵电视机（对象）。
只需握住这个遥控板，就相当于把握了与电视机衔接的通道。
但一旦须要“换频道”或许“关小声响”，咱们实践操纵的是遥控板（句柄），再由遥控板自己操纵电视机（对象）。
假设要在房间里到处走走，并想坚持对电视机的控制，那么手上拿着的是遥控板，而非电视机。
此外，即使没有电视机，遥控板亦可独立存在。
也就是说，只是由于领有一个句柄，并不示意必需有一个对象同它衔接。
所以假构想容纳一个词或句子，可创立一个String句柄： String s; 但这里创立的只是句柄，并不是对象。
若此时向s发送一条信息，就会取得一个失误（运转期）。
这是由于s实践并未与任何物品衔接（即“没有电视机”）。
因此，一种更安保的做法是：创立一个句柄时，记住无论如何都启动初始化： String s = asdf; 但是，这里采用的是一种不凡类型：字串可用加引号的文字初始化。
理论，必需为对象经常使用一种更通用的初始化类型。
2.2 一切对象都必需创立 创立句柄时，咱们宿愿它同一个新对象衔接。
理论用new关键字到达这一目的。
new的意思是：“把我变成这些对象的一种新类型”。
所以在上方的例子中，可以说： String s = new String(asdf); 它不只指出“将我变成一个新字串”，也经过提供一个初始字串，指出了“如何生成这个新字串”。
当然，字串（String）并非惟一的类型。
Java配套提供了数量泛滥的现成类型。
对咱们来讲，最关键的就是记住能自行创立类型。
理想上，这应是Java程序设计的一项基本操作，是继续本书后余部分学习的基础。
2.2.1 保管到什么中央 程序运转时，咱们最好对数据保管到什么中央做到成竹在胸。
特意要留意的是内存的调配。
有六个中央都可以保管数据： (1) 寄存器。
这是最快的保管区域，由于它位于和其余一切保管方式不同的中央：处置器外部。
但是，寄存器的数量十分有限，所以寄存器是依据须要由编译器调配。
咱们对此没有直接的控制权，也无法能在自己的程序里找到寄存器存在的任何形迹。
(2) 堆栈。
驻留于惯例RAM（随机访问存储器）区域，但可经过它的“堆栈指针”取得处置的直接支持。
堆栈指针若向下移，会创立新的内存；若向上移，则会监禁那些内存。
这是一种特意快、特意有效的数据保管方式，仅次于寄存器。
创立程序时，Java编译器必需准确地知道堆栈内保管的一切数据的“长度”以及“存在时期”。
这是由于它必需生成相应的代码，以便向上和向下移动指针。
这一限度无疑影响了程序的灵敏性，所以虽然有些Java数据要保管在堆栈里——特意是对象句柄，但Java对象并不放到其中。
(3) 堆。
一种惯例用途的内存池（也在RAM区域），其中保管了Java对象。
和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的中央在于编译器不用知道要从堆里调配多少存储空间，也不用知道存储的数据要在堆里逗留多长的时期。
因此，用堆保管数据时会失掉更大的灵敏性。
要求创立一个对象时，只需用new命令编制相关的代码即可。
执行这些代码时，会在堆里智能启动数据的保管。
当然，为到达这种灵敏性，肯定会付出肯定的代价：在堆里调配存储空间时会花掉更长的时期！ (4) 静态存储。
这儿的“静态”（Static）是指“位于固定位置”（虽然也在RAM里）。
程序运转时期，静态存储的数据将随时等待调用。
可用static关键字指出一个对象的特定元素是静态的。
但Java对象自身永远都不会置入静态存储空间。
(5) 常数存储。
常数值理论直接置于程序代码外部。
这样做是安保的，由于它们永远都不会扭转。
有的常数须要严厉地包全，所以可思考将它们置入只读存储器（ROM）。
(6) 非RAM存储。
若数据齐全独立于一个程序之外，则程序不运转时仍可存在，并在程序的控制范畴之外。
其中两个最关键的例子便是“流式对象”和“固定对象”。
关于流式对象，对象会变成字节流，理论会发给另一台机器。
而关于固定对象，对象保管在磁盘中。
即使程序停止运转，它们仍可坚持自己的形态不变。
关于这些类型的数据存储，一个特意有用的技巧就是它们能存在于其余媒体中。
一旦须要，甚至能将它们复原成个别的、基于RAM的对象。
Java 1.1提供了对Lightweight persistence的支持。
未来的版本甚至或许提供更完整的打算。
2.2.2 不凡状况：关键类型 有一系列类需特意看待；可将它们构想成“基本”、“关键”或许“主”（Primitive）类型，启动程序设计时要频繁用到它们。
之所以要特意看待，是由于用new创立对象（特意是小的、繁难的变量）并不是十分有效，由于new将对象置于“堆”里。
关于这些类型，Java采用了与C和C++相反的方法。
也就是说，不是用new创立变量，而是创立一个并非句柄的“智能”变量。
这个变量容纳了详细的值，并置于堆栈中，能够更高效地存取。
Java选择了每种关键类型的大小。
就象在大少数言语里那样，这些大小并不随着机器结构的变动而变动。
这种大小的无法更矫正是Java程序具有很强移植才干的要素之一。
主类型 大小 最小值 最大值 封装器类型 boolean 1-bit – – Boolean char 16-bit Unicode 0 Unicode 216- 1 Character byte 8-bit -128 +127 Byte[11] short 16-bit -215 +215 – 1 Short1 int 32-bit -231 +231 – 1 Integer long 64-bit -263 +263 – 1 Long float 32-bit IEEE754 IEEE754 Float double 64-bit IEEE754 IEEE754 Double void – – – Void1 ①：到Java 1.1才有，1.0版没有。
数值类型全都是有符号（正负号）的，所以不用吃力寻觅没有符号的类型。
主数据类型也领有自己的“封装器”（wrapper）类。
这象征着假构想让堆内一个非关键对象示意那个主类型，就要经常使用对应的封装器。
例如： char c = x; Character C = new Character(c); 也可以直接经常使用： Character C = new Character(x); 这样做的要素将在以后的章节里解释。
1. 高精度数字Java 1.1参与了两个类，用于启动高精度的计算：BigInteger和BigDecimal。
虽然它们大抵可以划分为“封装器”类型，但两者都没有对应的“主类型”。
这两个类都有自己不凡的“方法”，对应于咱们针对主类型执行的操作。
也就是说，能对int或float做的事件，对BigInteger和BigDecimal一样可以做。
只是必需经常使用方法调用，不能经常使用运算符。
此外，由于关涉更多，所以运算速度会慢一些。
咱们就义了速度，但换来了精度。
BigInteger支持恣意精度的整数。
也就是说，咱们可准确示意恣意大小的整数值，同时在运算环节中不会失落任何信息。
BigDecimal支持恣意精度的定点数字。
例如，可用它启动准确的币值计算。
至于调用这两个类时可选择的构建器和方法，请自行参考联机协助文档。
2.2.3 Java的数组简直一切程序设计言语都支持数组。
在C和C++里经常使用数组是十分风险的，由于那些数组只是内存块。
若程序访问自己内存块以外的数组，或许在初始化之前经常使用内存（属于惯例编程失误），会发生无法预测的结果（注释②）。
②：在C++里，应尽量不要经常使用数组，换用规范模板库（Standard TemplateLibrary）里更安保的容器。
Java的一项关键设计指标就是安保性。
所以在C和C++里困扰程序员的许多疑问都未在Java里重复。
一个Java可以保障被初始化，而且无法在它的范畴之外访问。
由于系统智能启动范畴审核，所以肯定要付出一些代价：针对每个数组，以及在运转时期对索引的校验，都会形成大批的内存开支。
但由此换回的是更高的安保性，以及更高的上班效率。
为此付出少许代价是值得的。
创立对象数组时，实践创立的是一个句柄数组。
而且每个句柄都会智能初始化成一个不凡值，并带有自己的关键字：null（空）。
一旦Java看到null，就知道该句柄并未指向一个对象。
正式经常使用前，必需为每个句柄都调配一个对象。
若试图经常使用依然为null的一个句柄，就会在运转期报告疑问。
因此，典型的数组失误在Java里就失掉了防止。
也可以创立主类型数组。
雷同地，编译器能够担保对它的初始化，由于会将那个数组的内存划分红零。
数组疑问将在以后的章节里详细讨论。
2.3 相对不要肃清对象在大少数程序设计言语中，变量的“存在时期”（Lifetime）不时是程序员须要着重思考的疑问。
变量应继续多长的时期？假构想肃清它，那么何时启动？在变量存在时期上牵扯不清会形成少量的程序失误。
在上方的小节里，将阐示Java如何协助咱们成功一切肃清上班，从而极大了简化了这个疑问。
2.3.1 作用域大少数程序设计言语都提供了“作用域”（Scope）的概念。
关于在作用域里定义的名字，作用域同时选择了它的“可见性”以及“存在时期”。
在C，C++和Java里，作用域是由花括号的位置选择的。
参考上方这个例子：{int x = 12;/* only x available */{int q = 96;/* both x & q available */}/* only x available *//* q “out of scope” */}作为在作用域里定义的一个变量，它只要在那个作用域完结之前才可经常使用。
在上方的例子中，缩进排版使Java代码更易辨读。
由于Java是一种方式自在的言语，所以额外的空格、制表位以及回车都不会对结果程序形成影响。
留意虽然在C和C++里是非法的，但在Java里不能象上方这样书写代码：{int x = 12;{int x = 96; /* illegal */}}编译器会以为变量x已被定义。
所以C和C++能将一个变量“暗藏”在一个更大的作用域里。
但这种做法在Java里是不准许的，由于Java的设计者以为这样做使程序发生了混杂。
2.3.2 对象的作用域Java对象不具有与主类型一样的存在时期。
用new关键字创立一个Java对象的时刻，它会超出作用域的范畴之外。
所以假若经常使用上方这段代码：{String s = new String(a string);} /* 作用域的终点 */那么句柄s会在作用域的终点处隐没。
但是，s指向的String对象依然占据着内存空间。
在上方这段代码里，咱们没有方法访问对象，由于指向它的惟逐一个句柄已超出了作用域的边界。
在前面的章节里，大家还会继续学习如何在程序运转时期传递和复制对象句柄。
这样形成的结果便是：关于用new创立的对象，只需咱们情愿，它们就会不时保管下去。
这个编程疑问在C和C++里特意突出。
看来在C++里遇到的费事最大：由于不能从言语取得任何协助，所以在须要对象的时刻，基本无法确定它们能否可用。
而且更费事的是，在C++里，一旦上班成功，必需保障将对象肃清。
这样便带来了一个幽默的疑问。
假设Java让对象依然故我，怎样才干防止它们少量充满内存，并最终形成程序的“凝结”呢。
在C++里，这个疑问最令程序员头痛。
但Java以后，状况却出现了改观。
Java有一个特意的“渣滓搜集器”，它会查找用new创立的一切对象，并别离其中哪些不再被援用。
随后，它会智能监禁由那些闲置对象占据的内存，以便能由新对象经常使用。
这象征着咱们基本不用操心内存的回收疑问。
只需繁难地创立对象，一旦不再须要它们，它们就会智能离去。
这样做可防止在C++里很经常出现的一个编程疑问：由于程序员遗记监禁内存形成的“内存溢出”。
2.4 新建数据类型：类假设说一切物品都是对象，那么用什么选择一个“类”（Class）的外观与行为呢？换句话说，是什么建设起了一个对象的“类型”（Type）呢？大家或许猜想有一个名为“type”的关键字。
但从历史看来，大少数面向对象的言语都用关键字“class”表白这样一个意思：“我预备通知你对象一种新类型的外观”。
class关键字太罕用了，以致于本书许多中央并没有用粗体字或双引号加以强调。
在这个关键字的前面，应该追随新数据类型的称号。
例如：class ATypeName {/*类主体置于这里}这样就引入了一种新类型，接上去便可用new创立这种类型的一个新对象：ATypeName a = new ATypeName();在ATypeName里，类主体只由一条注释构成（星号和斜杠以及其中的内容，本章前面还会详细讲述），所以并不能对它做太多的事件。
理想上，除非为其定义了某些方法，否则基本不能批示它做任何事件。
2.4.1 字段和方法定义一个类时（咱们在Java里的所有上班就是定义类、制造那些类的对象以及将信息发给那些对象），可在自己的类里设置两种类型的元素：数据成员（有时也叫“字段”）以及成员函数（理论叫“方法”）。
其中，数据成员是一种对象（经过它的句柄与其通讯），可以为任何类型。
它也可以是主类型（并不是句柄）之一。
假设是指向对象的一个句柄，则必需初始化那个句柄，用一种名为“构建器”（第4章会对此详述）的不凡函数将其与一个实践对象衔接起来（就象早先看到的那样，经常使用new关键字）。
但若是一种主类型，则可在类定义位置直接初始化（正如前面会看到的那样，句柄亦可在定义位置初始化）。
每个对象都为自己的数据成员保有存储空间；数据成员不会在对象之间共享。
上方是定义了一些数据成员的类示例：class DataOnly {int i;float f;boolean b;}这个类并没有做任何实质性的事件，但咱们可创立一个对象：DataOnly d = new DataOnly();可将值赋给数据成员，但首先必需知道如何援用一个对象的成员。
为到达援用对象成员的目的，首先要写上对象句柄的名字，再追随一个点号（句点），再追随对象外部成员的名字。
即“对象句柄.成员”。
例如：d.i = 47;d.f = 1.1f;d.b = false;一个对象也或许蕴含了另一个对象，而另一个对象里则蕴含了咱们想修正的数据。
关于这个疑问，只需坚持“衔接句点”即可。
例如 = 100;除容纳数据之外，DataOnly类再也不能做更多的事件，由于它没有成员函数（方法）。
为正确了解上班原理，首先必需知道“自变量”和“前往值”的概念。
咱们马上就会详加解释。
1. 主成员的自动值若某个主数据类型属于一个类成员，那么即使不明白（显式）启动初始化，也可以保障它们取得一个自动值。
主类型 自动值Boolean falseChar \u0000(null)byte (byte)0short (short)0int 0long 0Lfloat 0.0fdouble 0.0d一旦将变量作为类成员经常使用，就要特意留意由Java调配的自动值。
这样做可保障主类型的成员变量必需失掉了初始化（C++不具有这一配置），可有效抑止多种相关的编程失误。
但是，这种保障却并不实用于“部分”变量——那些变量并非一个类的字段。
所以，假若在一个函数定义中写入下述代码：int x;那么x会失掉一些随机值（这与C和C++是一样的），不会智能初始化成零。
咱们责任是在正式经常使用x前调配一个适当的值。
假设遗记，就会失掉一条编译期失误，通知咱们变量或许尚未初始化。
这种处置正是Java优于C++的体现之一。
许多C++编译器会对变量未初始化收回正告，但在Java里却是失误。
2.5 方法、自变量和前往值迄今为止，咱们不时用“函数”（Function）这个词指代一个已命名的子例程。
但在Java里，更罕用的一个词却是“方法”（Method），代表“成功某事的路径”。
虽然它们表白的实践是同一个意思，但从如今开局，本书将不时经常使用“方法”，而不是“函数”。
Java的“方法”选择了一个对象能够接纳的信息。
经过本节的学习，大家会知道方法的定义有如许繁难！方法的基本组成部分包括名字、自变量、前往类型以及主体。
上繁难是它最基本的方式：前往类型 方法名( /* 自变量列表*/ ) {/* 方法主体 */}前往类型是指调用方法之后前往的数值类型。
显然，方法名的作用是对详细的方法启动标识和援用。
自变量列表列出了想传递给方法的信息类型和称号。
Java的方法只能作为类的一部分创立。
只能针对某个对象调用一个方法（注释③），而且那个对象必需能够执行那个方法调用。
若试图为一个对象调用失误的方法，就会在编译期失掉一条出错信息。
为一个对象调用方法时，须要先列出对象的名字，在前面跟上一个句点，再跟上方法名以及它的参数列表。
亦即“对象名.方法名(自变量1，自变量2，自变量3...)。
举个例子来说，假定咱们有一个方法名叫f()，它没有自变量，前往的是类型为int的一个值。
那么，假定有一个名为a的对象，可为其调用方法f()，则代码如下：int x = a.f();前往值的类型必需兼容x的类型。
象这样调用一个方法的执行理论叫作“向对象发送一条信息”。
在上方的例子中，信息是f()，而对象是a。
面向对象的程序设计理论繁难地演绎为“向对象发送信息”。
③：正如马上就要学到的那样，“静态”方法可针对类调用，毋需一个对象。
2.5.1 自变量列表自变量列表规则了咱们传送给方法的是什么信息。
正如大家或许已猜到的那样，这些信息——似乎Java内其余任何物品——采用的都是对象的方式。
因此，咱们必需在自变量列表里指定要传递的对象类型，以及每个对象的名字。
正如在Java其余中央处置对象时一样，咱们实践传递的是“句柄”（注释④）。
但是，句柄的类型必需正确。
倘若宿愿自变量是一个“字串”，那么传递的必需是一个字串。
④：关于前面提及的“不凡”数据类型boolean，char，byte，short，int，long，，float以及double来说是一个例外。
但在传递对象时，理论都是指传递指向对象的句柄。
上方让咱们思考将一个字串作为自变量经常使用的方法。
上方列出的是定义代码，必需将它置于一个类定义里，否则无法编译：int storage(String s) {return () * 2;}这个方法通知咱们须要多少字节才干容纳一个特定字串里的信息（字串里的每个字符都是16位，或许说2个字节、长整数，以便提供对Unicode字符的支持）。
自变量的类型为String，而且叫作s。
一旦将s传递给方法，就可将它当作其余对象一样处置（可向其发送信息）。
在这里，咱们调用的是length()方法，它是String的方法之一。
该方法前往的是一个字串里的字符数。
经过上方的例子，也可以了解return关键字的运用。
它关键做两件事件。
首先，它象征着“分开方法，我已完工了”。
其次，假定方法生成了一个值，则那个值紧接在return语句的前面。
在这种状况下，前往值是经过计算表白式“()*2”而发生的。
可按自己的欲望前往恣意类型，但倘若不想前往任何物品，就可批示方法前往void（空）。
上方列出一些例子。
boolean flag() { return true; }float naturalLogBase() { return 2.718; }void nothing() { return; }void nothing2() {}若前往类型为void，则return关键字惟一的作用就是分开方法。
所以一旦到达方法末尾，该关键字便不须要了。
可在任何中央从一个方法前往。
但假定已指定了一种非void的前往类型，那么无论从何地前往，编译器都会确保咱们前往的是正确的类型。
到此为止，大家或许已失掉了这样的一个印象：一个程序只是一系列对象的汇合，它们的方法将其余对象作为自己的自变量经常使用，而且将信息发给那些对象。
这种说法大体正确，但经过以后的学习，大家还会知道如何在一个方法里作出决策，做一些更粗疏的基层上班。
至于这一章，只需了解信息传送就足le
phper