Java程序设计修改

1、第3章 类和对象Java通过类和对象来组织和构建程序。类包括类的声明和类的主体。类的主体包括成员变量和成员方法。类的主体中还包括一个与类名相同无返回值的特殊方法，这就是构造函数。构造函数用来对对象进行初始化。有些方法在使用时需要为其传送参数，this引用可以把当前对象作为参数传递到方法中。类设计好以后，就可以用来定义对象，对象是一种引用类型，存放的是实际对象的内存地址。使用对象名来访问对象的成员变量和方法，以实现对对象的操作，完成程序的功能。包是类的组织结构。包主要用来管理Java中的类并提供访问控制。本章要点l 类的定义与对象的创建l 构造方法的使用l this引用l 包的访问本章难点l 类

2、的定义l 构造方法的使用学习目标l 掌握类的定义与创建l 掌握构造方法的使用l 了解包的访问3.1 类的定义311类和对象的关系类（Class）是一种复杂的数据类型，它是将数据和与数据相关的操作封装在一起的集合体。类是普通数据类型的扩展，它不但包含数据，还包含了对数据进行操作的方法（method）。方法反映的是数据的行为而不是数据本身。对象 （Object）是类的实例，当程序运行时，对象占用内存单元。对象与类的关系就像变量与类型的关系一样。例如：如果把“人”看成是一个抽象的类，我们每一个具体的人，就是“人”类中的一个实例，即一个对象，每个人的的姓名、年龄、身高、体重等特征可作为“人”类中的数据

3、，吃饭、走路、工作等行为作为类的方法。Java 中的所有数据类型都是用类来实现的，Java语言是建立在类这个逻辑结构之上的，类是Java的核心。312 类的定义格式1类的声明格式Java类的定义格式分为两部分：类声明和类主体。其格式如下： 类声明中包括关键字class,类名及类的属性。类声明的格式如下：classextendsimplements类主体是Java类的主体部分，完成变量的说明以及方法的定义及实现。在类中，用变量来说明类的状态，而用方法来实现类的行为。包含类主体的类结构如下： 2声明成员变量Java类的状态用成员变量来表示。声明成员变量必须给出变量名及其所属的类型，同时还可以指定其

4、他特性。声明格式如下：3声明成员方法类的行为由它的方法实现，其他对象可以调用对象的方法来得到该对象的服务。方法的声明与实现也可分为两部分：方法声明和方法体。声明成员方法的格式如下：(参数列表)throws 方法都有一个返回类型，如果一个方法不返回任何值，则它必须有一个void的返回类型声明。如果一个方法具有返回值，则在方法体中使用return语句把一个确定的值返回给调用该方法的语句。return语句的一般格式如下：return ;参数表由类型声明和参数名组成，参数名之间由逗号分开，若方法无参数，则参数表为空。方法的主体称为方法体，它是成员方法的实现部分。方法体包含在一对大括号中，即使方法体没有

5、语句，一对大括号也是必不可少的。在方法体中也可以声明变量，但方法体中声明的变量只是属于方法的局部变量，而不是类的成员变量。【例3_1】类定义示例。class Exam3_1int i=10;public void printI()System.out.println (i=+i);程序中我们定义了一个类，名字叫做Exam3_1，在这个类中我们定义了一个成员变量i，一个成员方法printI()，这就完成了一个最基本的类的定义。3.2 方法方法是类的成员，它与类的成员变量一起被封装在类中，并在类中实现。方法的声明格式已经在3.1节中给出了。在使用方法时我们会遇到有返回值的方法和无返回值的方法，以及

6、有参数的方法和无参数的方法。321 方法的返回值方法的返回值类型可以是基本数据类型也可以是对象，如果没有返回值，就用void来描述。例如，main方法就没有返回值，而且必须没有返回值。如果一个方法有返回值，则可以在方法体中使用return 语句将值返回，需要注意的是方法的返回值的类型必须和return 语句中返回的值的类型一样。【例3_2】方法的返回值。class Exam3_2static int i=10;public static void print1()System.out.println (i=+i);public static int print2()return i;publi

7、c static void main(String args) print1(); System.out.println (i=+print2(); 程序中我们创建了两个方法print1（）和print2（），print1（）方法是无返回值的，因此在声明时使用void表明其无返回值，print2（）方法会返回一个int类型的变量i，因此在方法声明是使用int表明返回值类型是int型，并使用return语句返回了int类型的变量i。程序的运行结果如图3-1所示。图3-1 例3_2程序运行结果322 方法的参数从参数上考察方法的话，方法分为有参方法和无参方法，需要注意的是，在Java语言中，向方法

8、传递参数的方式是“按值传递”。按值传递意味着当将一个参数传递给一个方法时，首先创建了源参数的一个副本并将这个副本传入了方法，这样方法接收的是原始值的一个副本。因此，即使在方法中修改了该参数，那仅仅是改变副本，而源参数值保持不变。【例3_3】方法的参数。class Exam3_3static int i=10;public static void set1()i=100;public static void set2(int n)i=n;public static void print()System.out.println (i=+i);public static void main(Stri

9、ng args)print(); set1(); print(); set2(50); print(); 对程序3.1做修改，添加了两个方法set1（）和set（）2，其中set1（）是没有参数的方法，方法中将i的值修改为100，而set2（）方法是带有一个整形参数的方法，将传进来的参数值赋值给i，这样在main（）方法中调用set2（）时，会将传入的整数值50传递给i。程序的运行结果如图3-2所示。图3-2 例3_3程序运行结果【例3_4】方法的参数传递。class Exam3_4public static void changeI(int i)i=100;System.out.printl

10、n (changeI方法中i=+i);public static void main(String args) int i=10; System.out.println (转换前i=+i); changeI(i); System.out.println (转换后i=+i); 不难看出，虽然在changeI（）方法中改变了传进来的参数i的值，但对这个参数的源变量本身并没有影响，即对 main方法里的 i 变量没有影响。这说明，按值传递实际上是将参数的值作了一个副本传进方法的，因此，无论在方法里怎么改变其值，结果都只是改变了拷贝的值，而不是源值。运行结果如图3-3所示。图3-3 例3_4程序运行结

11、果3.3 类的实例化331 创建对象创建对象包括对象声明和对象初始化两个部分。通常这两部分是结合在一起的，即定义对象的同时对其初始化，为其分配空间，并进行赋值。其格式为： = new （ ）例如，创建例3.1中Exam3_1类的一个对象可以写成：Exam3_1 e=new Exam3_1（）;其中e是所创建的对象的名字。Java中的对象是引用类型。引用类型是指该类型的标识符表示的是一片连续内存地址的首地址。对象定义后系统将给对象标识符分配一个内存单元，用以存放实际对象在内存中的存放位置。在没有用new关键字创建实际对象前，对象名的值为null。332使用对象成员一旦定义并创建了对象，就可以在程

12、序中使用对象了。对象通过使用成员运算符“”实现对变量的访问和方法的调用。通常使用的格式为：对象名成员变量名对象名成员方法名（ ）【例3_5】类定义示例。class Exam3_5static int i=10;public static void printI()System.out.println (i=+i); public static void main(String args) Exam3_5 e=new Exam3_5(); e.printI(); e.i=100; e.printI(); 程序中我们在main（）方法中创建了类的对象e，并使用e访问了其中的变量i和方法e.prin

13、tI()，运行结果如图3-2所示。图3-4 例3_5程序运行结果333对象资源的回收每个对象都要求资源才能“生存”，其中最令人注目的资源是内存。如果不再需要使用一个对象，就必须将其清除，以便释放这些资源，给其他对象使用。我们创建对象，在需要的时候调用它，然后将其清除或者“破坏”。但是如何才能知道什么时间删除对象呢？Java编程语言解除了程序员回收内存资源的责任，它提供垃圾回收机制（Garbage Collection）以跟踪每一存储器的分配情况并对不再使用的内存资源作回收。在垃圾回收机制中，JVM会跟踪资源的使用情况，定期检测出不使用的内存，由系统自动回收并做再次分配。垃圾收集器“知道”一个对

14、象在什么时候不再使用，然后会自动释放那个对象占据的内存空间。因此，Java程序中将不用考虑对象的释放问题，从而减轻程序员的负担，提高程序安全性，避免因资源耗尽而导致系统瘫痪的隐患。334类成员的访问控制在说明类的定义时我们提到了类及其成员的修饰符，可以用来修饰类的修饰符有public、abstract、final，用来修饰类的成员变量的有public、private、protected、final、static，修饰成员方法的有public、private、protected、final、static、abstract。任何修饰符都没有使用的，属于默认修饰符（friendly）。将这些修饰符的

15、作用列如表3-1所示。表3-1 类及其成员修饰符的作用访问控制修饰符同一类中同一包中不同包中的子类不同包中的非子类publicYesYesYesYesprotectedYesYesYesNo（friendly）YesYesNoNoprivateYesNoNoNo类型说明final最终类或最终成员，修饰类时表示此类不能有子类，修饰变量时表明此变量是一个常量，修饰方法时表明此方法不允许被覆盖abstract抽象类或抽象方法，修饰类时表明此类不能定义对象，修饰方法时表明此方法必须被覆盖static类成员或静态成员，表明此成员属于类，而不属于该类的某一具体对象1访问控制修饰符访问控制修饰符说明类或类的

16、成员的可访问范围，用public修饰的类或成员拥有公共作用域，表明此类或类的成员可以被任何Java中的类所访问，是最广泛的作用范围。用protected修饰的变量或方法拥有受保护作用域，可以被同一个包中所有的类及其他包中该类的子类所访问。用private修饰的变量或方法拥有私有作用域，只能在此类中访问，在其他类中，包括该类的子类中也是不允许访问的，private是最保守的作用范围。没有使用任何修饰符的，拥有默认访问权限，表明此类或类的成员可以被同一个包中的其它类访问。【例3_6】访问控制修饰符示例。class Exam3_6private static int i=10;public stat

17、ic void printI()System.out.println (i=+i);public void setI(int i1)i=i1;class Testpublic static void main(String args) Exam3_6 e=new Exam3_6(); e.printI(); /e.i=100; e.setI(100); e.printI(); 程序中我们将i的修饰符改为private，这样i只能在类Exam3_4中直接访问，在Test类中的直接访问语句e.i=100将出现“i has private access in Exam3_4”错误，为了给i赋值，我们

18、提供了可以在所有类中访问的public方法setI（），以达到改变i值得目的。程序运行结果如图3-5所示。图3-5 例3_6程序运行结果2static修饰符在一个类中，使用static修饰的变量和方法分别称为类变量（或称静态变量）和类方法（或称静态方法），没有使用static修饰的变量和方法分别称为实例变量和实例方法。类成员（静态成员）属于这个类而不是属于这个类的某个对象，它由这个类所创建的所有对象共同拥有。类成员仅在类的存储单元中存在，而在由这个类所创建的所有对象中，只是存储了一个指向该成员的引用。因此，如果任何一个该类的对象改变了类成员，则对其他对象而言该类成员会发生同样的改变。对于类成员

19、，既可以使用对象进行访问，也可以使用类名直接进行访问，并且在类方法中只能访问类成员，而不能访问实例成员。实例成员由每一个对象个体独有，对象的存储空间中的确有一块空间用来存储该成员。不同的对象之间，它们的实例成员相互独立，任何一个对象改变了自己的实例成员，只会影响这个对象本身，而不会影响其他对象中的实例成员。对于实例成员，只能通过对象来访问，不能通过类名进行访问。在实例方法中，既可以访问实例成员，也可以访问类成员。【例3_7】static修饰符访问示例。class Exam3_7static int i=1;int j=1;static void printStatic( )System.out

20、.println(i=+i);/System.out.println(j=+j);/非法访问void print()System.out.println(i=+i);System.out.println(j=+j);public static void main(String args)Exam3_7.printStatic( );/Exam3_7.print( );/非法访问Exam3_7.i=2;/Exam3_7.j=2;/非法访问Exam3_7 st=new Exam3_7( );st.i=3;st.j=3;st.print( );st.printStatic( );Exam3_7.pr

21、intStatic( );程序定义了一个类变量i，定义了一个实例变量j，定义了一个类方法printStatic（），定义了一个实例方法print（），在类方法printStatic（）中，只能访问类变量i，但不能访问实例变量j，在实例方法print（）中，则两个变量都可以访问。在main（）方法中，由于main（）方法是使用static修饰的，因此可以直接通过类名访问类变量i和类方法printStatic（），但不能通过类名访问实例变量j和实例方法print（），而一旦定义了对象st，则通过对象st可以访问类的任何成员，不论是类成员还是实例成员。程序运行结果如图3-6所示。图3-6 例3_7程

22、序运行结果【例3_8】测试类变量与实例变量的不同。class Exam3_8int i=0;static int j=0;public void print( )System.out.println(i=+i);System.out.println(j=+j);public static void main(String args)Exam3_8 sv1=new Exam3_8( );sv1.i+;sv1.j+;sv1.print();Exam3_8 sv2=new Exam3_8( );sv2.print();程序中定义了实例变量i和类变量j，创建了两个对象sv1和sv2，对sv1中的i和j

23、进行自增运算，输出均为1；然后输出sv2中的两个变量，结果为0和1。因为i是实例变量，sv1的更改只影响sv1本身，不影响其他对象，而j是类变量，sv1对其更改，sv2中的该变量会随之更改。程序运行结果如图3-7所示。图3-7 例3_8程序运行结果3.4 构造函数341 构造函数的作用和定义构造函数也称为构造方法，用来对对象进行初始化。它本身是一种特殊的方法，构造函数的名字必须和类名完全相同，并且没有返回值，甚至连表示无返回值的空类型（void）也没有，当创建对象时，由new运算符自动调用。有了构造函数，我们在3.2节中对类的实例化的格式可以改成： = new （ ）由此可以看到，构造函数的作

24、用就是用于创建不同的对象。【例3_9】构造函数使用示例。class Exam3_9 int i; public Exam3_9(int i1) i=i1; public void printI()System.out.println (i=+i);class Testpublic static void main(String args) Exam3_9 e1=new Exam3_9(1); Exam3_9 e2=new Exam3_9(2); Exam3_9 e3=new Exam3_9(3); e1.printI(); e2.printI(); e3.printI(); 程序中的publi

25、c Exam3_9(int i1)是一个方法的声明，但是该方法无返回值，且与类名完全相同，因此它是类Exam3_9的构造函数。在这个构造函数中，我们将传递进来的整数值赋值给类的成员变量i，因此，我们可以用构造函数来创建具有不同i的 Exam3_9类的对象e1、e2、e3。程序的执行结果如图3-8所示。图3-8 例3_9程序运行结果342 默认构造函数一般而言，每个类都至少有一个构造函数。如果程序员没有为类定义构造函数，Java虚拟机会自动为该类生成一个默认的构造函数。默认构造函数的参数列表及方法体都为空。在程序中，当使用new Xxx（）的形式来创建对象实例时，就是调用了默认构造函数，这里Xx

26、x表示类名。例如在3.1和3.2节中我们遇到的所有的构造函数其实都是由JVM为我们创建的默认构造函数。要特别注意的是，如果程序员定义了一个或多个构造函数，则自动屏蔽掉默认的构造函数。3.5 this引用351 this引用在例3_9的构造函数中我们将传入的变量i1的值赋值给类的成员变量i，如果我们不把构造函数的参数声明为i1，而把它也声明为i，此时构造函数中的赋值语句就会变为i=i；这样我们就分不清楚两个“i”究竟指的是哪一个。此时我们需要一个指示器来指明究竟哪一个“i”是构造方法中的变量i，哪一个“i”是类中的成员变量i，而这个指示器就是this引用。在Java语言动态方法的作用域中，thi

27、s代表当前的对象，一个变量引用它自己的实例变量及方法时，在每个引用的前面都隐含着this。【例3_10】this引用使用示例1。class Exam3_10 int i; public Exam3_10(int i) this.i=i; public void printI()System.out.println (i=+i);class Testpublic static void main(String args) Exam3_10 e1=new Exam3_10(1); e1.printI(); 程序中的构造函数Exam3_10（int i）的参数与类的成员变量同名，因此我们使用this

28、引用当前对象，这样在这个构造函数中的this.i指的就是类的成员变量i，而没有使用this应用的变量i，指的就是构造函数的参数i。程序的执行结果如图3-9所示。图3-9 例3_10程序运行结果有些时候，方法需要明确使用对当前对象的引用，此时要使用this关键字。this关键字用于获得调用本方法的那个对象的引用。当方法需要访问类的成员变量时，就可以使用this引用指明要操作的对象。【例3_11】this引用使用示例2。class Exam3_11 int i; public Exam3_11(int i) this.i=i;printI(this); public void printI(Exa

29、m3_11 e)System.out.println (i=+e.i);class Testpublic static void main(String args) Exam3_11 e1=new Exam3_11(1); 类Exam3_11的构造方法中调用了方法printI（），但printI（）需要Exam3_11类的一个对象作参数，也就是使用本身这个类的一个对象作参数，此时我们使用this引用当前这个类的对象。程序的运行结果如图3-8所示。352 类的封装性我们知道，类由成员变量和成员方法构成，变量和方法可以封装在一个单个实体中，这是面向对象语言的一个基本特征封装。我们对类可以进行各种操

30、作，也就是对类的成员进行各种操作。但是如果可以访问的类的成员很多，出现问题的机率就会变大，程序的健壮性、稳定性就变得很差。为避免这种情况，在面向对象编程中提出了“强内聚、弱耦合”的编程思想。也就是要求一个类的内部成员之间联系紧密一些，而一个类与其他类之间的联系疏松一些。实现这种“强内聚、弱耦合”编程思想的方式，就是尽可能的把类的成员声明为私有的（private），只把一些少量的、必要的方法声明为公共的（public），提供给外部使用。这种方式使得类功能的实现只在类内可见，在类的外部，则只能访问那些少量的public方法，完成相应的功能。至于实现这些功能的内部机理和过程，在类的外部并不知道也不需

31、要知道，从而减少了用户对类的内部成员的访问，增强了程序的健壮性。这种技术就是封装。它将类的外部界面与类的实现区分开来，隐藏实现细节。迫使用户去使用外部界面，即使实现细节改变，还可通过界面承担其功能而保留原样，确保调用它的代码还继续工作。这使代码维护更简单。3.6类的组织361 包的概念包是Java提供的文件组织方式。一个包对应一个文件夹，一个包中可以包括很多类文件，包中还可以有子包，形成包等级。Java把类文件放在不同等级的包中。这样一个类文件就会有两个名字：一个是类文件的非全限定名，另外一个是类文件的全限定名。非全限定名就是类文件本身的名字，全限定名则是在类文件的名字前面加上包的名字。362

32、 创建包 创建一个包是很简单的：只要使用一个package语句作为一个Java源文件的第一句，则该源文件中所定义的任何类都将属于由此package语句指定的包。其语法格式为：package ;其中package是关键字，包名是包的标识符。package语句使得其所在文件中的所有的类都属于指定的包。例如：package myPackage; 也可以创建包的层次。一个多级包的声明的通用形式如下：package . .;例如，下面的声明在名为MyPackage的包中创建了它的子包secondPackage。package myPackage .secondPackage;需要注意的是，在一个Java

33、文件中，只允许出现一句package语句。【例3_12】创建包的示例。package pa;class Exam3_12 int i; public Exam3_12(int i) this.i=i;printI(this); public void printI(Exam3_12e)System.out.println (i=+e.i);class Testpublic static void main(String args) Exam3_12 e1=new Exam3_12(1); 我们在程序的最前面加上了package pa一条语句，此时类Exam3_12和Test就属于包pa。在执行

34、javac生成语句时，加 d参数，可在指定目录下建立一个以包名命名的文件夹，生成好的class文件会存入该目录中。如上题在生成时可写为：javac d E:myjava Exam3_12.java此时会在E:myjava目录下创建一个pa文件夹，生成的class文件存于该文件夹中。若在生成时不使用 d 参数直接创建新文件夹，也可以先手工建立包文件夹，然后将生成的类存入包文件夹中。但我们一般不推荐使用这种方法。363 访问包包的存在方便了类的管理，但在使用一个类时必须加上类所在包的包名，这会带来编程的不便。为此，Java使用import语句来引入特定的类甚至是整个包。一旦被引入，类可以被直呼其名

35、，而不必使用全限定名。在Java源程序文件中，import语句紧接着package语句（如果package 语句存在的话），它存在于任何类定义之前。下面是import声明的通用形式：import pkg1.pkg2.(classname|*);这里，pkg1是顶层包名，pkg2是在外部包中的用逗点（.）隔离的下级包名。引入包还有另外一种情况，那就是使用一个星号（*）指明要引入这个包中所有的public类。例如：import java.util.Date;/引入java.util.Date类import java.io.*;/引入java.io包中的所有public类【例3_13】访问包的示例。

36、package pa;import java.lang.Math;class Exam3_13 int i; public Exam3_13(int i) this.i=i;printI(this); public void printI(Exam3_13 e)System.out.println (i=+e.i);class Testpublic static void main(String args)int i=(int)(Math.random()*100); Exam3_13 e1=new Exam3_13(i); 程序中我们使用了import java.lang.Math语句引入了

37、Math类，在程序中就可以使用这个类了。我们在main（）方法中使用了Math类的random()方法产生了一个01的随机数，然后将其转化成一个0100的整数，将其作为Exam3_13类的构造函数的参数，来初始化创建的对象。3.7案例一个银行帐户类的设计本节中，我们设计一个银行账户类，其中包括账号、储户姓名、储户身份证号、日期、金额、余额、累计余额等属性，存款、取款、查询等方法，并使用自己的包存储该类。程序如下所示：/银行帐户的属性有账号、储户姓名、储户身份证号、日期、金额、余额、累计余额/银行帐户的方法有存款、取款、查询等，package myaccount;class Account fi

38、nal int Max=5; /操作的次数 private int top; /储户帐目管理的指针 private int Ac_id; /账号 private String Ac_name; /储户姓名 private long Ac_card; /储户身份证号 private String Ac_date=new StringMax; /日期 private int Ac_money=new intMax; /金额 private int Ac_rest=new intMax; /余额 private static int Ac_sum=0; /累计余额 public Account()

39、/构造函数，设置各参数 top=0; /储户帐目管理的指针 Ac_id=0; /账号 Ac_name=; /储户姓名 Ac_card=0; /储户身份证号 void Ac_in(String Ac_name,String aAc_date,int aAc_money)/定义存款的方法 Ac_datetop=aAc_date; Ac_moneytop=aAc_money; Ac_sum=Ac_sum+aAc_money; Ac_resttop=Ac_sum; System.out.println(储户姓名+Ac_name+日期+ Ac_datetop+存入+ Ac_moneytop+存款余额+A

40、c_resttop); top+; void Ac_out(String Ac_name,String aAc_date,int aAc_money)/定义存款的方法 Ac_datetop=aAc_date; Ac_moneytop=-aAc_money; Ac_sum=Ac_sum-aAc_money; Ac_resttop=Ac_sum; System.out.println(储户姓名+Ac_name+日期+ Ac_datetop+取出+ (-Ac_moneytop)+存款余额+Ac_resttop); top+; void Ac_ask(String Ac_name,String aAc

41、_date)/定义查询的方法 Ac_datetop=aAc_date; Ac_moneytop=0; Ac_resttop=Ac_sum; System.out.println(储户姓名+Ac_name+日期+ Ac_datetop+查询存款余额+Ac_resttop); top+; public class BankAccount public static void main(String args) /利用实例，调用储蓄用户 Account zhang =new Account(); zhang.Ac_in(张梁,2003.6.6,3000); zhang.Ac_out(张梁,2003.

42、6.8,2000); zhang.Ac_in(张梁,2003.7.7,3000); zhang.Ac_out(张梁,2003.7.9,1500); zhang.Ac_ask(张梁,2003.7.10); Account li =new Account(); li.Ac_in(李岩,2003.8.6,3000); li.Ac_in(李岩,2003.8.7,2000); li.Ac_in(李岩,2003.9.7,3000); li.Ac_out(李岩,2003.9.9,1500); li.Ac_ask(李岩,2003.9.10); 程序中我们创建了银行储户类Account，在其中定义了相关的属性和

43、方法，为了体现封装。我们将所有的属性都定义为私有的访问权限，使用方法对这些属性进行操作，并将类放到了自定义的包中，最后使用BankAccount类对程序进行了测试。程序运行结果如图3-10所示。图3-10程序BankAccount运行结果小结Java通过类和对象来组织和构建程序。类包括类的声明和类的主体。类的声明使用如下格式：修饰符 class extends 父类名 implements 接口名。其中的修饰符确定了类的特性和访问权限。abstract类是抽象类，final类是最终类，public具有公共访问权限，默认类具有包的访问权限。类的主体包括成员变量和成员方法，声明成员变量的格式为：修

44、饰符 声明成员方法的格式为： ( 参数列表 ) throws 变量和方法的修饰符用以表明其特性。public表明该成员可以被任何类访问，private表明该成员只能被该类所访问，protected表明该成员可以被同一包中所有类及其他包中该类的子类所访问，final表明该成员是不可被改变的，static表明该成员是类的成员或者说是一个静态成员变量，是一个类所有对象共同拥有的。没有任何修饰符则为默认访问权限，表明该成员可以被同一包中的所有类所访问。abstract表明此方法是抽象的，必须被覆盖。类的主体中还包括一个与类名相同无返回值的特殊方法，这就是构造函数。构造函数用来对对象进行初始化。Java

45、虚拟机会自动为类生成一个无参数的默认构造函数，但如果程序中定义了一个或多个构造函数，则会屏蔽掉默认的构造函数。有些方法在使用时需要为其传送参数，this引用可以把当前对象作为参数传递到方法中。类设计好以后，就可以用来定义对象，其格式为： = new 构造函数 （ ）对象是一种引用类型，存放的是实际对象的内存地址。使用对象名来访问对象的成员变量和方法，以实现对对象的操作，完成程序的功能。通常对对象的成员变量和方法的访问是使用成员运算符“”。包是类的组织结构。创建包使用import语句，并要作为源文件的第一句。引入包使用import语句，它紧接着package语句后面（如果package 语句存在的话）。包主要用来管理Java中的类并提供访问控制。实训3一、实训目的1. 类的定义，对象的创建及使用，构造函数的使用。2. 包的创建及使用，类及其成员的访问权限。3. 理解静态和非静态成员变量的区别。4. 学会创建自己的包。二、 实训内容1. 编写一个学校类，其中包括成员变量scoreLine(录取分数线)和对该变量进行设置和获取的方法。学校类仅包括静态成员变量和方法。2. 编写一个学生类，她的成员变量有考生的name(姓名)、id(考号)、intgre