试验四
类和对象的创建
一. 类的定义
类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。
类的实现包括两部分：类声明和类体。基本格式为：
修饰符class 类名[extends 父类名] {
/*类体的内容*/
}
1. 类声明
以下是一个类声明的例子。
class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则：
(1) 如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。
(2) 类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。
2. 类体
编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。
类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。
下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。
二. 对象
1. 对象的创建
创建一个对象包括对象的声明和为对象分配内存两个步骤。
(1) 对象的声明。
一般格式为：
类的名字对象名字;
如：
这里People是类的名字，zhubajie是我们声明的对象的名字。
(2) 为声明的对象分配内存。
使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如：
例1：
「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。
2. 对象的使用
对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。
通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。
例2：
程序执行结果如下：
类中的方法可以操作成员变量，当对象调用该方法时，方法中出现的成员变量就是指该对象的成员变量。在上述代码中，当对象zhubajie调用speak方法后，就将自己的头修改成：“歪着头”。同样，对象sunwuk ong调用speak方法后，也将自己的头修改成：“歪着头”。
3. 对象的引用和实体
当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称为该对象的实体，而对象中存放着引用，以确保实体由该对象操作使用。
再以例1中的Point类为例，假如分别使用类的构造方法Point(int x, int y)创建了两个对象p1、p2：
那么内存模型如图4-1-1所示：
图4-1-1 对象内存模式1
假如在程序中使用了下述赋值语句：
p1 = p2;
把p2的引用（p2在内存中的名字）赋给了p1，因此p1和p2本质上是一样的了。虽然在源文件中p1、p2是两个名字，但在系统看来它们的名字是一个：0xDD。系统将取消原来分配给p1的内存，即释放分配给p1的变量。这时如果输出p1.x的结果将是6，而不是12，即p1、p2有相同的实体。内存模式变成如图4-1-2所示：
图4-1-2 对象内存模式2
因此，如果一个类创建的两个对象具有相同的引用，那么就具有完全相同的实体。没有实体的对象称为空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。假如程序中使用了空对象，程序在运行时会出现异常：NullPointerException。由于对象是动态地分配实体，所以Java的编译器对空对象不做检查。因此，在编写程序时要避免使用空对象。
「注」实际上，Java有所谓“垃圾收集”机制，这种机制周期地检测某个实体是否已不再被任何对象所拥有，如果发现这样的实体，就释放实体占有的内存。因此，Java编程人员不必像C++程序员那样，要时刻自己检查哪些对象应该释放内存。在上述程序中，当将p2的引用赋给p1后，最初分配给对象p1的变量（实体）所占有的内存就会被释放。
4. 参数传值
当方法被调用时，如果方法有参数，参数必须要实例化，即参数变量必须有具体的值。在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的副本。例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递值的副本。方法如果改变参数的值，不会影响向参数“传值”的变量的值。
(1) 基本数据类型参数的传值
对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别，比如，不可以向int型参数传递一个float值，但可以向double型参数传递一个float值。
(2) 引用类型参数的传值
Java的引用型数据包括对象、数组以及接口。当参数是引用类型时，“传值”传递的是变量的引用而不是变量所引用的实体。
如果改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化，因为，两个同类型的引用型变量如果具有同样的引用，就会用同样的实体。但是，改变参数的引用不会影响向其传值的变量的引用，如图4-1-3所示：
图4-1-3 引用类型参数的传值
仔细阅读下面的例3，特别注意引用类型参数和基本数据类型参数的区别。
例3：
静态变量与静态方法的设计
static修饰符可以用来修饰类的成员变量、成员方法和代码块。
●用static修饰的成员变量表示静态变量，可以直接通过类名来访问。
●用static修饰的成员方法表示静态方法，可以直接通过类名来访问。
●用static修饰的程序代码块表示静态代码块，当Java虚拟机加载类时，就会执行该代码块。
被static所修饰的成员变量和成员方法表明归某个类所有，它不依赖于类的特定实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定位到它们。
一. static变量
类的成员变量有两种：一种是static修饰的变量，叫类变量或静态变量；另一种是没有被static修饰的变量，叫实例变量。
●静态变量在内存中只有一个拷贝，运行时Java虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。可以直接通过类名访问静态变量。
●对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响。
在类的内部，可以在任何方法内直接访问静态变量；在其他类中，可以通过某个类的类名来访问它的静态变量。例如：
在以下Scope类中定义了静态变量a，在main()方法中采用多种方式访问这个变量，它的最后取值为4。
static变量在某种程度上与其他语言（如C语言）中的全局变量相似。Java语言不支持不属于任何类的全局变量，静态变量提供了这一功能，他有如下两个作用。
● 能被类的所有实例共享，可作为实例之间进行交流的共享数据。
●如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间。例如某种类型的变压器Transformer类，它所接受的最小输入电压为110V，最大输入电压为220V，输出电压为15V，这是对所有变压器Transformer对象适用的属性，可在Transformer类中按如下方式定义它们。
下面再用具体例子说明静态变量的用法。假定有一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到100时，就停止投票。从这个问题领域中抽象出Voter类，代表选民。所有的选民都会改变同一个数据，即投票次数，因此把它定义为静态类型。
此外，最大投票数100是一个适用于所有选民的常量，因此把它定义为静态常量类型。
另外，为了防止选民重复选票，必须保存已经参与投票的选民的信息，可采用一个集合来存放已经投票的选民的对象。
以下代码是Voter类的源程序。
在Voter类的main()方法中，先创建了3个选民，然后让他们依次投票，其中Tom还试图进行重复投票。该程序的运行结果如下：
二. static方法
成员方法分为静态方法和实例方法。用static修饰的方法叫静态方法，或类方法。静态方法也和静态变量一样，不需要创建类的实例，可以直接通过类名来访问。例如：
1. 静态方法可访问的内容
因为静态方法不需要通过它所属的类的任何实例就会被调用，因此在静态方法中不能使用this关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。例如在Voter类中，count变量是静态变量，表示所有的选民的共同投票数，name变量是实例变量，表示每个具体选民对象的名字。以下程序在Voter类的静态方法printVoterResult()中直接访问count和name变量。
不妨用反证法来证明在printVoteResult()方法中不能直接访问name变量或者https://www.doczj.com/doc/d24626594.html,变量。假定以上程序编译成功，那么当Java虚拟机在执行以下代码时会遇到问题。
Java虚拟机在执行静态方法printVoteResult()时，它能顺利地从Voter类方法区内找到count静态变量，而对于name变量或https://www.doczj.com/doc/d24626594.html,变量，Java虚拟机无从判断到底属于哪个Voter对象，Java虚拟机只会在包含Voter类信息的方法区寻找该量，而不会到存放所有Voter对象的堆区去寻找它，所以Java虚拟机无法找到name变量或https://www.doczj.com/doc/d24626594.html,变量。
由此可见，在静态方法中不能直接访问所属类的实例变量或实例方法，因为Java虚拟机无法定位它们。如果程序中出现这样的操作，Java编译器会生成以下编译错误：
那么假如printVoteResult()方法需要访问某个特定Voter对象的name属性，该怎么办呢？必须通过Vote r对象的引用来访问name属性。例如：
以上程序从voters集合中依次取出每个Voter对象，然后打印它的name属性。程序以https://www.doczj.com/doc/d24626594.html,的形式来访问name变量，使Java虚拟机能明确知道到底访问哪个Voter对象的name属性。
静态方法中也不能使用super关键字。例如以下程序是非法的：
super关键字用来访问当前Sub实例从父类Base中继承的方法和属性。既然super关键字与类似的特定实例相关，那么和this关键字一样，在静态方法中也不能使用super关键字。
2. 实例方法可访问的内容
如果一个方法没有用static修饰，那么它就是实例方法。在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。例如Voter类的voteFor()方法就是实例方法。在这个方法中会直接访问c ount静态变量、voter静态变量和name实例变量。
在静态方法main()中创建了一些Voter实例，然后通过实例的引用来访问voteFor()方法。
在执行tom.voteFor()或者mike.voteFor()方法时，Java虚拟机能明确知道到底执行哪个Voter实例的vote For()方法，因此在方法内访问name变量时，它会顺利地从堆区内找到这个Voter实例的name变量。
3. 静态方法必须被实现
静态方法用来表示某个类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。既然如此，当前类必须为静态方法提供实现。换句话说，一个静态的方法不能被定义为抽象方法。以下方法的定义是非法的：
static和abstract修饰符是一对“冤家”，永远不能在一起使用。如果一个方法是静态的，它就必须自力更生，自己实现该方法；如果一个方法是抽象的，那么它就只表示类所具有的功能，但不会实现它，在子类中才会实现它。
4. 作为程序入口的main()方法是静态方法
作为程序入口的main()方法必须使用static修饰，因为把main()方法定义为静态方法，可以使得Java虚拟机只要加载了main()方法所属的类，就能执行main()方法，而无需先创建这个类的实例。
在main()静态方法中不能直接访问实例变量和实例方法。在调试程序时会经常遇到类似下面的编译错误：
正常的做法是通过Sample实例的引用来访问实例方法和实例变量。
5. 方法的字节码都位于方法区
不管实例方法，还是静态方法，它们的字节码都位于方法区内。Java编译器把Java方法的源程序代码编译成二进制代码，称为字节码。Java虚拟机的解析器能够解析这种字节码。如图4-2-1所示，当Java虚拟机的主线程执行tom.voteFor()或者mike.voteFor()方法时，都从方法区内获得voteFor()方法的字节码。当主线程执行代表以下程序代码的字节码指令时：
主线程会根据方法调用栈的有关信息，在堆区找到相应的name变量。如果执行tom.voteFor()方法，那就访问tom变量访问的Voter对象的name变量；如果执行jack.voteFor()方法，那就访问jack变量访问的V oter对象的name变量。
图4-2-1 方法的字节码都位于方法区
三. static代码块
类中可以包含静态代码块，它不存在于任何方法体中。在Java虚拟机加载类时会执行这些代码块。如果类中包含多个静态块，那么Java虚拟机将按照它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。例如以下Sample类中包含两个静态代码块。运行Sample类的main()方法时，Java虚拟机首先加载Sample类，在加载的过程中依次执行两个静态代码块。Java虚拟机加载Sample类后，再执行main ()方法。
运行这个程序，将输出如下结果：
类的构造方法用于初始化类的实例，而类的静态代码块则可用于初始化类，给类的静态变量赋初始值。
静态代码块与静态方法一样，也不能直接访问类的实例变量和实例方法，而必须通过实例的引用来访问它们。例如：
访问修饰符与方法的重载
一. Java中的访问修饰符
当一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。下面具体说明这些修饰符的作用。
「注」一个类中的实例方法总是可以操作该类中的成员变量；类方法总是可以操作该类中的类变量，与访问限制符没有关系。
1. 私有变量和私有方法
用关键字private修饰的成员变量和方法称为私有变量和私有方法。如：
当在另一个类中用类Tom创建了一个对象后，该对象不能访问自己的私有变量和私有方法。如：
如果Tom类中的某个成员是私有类变量（静态成员变量），那么在另外一个类中，也不能通过类名To m来操作这个私有类变量。如果Tom类中的某个方法是私有的类方法，那么在另一个类中，也不能通过类名Tom来调用这个私有的类方法。
对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法，如例1所示。
例1：
2. 公有变量和公有方法
用public修饰的成员变量和方法称为公有变量和公有方法。如：
当在任何一个类中用类Tom创建了一个对象后，该对象能访问自己的public变量和类中的public方法。如：
如果Tom类中的某个成员是公有类变量，那么在另外一个类中，也可以通过类名Tom来操作这个私有类变量。如果Tom类中的某个方法是公有的类方法，那么在另一个类中，也可以通过类名Tom来调用这个公有的类方法。
3. 受保护的成员变量和方法
用protected修饰的成员变量和方法称为受保护的成员变量和受保护的方法。如：
当在任何一个类中用类Tom创建了一个对象后，如果这个类与类在同一个包中，那么该对象能访问自己的protected变量和protected方法。在任何一个与Tom同一包中的类中，也可以通过Tom类的类名访问T om类的protected类变量和protected类方法。
假如Jerry与Tom是同一包中的类，那么Jerry类中的cat.weight、cat.f(3f,4f)都是合法的。
4. 友好变量和友好方法
不用private、public、protected修饰符的成员变量和方法被称为友好变量和友好方法。如：
当在另一个类中用类Tom创建了一个对象后，如果这个类与Tom类在同一个包中，那么该对象能访问自己的友好变量和友好方法。任何一个与Tom同一包中的类中，也可以通过Tom类的类名访问Tom类的类友好成员变量和类友好方法。
假如Jerry与Tom是同一个包中的类，那么，下述Jerry类中的cat.weight、cat.f(3f,4f)都是合法的。
在源文件中编写命名的类总是在同一包中的。如果你在源文件中用import语句引入了另外一个包中的类，并用该类创建了一个对象，那么该类的这个对象将不能访问自己的友好变量和友好方法。
5. public类与友好类
类声明时，如果关键字class前面加上public关键字，就称这样的类是一个public类，如：
可以在任何另外一个类中，使用public类创建对象。如果一个类不加public修饰，如：
这样的类称为友好类，那么另外一个类中使用友好类创建对象时，要保证它们是在同一包中。
「注」不能用protected和private修饰类；按访问权限从高到低的排列顺序是public、protected、friendl y、private。
二. 方法的重载
有时候，类的同一种功能有多种实现方式，到底采用哪种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。
再例如某个类的一个功能是比较两个城市是否相同，一种方式是按两个城市的名字进行比较，另一种方式是按两个城市的名字，以及城市所在国家的名字进行比较。
再例如https://www.doczj.com/doc/d24626594.html,ng.Math类的max()方法能够从两个数字中取出最大值，它有多种实现方式。
以下程序多次调用Math类的max()方法，运行时，Java虚拟机先判断给定参数的类型，然后决定到底执行哪个max()方法。
对于类的方法（包括从父类中继承的方法），如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。
重载方法必须满足以下条件：
●方法名相同。
● 方法的参数类型、个数、顺序至少有一项不相同。
●方法的返回类型可以不相同。
●方法的修饰符可以不相同。
在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。
三. 访问器get/set方法
当声明类的非public成员变量时，如private类型的变量，如果在方法中要读取或者设置这个成员属性的值时，我们需要给此属性生成访问器，这样通过类的对象调用相应的public访问器就可以读取和设置值了。例如：
选择题 1、下列关于变量的叙述哪个是错的？（） A. 实例变量是类的成员变量。 B. 在方法中定义的局部变量在该方法被执行时创建。 C. 实例变量用关键字static声明。 D. 局部变量在使用前必须被初始化。 2、在Java语言中，下列哪个包是编译器自动导入的？（） A. java.applet B. https://www.doczj.com/doc/d24626594.html,ng C. java.io D. java.awt 3、当类的成员未用访问权限修饰符时，Java认为此成员的访问权限为（）。 A. private B. protected C.friendly D.public 4、下面哪个关键字不是用来控制对类成员的访问的？（） Ａ. public B. protected C. default D. private 5、下面哪一个特性不是面向对象编程主要体现的（）。 A. 封装性 B. 继承 C. 多态 D. 类 6、不允许作为类及类成员的访问控制符的是（）。 A. public B. private C. static D. protected 7、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB 作为前缀就可以调用它，该方法头的形式为（）。 A、static void method( ) B、public void method( ) C、final void method( ) D、abstract void method( ) 8、可以在下面代码段point x处写入的是？（） //point x public class Interesting{ //do something } A. String str; B. static int PI=3.14; C. public class MyClass{//do other thing…} D. import java.awt.*; 9、下列关于变量的叙述哪个是错的？（） A、实例变量是类的成员变量。 B、在方法中定义的局部变量在该方法被执行时创建。 C、实例变量用关键字static声明。 D、局部变量在使用前必须被初始化。 10、下列哪个类声明是正确的？（） A、abstract final class HI{} B、abstract private move(){} C、protected private number; D、public abstract class Car{}
1、JAVA中的参数传递问题（理解内存图） 基本类型：形式参数的改变对实际参数没有影响 引用类型：形式参数的改变直接影响实际参数 2、面向对象(理解,升就业班问说说什么是面向对象和思想特点) 1、面向对象(从三点回答) A面向过程是以函数为基础，完成各种操作，强调的是过程 B面向对象以对象为基础，完成各种操作，强调的是对象，结果 C面向对象是基于面向过程的 2、面向对象的思想特点: a)是一种更符合人们思考习惯的思想 b)把复杂的事情简单化 c)把我们从执行者变成了指挥者 3、举例： a)买电脑 b)洗衣做饭 c)旅游 d)把大象装进冰箱(伪代码体现) 4、事物是如何体现的 a)属性有哪些特征名词提取法 b)行为有哪些功能 5、类与对象的关系(掌握) 把事物转换成类 A:成员变量 定义在类中，方法外 B:成员方法 和以前的区别是去掉static 把这个说完还没有说道类与对象的概念，对不对 类：是相关的属性和行为的集合，集合就是一堆东西，是一个抽象的概念 对象：是某种事物的具体的存在，具体的表现形式 举例： 学生：类 对象：小明 6、案例 A学生类 B手机类 C汽车类(在这里画了内存图，有空看一下) 7、如何使用呢 a)创建对象 i.格式 a)类名变量= new 类名() b)使用成员变量和成员方法
i.对象名.成员变量 ii.对象名.成员方法 8、成员变量和局部变量的区别(理解) A 定义位置 成员变量：在类中方法外 局部变量，在类中方法中，或者方法上的形式参数 B 初始化的区别 成员变量：有默认的初始化值 局部变量：无 C 存储位置 成员变量：堆随着对象的存在而存在 局部变量：栈随着方法的存在而存在 9、匿名对象 a)概念：没有名字的对象 b)使用场景 i.当对象中的方法只掉用一次的情况下使用(一般不用，测试时使用)new Student().sayHello(); ii.匿名对象作为实际参数传递
Java中创建对象的四种方式 1.用new语句创建对象，这是最常见的创建对象的方法。 2.运用反射手段,调用https://www.doczj.com/doc/d24626594.html,ng.Class或者https://www.doczj.com/doc/d24626594.html,ng.reflect.Constructor类的newInstance()实例方法。 3.调用对象的clone()方法。 4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法。 以下是代码片段： package org.whb.test.demo724; /* *测试Cloneable接口的使用 *包含第一种和第三种方法clone() *不过要注意在clone()中深复制和潜复制的理解 *实例化对象 */ class Person implements Cloneable{ private String name; private int age; public Person( String name,int age) { https://www.doczj.com/doc/d24626594.html, = name; this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name){ https://www.doczj.com/doc/d24626594.html, =name; } @Override public Object clone() throws CloneNotSupportedException { // TODO Auto-generated method stub return super.clone();
第3章类与对象 一．选择题 1.下列不属于面向对象编程的特性是（D）。 A．封装性 B. 继承性 C. 多态性 D. 编译执行 2.下列类的声明中不合法的是（C）。 A. class People{…} B. class 植物{…} C. Class A{…} D. public class 共有类{… 3.下列方法的声明中不合法的是（C）。 A. float area(){…} B. void area(){…} C. double area(d){…} D. int area(int r){…} 4. 下列构造方法（构造器）的调用中正确的是（C）。 A. 按照一般的方法调用 B. 由用户直接调用 C. 只能通过new自动调用 D. 被系统调用 5.下列程序运行的结果是（A）。 class Book{ int width; int length; } public class A{ static void f(Book p){ p.width=20; p.length=40; } public static void main(String args[]){ Book b=new Book(); b.width=10; b.length=20; f(b); System.out.print(" "+b.width); System.out.print(" "+b.length); } } A. 20 40 B. 10 40 C. 10 20 D. 以上都不对 6.下列程序运行的结果是（D）。 public class A{ static void f(int y){ y=y+10; } public static void main(String args[]){ double x=10; f(x); System.out.println(x); } }
类和对象 一、选择题 1、下面对方法的作用描述不正确的是：（ d ） A、使程序结构清晰 B、功能复用 C、代码简洁 D、重复代码 2、方法定义的变量：（ b ） A 、一定在方法所有位置可见B、可能在方法的局部位置可见 C、在方法外可以使用 D、在方法外可见 3、方法的形参：（a） A、可以没有 B、至少有一个 C、必须定义多个形参 D、只能是简单变量 4、方法的调用：（c） A、必须是一条完整的语句 B、只能是一个表达式 C、可能是语句，也可能是表达式 D、必须提供实际参数 5、return 语句：( d) A、不能用来返回对象 B、只可以返回数值 C、方法都必须含有 D、一个方法中可以有多个return 语句 6、void 的含义：（d） A、方法体为空 B、方法体没有意义 C、定义方法时必须使用 D、方法没有返回值 7、main()方法的返回类型是：（ c ） A 、boolean B、int C、void D、static 8、方法重载所涉及的方法：（ a ） A、有相同的名字 B、参数个数必须不同 C、参数类型必须不同 D、返回类型必须不同 9、下面关于类和对象之间关系的描述，正确的是（ c ） A、联接关系Ｂ、包含关系Ｃ、具体与抽象的关系Ｄ、类是对象的具体化 10、下面关于java中类的说法哪个是不正确的（ c ） A、类体中只能有变量定义和成员方法的定义，不能有其他语句。 B、构造方法是类中的特殊方法。 C、类一定要声明为public的，才可以执行。
D、一个java文件中可以有多个class定义。 11、下列哪个类声明是正确的( d) A、public void H1｛…｝ B 、public class Move()｛…｝ C、public class void number{} D、public class Car｛…｝ 12、下面的方法声明中，哪个是正确的（c） A、public class methodName(){} B、public void int methodName(){} C、public void methodName(){} D、public void methodName{} 13、下述哪些说法是不正确的？（ b ） A、实例变量是类的成员变量 B、实例变量是用static关键字声明的 C、方法变量在方法执行时创建 D、方法变量在使用之前必须初始化 14、下面对构造方法的描述不正确是( b)。 A、系统提供默认的构造方法 B、构造方法可以有参数，所以也可以有返回值 C、构造方法可以重载 D、构造方法可以设置参数 15、定义类头时，不可能用到的关键字是( b)。 A、class B、private C、extends D、public 16、下列类头定义中，错误的是( )。 A、public x extends y {...} B、public class x extends y {...} C、class x extends y implements y1 {...} D、class x {...} 17、设A为已定义的类名，下列声明A类的对象a的语句中正确的是( ) 。 A、float A a; B、public A a=A( ); C、A a=new int( ); D、static A a=new A( ); 18、设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是( a )。 A、void X(int k ){ i=k; } B、X(int k ){ i=k; } C、X(int m, int n ){ i=m; j=n; } D、X( ){i=0;j=0; } 19、有一个类A，以下为其构造方法的声明，其中正确的是
JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。
类名自定义名= new 类名() 假设我们在函数中写了如下这个简单的语句： StringBuffer str = new StringBuffer（"Hello world"）； 别看这个语句简单，其实包含了如下三个步骤： 首先，newStringBuffer（"Helloworld"）在堆里申请了一坨内存，把创建好的StringBuffer 对象放进去。 其次，StringBufferstr声明了一个指针。这个指针本身是存储在栈上的（因为语句写在函数中），可以用来指向某个StringBuffer类型的对象。或者换一种说法，这个指针可以用来保存某个StringBuffer对象的地址。 最后，当中这个等于号（赋值符号）把两者关联起来，也就是把刚申请的那一坨内存的地址保存成str的值。
引用对象之间的赋值、判相等 通过上述的图解，大伙儿应该明白指针变量和该指针变量指向的对象是一个什么关系了吧。 还是接着刚才的例子，再来看赋值的问题。对于如下语句： StringBuffer str2 = str； 这个赋值语句是啥意思捏？实际上就是把str的地址复制给str2，记住，是地址的复制，StringBuffer对象本身并没有复制。所以两个指针指向的是同一个东东。 再搞一张示意图，如下（今天画这些图把我累坏了）：
实际上两个指针的值相同，则肯定是指向同一个对象（所以对象内容必定相同）。但是两个内容相同的对象，它们的地址可能不一样（比如克隆出来的多个对象之间，地址就不同）。 final常量的问题 针对引用类型变量的final修饰符也是很多人搞混淆的地方。实际上final只是修饰指针的值（也就是限定指针保存的地址不能变）。至于该指针指向的对象，内容是否能变，那就管不着了。所以，对于如下语句： final StringBuffer strConst = new StringBuffer（）； 你可以修改它指向的对象的内容，比如： strConst.append（" "）； 但是不能修改它的值，比如： strConst = null； 传参的问题 引用类型（在函数调用中）的传参问题，是一个相当扯的问题。有些书上说是传值，有些书上说是传引用。搞得Java程序员都快成神经分裂了。所以，我们最后来谈一下“引用类型参数传递”的问题。 v还是拿刚才的例子，假设现在要把刚才创建的那一坨字符串打印出来，我们会使用如下语句： System.out.println（str）；这个语句又是什么意思捏？这时候就两说了。 第一种理解：可以认为传进函数的是str这个指针，指针说白了就是一个地址的值，说得再白一点，就是个整数。按照这种理解，就是传值的方式。也就是说，参数传递的是指针本身，所以是传值的。 第二种理解：可以认为传进去的是StringBuffer对象，按照这种理解，就是传引用方式了。因为我们确实是把对象的地址（也就是引用）给传了进去。
一、实验目的 掌握类和对象的定义，以及它们之间的关系 学习类中属性和方法的设计 会用UML图来对类进行描述 熟悉修饰符的作用，会用set/get方法对数据进行封装 二、实验要求 设计一个名为Rectangle的类表示矩形。这个类包括： ?两个名为width和height的私有double型数据域。用来表示宽、高。默认值为1.0。 ?创建默认矩形的无参构造方法。 ?一个创建width和height为指定值的矩形的构造方法。 ?一个名为GetArea()的公有方法返回矩形面积double ?一个静态的Compare方法，比较两个矩形的面积大小是否相等并返回一个布尔型结果，相等返回true，不等返回false； 画出UML 类图，实现Rectangle类，编写测试程序创建两个Rectangle类的对象。第一个对象的width为1，height为1；第一个对象的width为5，height为6。调用compare方法判断两个矩形是否相等并显示结果。 三、实验内容 1.使用Jude工具绘制UML图
2.编写代码实现类Rectangle package edu.neu.li.test; publicclass Rectangle { privatedouble width; privatedouble height; public Rectangle() { this.width = 1.0; this.height = 1.0; public Rectangle(double width, double height) { this.width = width; this.height = width; } publicdouble GetArea() { returnthis.width * this.height ; } publicstaticboolean Compare(Rectangle rec1, Rectangle rec2) { if(rec1.GetArea()==rec2.GetArea()) { returntrue; } returnfalse; } }
试验四 类和对象的创建 一.类的定义 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。 类的实现包括两部分：类声明和类体。基本格式为： 修饰符class类名[extends父类名]{ /*类体的内容*/ } 1.类声明 以下是一个类声明的例子。 class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则： (1)如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。 (2)类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。 2.类体 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。 类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。 下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。
二.对象 1.对象的创建 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字对象名字; 如： 这里People是类的名字，zhubajie是我们声明的对象的名字。 (2)为声明的对象分配内存。 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如： 例1： 「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。 2.对象的使用 对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 例2：
成绩： 面向对象原理与Java实践课程实验报告 实验1：对象和类 姓名 ____ 班级 ____ 学号 ____ 实验地点 ____ 实验时间 ____ 指导教师 ____
面向对象原理与Java实践课程实验报告 实验1：对象和类 一、实验目的： ●掌握类的定义及应用方法 ●掌握对象的创建方法，了解实例变量、实例方法和静态字段的特性 ●体会Java在类和对象的设计中体现的面向对象的思想 二、实验要求： ●具备Java基础知识（教材第1、2章内容） ●掌握Java中对象和类的基本概念和应用方法（教材第3章内容） ●设计类时注意保证类的封装性 ●编写程序完成以下实验内容并上交实验报告（包括电子文档与纸质文档） 三、实验内容： 设计并实现一个“广石化院电信学院学生通信录”系统。系统采用字符界面，在出现的主界面中按提示输入相应字符以选择“增加”、“删除”、“修改”、“查找”等功能进行操作（其中“查找”功能除能够查找某个学生的信息之外，还能够显示所有学生的信息）。记录的存储可采用数组或链表的方式。 四、设计思路： 为了实现该系统，首先要需要两个类；一个类为主界面服务，用于接收用户输入信息以及做出相关反应；一个类为学生信息服务，定义学生通讯录信息的各个字段，以及操作字段的各个方法，考虑到部分字段的属性问题，所以将操作方法都写在学生类中，不再另外放置在其他类中。学生信息将会采用学生类的对象数组来储存。 五、程序源代码： 下面是ZhuJieMian 主界面类 package pkg_TXL; import java.util.Scanner; public class ZhuJieMian { /** * * 该类为通讯录系统的主界面提供主要功能显示，以及负责主菜单与子菜单的正常跳转 */ public static void main(String[] args) {
JAVA类与对象习题 一、写出一个类People，并由该类做基类派生出子类Employee和Teacher。其中People 类具有name、age两个保护成员变量，分别为String类型、整型，且具有公有的getAge 成员函数，用于返回age变量的值。Employee类具有保护成员变量empno,Teacher类有teano和zc成员变量。 二、（1）创建Rectangle类，添加属性width、height； （2）在Rectangle类中添加两种方法计算矩形的周长和面积； （3）编程利用Rectangle输出一个矩形的周长和面积 三、（1）设计一个User类，其中包括用户名、口令等属性以及构造方法（至少重载2 个）。获取和设置口令的方法，显示和修改用户名的方法等。编写应用程序测试User 类。 （2）定义一个student类,其中包括用户名、姓名、性别、出生年月等属行以及init()——初始化各属性、display()——显示各属性、modify()——修改姓名等方法。实现并测试这个类。 （3）从上题的student类中派生出Granduate(研究生)类，添加属性：专业subject、导师adviser。重载相应的成员方法。并测试这个类。 四、项目名称:Bank Account Management System 银行账户管理系统简称BAM 练习1:(面向对象基础语法) 写一个账户类(Account), 属性: id:账户号码长整数 password:账户密码 name:真实姓名 personId:身份证号码字符串类型 email:客户的电子邮箱 balance:账户余额 方法: deposit: 存款方法,参数是double型的金额 withdraw:取款方法,参数是double型的金额
Java有一下三种方法可以创建对象实例。 1.new 通常都是使用java的关键字new来创建对象实例。 若有一个Something类，则可以通过下面的语句创建Something类的对象实例并指定到变量obj。 Something somethingNew = new Something()； 通过new创建对象实例必须把类名写在原代码里面。 2.clone 若程序写成如下，则可以根据当前对象（this）建立一个新实例对象（没有调用构造函数）. public class Something implements Cloneable{ private Something obj; public Something cloneSomething() { try { obj = (Something)this.clone(); // obj = (Something)clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return obj; } } 如果需要复制上面的那个obj指向的对象实例时，调用 somethingNew.cloneSomething()方法就ok了。 但是为什么不直接使用somethingNew.clone()呢？ JDK中Object# clone()方法的原型是： protected native Object clone() throws CloneNotSupportedException; 方法修饰符是protected，而不是public。这种访问的不可见性使得我们对Object#clone()方法不可见。
实验报告 一、实验项目：类与对象 二、实验目的： 1. 学会使用类来封装对象的属性和功能 2. 掌握类变量与实例变量，以及类方法与实例方法的区别 3. 掌握使用package和import语 三、实验器材：计算机、Java编程软件JCreator 四、实验原理（或仪器装置图）： 1. 类与对象 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。 类声明 class 类名{ 类体 } 对象的声明 一般格式为： 类的名字对象名字; 定义对象引用后，用new运算符完成对象的创建工作，分配存储空间，并对其初始化。 变量名=new 类名([构造方法实参表]); 对象的使用 访问成员的基本语法形式如下：
对象名.变量成员名 对象名.方法成员名([实际参数表]) 2.成员变量和局部变量 成员变量格式：[修饰符] 变量类型变量名[=初值]; 成员方法： 格式:[修饰符] 返回值的数据类型方法名（参数1，参数2，…） { 语句序列； return[表达式]; } 类中定义的变量是成员变量，而方法中定义的变量是局部变量。 3. 构造方法 构造方法是一种特殊的方法，创建对象时被自动调用。与一般的方法不同，它没有返回值类型的说明，方法体中也不可以用return语句带回返回值。构造方法的方法名与类名相同在构造方法中可以通过this关键字调用该类中其他的构造方法。 4.包 包是Java语言中有效地管理类的一个机制。 ①通过关键字package声明包语句。package 语句作为Java源文件的第一条语句，指 明该源文件定义的类所在的包。package语句的一般格式为：package 包名; ②import 语句：使用import 语句可以引入包中的类。 五、实验步骤及数据记录： 1．定义一个圆柱体类Cylinder，并创建相应的对象，然后计算圆柱体的底面积与体积。
Java编程面向对象——类与对象的关系 面向对象是一种组件化的设计思想，OOA、OOD、OOP 类与对象是整个面向对象之中最为基础的组成单元，如果需要给划出定义：类就是共性的集合，而对象是某一个性的产物；所有类实际上是用来描述一个对象的结构。 类是通过对象来使用的，而对象是通过类来创建的。 类与对象的基本定义： 在程序中，定义类，可以使用“class 类名称{}”的语法结构完成。 而类之中的组成主要有两点： * Field （属性、成员、变量），就是一推变量的集合 * Method （方法、行为），此时的方法是由对象调用的。 这个类中定义了两个属性和一个方法（可以定义更多属性和方法） *类虽然存在，但是类的使用，必须有对象； 对象的定义格式： 声明并实例化对象： 类名称对象名称 = new 类名称(); 分步完成： 声明对象：类名称对象名称 = null； 实例化对象：对象名称 = new 类名称(); 引用数据类型： 引用数据类型最大的不同在于需要内存的开辟及使用，所以关键字new 的主要功能就是开辟内存空间； 即：只要引用数据类型想使用，就必须使用关键字new 来开辟空间。 当一个对象实例化之后就可以使用以下方式利用对象来操作类的结构： 对象.属性：表示要操作类中属性内容 对象.方法()：表示要调用类中的方法内容
内存概念： 堆内存：保存每一个对象的属性内容，堆内存需要用关键字 new 才可以开辟； 栈内存：保存的是一块堆内存的地址。简单的理解，栈内存保存的是对象的名字； 编程中的栈内存和堆内存的操作过程： 引用数据的初步分析： 引用是整个 Java 开发中的核心精髓所在，即：只有掌握了“引用”这一概念之后，才能加入下一步学习，类似C/C++ 中的指针概念。 在所有的引用分析里面，最关键的还是在于关键字 “new ”，每一次使用关键字new ，都会开辟新的堆内存空间，如果你的代码里面声明两个对象，并且使用了关键字new 为两个对象分别实例化操作，那么一定是各自占有各自(独立)的堆内存空间
《JAVA面向对象编程》[PDF] 孙卫琴著 【目录】 第1章面向对象开发方法概述 1 1.1 结构化的软件开发方法简介3 1.2 面向对象的软件开发方法简介5 1.2.1 对象模型6 1.2.2 UML：可视化建模语言6 1.2.3 Rational Rose：可视化建模工具7 1.3 面向对象开发中的核心思想和概念7 1.3.1 问题领域、对象、属性、状态、行为、方法、实现7 1.3.2 类、类型9 1.3.3 消息、服务10 1.3.4 接口11 1.3.5 封装、透明12 1.3.6 抽象16 1.3.7 继承、扩展、覆盖17 1.3.8 组合19 1.3.9 多态、动态绑定22 1.4 UML语言简介24 1.4.1 用例图24 1.4.2 类框图25 1.4.3 时序图26 1.4.4 协作图27 1.4.5 状态转换图27 1.4.6 组件图28 1.4.7 部署图29 1.5 类之间的关系29 1.5.1 关联（Association）29 1.5.2 依赖（Dependency）31 1.5.3 聚集（Aggregation）31 1.5.4 泛化（Generalization）32 1.5.5 实现（Realization）32 1.5.6 区分依赖、关联和聚集关系33 1.6 实现Panel系统35 1.6.1 扩展Panel系统37 1.6.2 用配置文件进一步提高Panel系统的可维护性39 1.6.3 运行Panel系统40 1.7 小结41 1.8 思考题42 第2章第一个Java应用43 2.1 创建Java源文件43 2.1.1 Java源文件结构44
5.2.1 编程实验1：基本类定义 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 基本类的定义。 ? 使用自定义的基本类创建对象，并进行调用。 在强化练习中，学生将练习： ? 给基本类中增加属性 ? 在测试类中将增加的属性向控制台打印输出 2. 问题描述 编写一个类，描述学生的学号、姓名、成绩。学号用整型，成绩用浮点型,姓名用String类型。 编写一个测试类，输入学生的学号和成绩，并显示该学号的学生姓名，以及成绩。 3. 示例输出 4. 程序模板 class Student{ /* 此处创建三个属性。 */ } public class T1_Student{ public static void main(String[] args){ /* 先构造Student对象，然后分别为对象的属性赋值 最后打印输出对象的各个属性。 */ } } 5. 解答提示 1）在基本类的定义中描述学生类，学生的学号、成绩和姓名作为学生类的属性来描述。2）在测试类中写main方法，作为程序的入口进行运行，在main方法中创建学生对象，并
给对象的各个属性赋予具体值。 3）在测试类中用System.out.println()方法将属性的具体值输出到控制台，完成程序的输出结果要求。 6. 强化练习 1）给学生类添加性别属性，取值为boolean类型，用true表示男，用false表示女。 2）在测试类中输出学生的姓名、学号、成绩的同时，输出性别为：男或女。 5.2.2 编程实验2：构造方法 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 定义多个基本类 ? 构造方法的定义 ? 构造方法的重载 在强化练习中，学生将练习： ? 构造方法的多个重载 ? 只通过指定长和宽来定制桌子。 2. 问题描述 编写一个类，描述桌子，包括以下几种属性：长、宽、高、颜色。并且使该类具有这样的功能：在定制桌子（即创建桌子对象时），就可以同时指定桌子的长宽高来订制。也可以同时指定长、宽、高、颜色来订制，也可单独指定桌子颜色来订制。 并编写一个测试类测试这几种定制方法。 5.2.3 编程实验3：访问器方法 本实验要求在封闭实验课中在教师指导下完成。 1. 实验目的 本实验旨在巩固学生对《Java语言程序设计》中第5章内容的掌握。在这个实验中学生将练习： ? 编写基本类，包括私有属性 ? 给基本类添加访问器方法，从而限制属性的读、写。 ? 测试类的编写，测试访问器方法对属性的读、写限制。 在强化练习中，学生将练习： ? 在基本类中添加私有属性。 ? 给该私有属性分别添加get和set访问器方法进行读、写。 2. 问题描述 编写一个类，描述银行账户，包括收入、支出和账户余额三种属性，同时包括对这三种
1.实现简易计算器，分别实现两个整数、三个浮点数的加法运算.（用JAVA中的类和对象） 源码如下： package days;//包名自己修改 import java.util.Scanner;//注意别忘记导入这个包名了public class NumSum { public int add(int num1,int num2){ return num1+num2; } public double add(double num1,double num2,double num3){ return num1+num2+num3; } public static void main(String[] args) { // TODO Auto-generated method stub NumSum nc=new NumSum(); NumSum nc1=new NumSum();
//调用2个整数相加的方法 //Scanner是用键盘手动输入数字。 System.out.println("请用键盘手动输入两个整数："); System.out.println(nc.add(new Scanner(System.in) .nextInt(),new Scanner(System.in).nextInt())); //调用3个浮点数相加的方法 System.out.println("请用键盘手动输入三个浮点数："); System.out.println(nc1.add(new Scanner(System .in).nextDouble(), new Scanner(System.in).nextDouble( ), new Scanner(System.in).nextDouble())); } }
类与对象的创建与使用方法 //声明RectTest类 class RectTest{ public static void main(String args[]){ Rect rect1=new Rect(); System.out.println("矩形1的信息"+rect1.toString()); Rect rect2=new Rect(33,44); System.out.println("矩形2的信息"+rect2.toString()); rect1 = rect2; System.out.println("矩形1的信息"+rect1.toString()); System.out.println("矩形1的周长: "+rect1.getPerimeter()); System.out.println("矩形1的面积: "+rect1.getArea()); System.out.println("矩形2的周长: "+rect2.getPerimeter()); System.out.println("矩形2的面积: "+rect2.getArea()); } } //声明矩形类Rect class Rect { private float length; //矩形的长度 private float width; //矩形的宽度 public Rect(){ //默认构造方法 length=0; width=0; } public Rect(float l, float w){ //带参数的构造方法 length=l; width=w; } public void setLength(float l){ //改变矩形的长度 length=l; } public float getLength(){ //得到矩形的长度 return length; } public void setWidth(float w){ //改变矩形的宽度 width=w; }
?JAVA中对象创建和初始化过程 ? ?分析一下JAVA中对象创建和初始化过程中涉及的相关概念问题，java中栈(st ack)与堆(heap)，对象、引用、句柄的概念。 @Author:ZJ 06-11-25 Blog: https://www.doczj.com/doc/d24626594.html,/ 1.Java中的数据类型 Java中有3个数据类型：基本数据类型(在Java中，boolean、byte、short、int、lo ng、char、float、double这八种是基本数据类型)、引用类型和null类型。其中，引用类型包括类类型(含数组)、接口类型。 下列语句声明了一些变量： 以下是引用片段： int k ; A a; //a是A数据类型的对象变量名。 B b1,b2,…,b10000;// 假定B是抽象类或接口。 String s; 注意：从数据类型与变量的角度看，基本数据类型变量k、类类型变量a和s、抽象类或接口类型变量b(1万个)，它们都是变量(标识符)。 2.关于句柄(handle) 为了区别引用类型的变量标识符和基本数据类型变量标识符，我们特别的使用Handle 来称呼引用类型的变量标识符。上面例子中b1至b10000、a、s都是Handle。Handle直观的看就是手柄、把手，我们采用计算机界常用的中文翻译“句柄”。 2.1【Windows编程中的】句柄的含义 句柄是WONDOWS用来标识被应用程序所建立或使用的对象的唯一整数，WINDOWS使用各种各样的句柄标识诸如应用程序实例，窗口，控制，位图，GDI对象等等。WINDOWS句柄有点象C语言中的文件句柄。 从上面的定义中的我们可以看到，句柄是一个标识符，是拿来标识对象或者项目的，它就象我们的姓名一样，每个人都会有一个，不同的人的姓名不一样，但是，也可能有一个名字和你一样的人。从数据类型上来看它只是一个16位的无符号整数。应用程序几乎总是通过调用一个WINDOWS函数来获得一个句柄，之后其他的WINDOWS函数就可以使用该句柄，以引用相应的对象。 如果想更透彻一点地认识句柄，我可以告诉大家，句柄是一种指向指针的指针。我们知道，所谓指针是一种内存地址。应用程序启动后，组成这个程序的各对象是驻留在内存的。 如果简单地理解，似乎我们只要获知这个内存的首地址，那么就可以随时用这个地址访问对象。但是，如果您真的这样认为，那么您就大错特错了。我们知道，Windows是一个以虚拟
实验三类与对象 一、实验目的 1、掌握类和构造方法的定义 2、理解静态和非静态成员变量的区别 3、掌握创建类实例的方法 4、理解Java中包的概念及其使用方法 二、实验要求 1.写一个名为Rectangle的类表示矩形。其属性包括宽width、高height和颜色color，width 和height都是double型的，而color则是String类型的。要求该类具有： (1)使用构造函数完成各属性的初始赋值 (2)使用getter和setter的形式完成属性的访问及修改 提供计算面积的getArea()方法 public class mianji { private double height; private double width; private String color; public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public mianji(double width,double height,String color){ this.setColor(color); this.setHeight(height); this.setWidth(width); } public void getArea(){ double area=0; area=this.height*this.width; System.out.println("矩形的面积为"+area); } public String toString(){ String recStr="矩形的高度："+this.getHeight() +"宽度："+this.getWidth() +"颜色:"+this.getColor(); return recStr; } public static void main(String[] args) { mianji rec=new mianji(3, 4, "红色"); rec.getArea(); System.out.println(rec.toString());}