类的结构

来源：互联网发布：淘宝店铺免费推广编辑：程序博客网时间：2024/05/21 17:18

一、类的定义形式
类定义的一般形式如下

[类定义修饰符] class <类名>

{ //类体

[成员变量声明] [构造函数]

[成员方法]

}

前面说过，在描述java语法时，方括号中的内容都是可以省略掉的。实际上任何程序设计相关语法都是如此，这是国际通行的标准。那么，要定义一个最简单的类就是如下的写法：
class Test
{

}
这个类因为类体没有包含任何内容，所以什么也不干，同时如果直接调试该程序，可以编译，但是运行错误，提示错误信息如下：“错误: 在类 Test 中找不到主方法, 请将主方法定义为: public static void main(String[] args)”。
为什么会出现这个错误呢？因为讲过前面，一个java程序或者说一个java项目，必须有一个主类（主类内容接下来会讲），主类必须有一个主方法，主方法就是程序的入口，即程序首先是从主类的主方法中开始运行的，所以运行该程序自然会提出错误信息。
二、类的定义解释
1、类的定义：类的定义通过关键字class来实现，所定义的类名应符合标识符的规定。类的名字必须由大写字母开头而单词中的其他字母均为小写；如果类名称由多个单词组成，则每个单词的首字母均应为大写例如TestPage；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample。还有一点命名技巧就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词。
2、类定义修饰符修饰符:修饰符可以省略，也可以是public, protected, private, static, final，其中public、protected , private三个最多只能出现其中之一，可以与static, finaf组合起来修饰属性。

3、成员变量声明

成员变量是类的属性，声明的一般格式为：
[变量修饰符] <成员变量类型> <成员变量名>变量修饰符:public、protected、private、和默认（frieddlly）。4、构造函数一般我们讲的“函数”就是“方法”，构造函数是一个特殊的函数，虽然在类定义的过程中用方括号括起来，即我们可以不写构造函数，但是java系统会默认自动为每个类生成一个缺省的不带任何参数的构造函数，在创建对象时系统会调用缺省的构造函数。如果程序中定义了构造函数，系统将不再提供该缺省的构造函数。构造函数具有如下特点：（1）构造方法的方法名必须与类名相同，其它方法不能和类名相同。

　　（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。　　（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。　　（4）构造方法不能由编程人员调用，而由系统调用。　　（5）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。　　（6）构造方法可以重载，以参数的个数，类型，或排列顺序区分。
使用无参数构造函数的例子

[java]view plaincopyprint?

1 class Test {

2 String name;

3 Test(){

4 name="韦小宝";

5 }

6 public static void main(String[] args){

7 Test t1=new Test();

8 System.out.println(t1.name);

9 t1.name="康熙";

10 System.out.println(t1.name);

11 }

12 }

13

class Test {

String name;

Test(){

name="韦小宝";

}

public static void main(String[] args){

Test t1=new Test();

System.out.println(t1.name);

t1.name="康熙";

System.out.println(t1.name);

}

执行程序，输出结果如下：韦小宝康熙在程序中并没有对对象 t1的name变量进行赋值，而打印输出 t1.name 输出结果是“韦小宝”，此时Test类的构造函数中对name变量进行了初始化，输出的就是初始化的值；而对t1对象的name属性进行了赋值后，此时输出结果就是重新赋值后的值，即“康熙”。使用有参数构造函数的例子

[java]view plaincopyprint?

14 class Test {

15 String name;

16 Test(){

17 name="韦小宝";

18 }

19 Test(String myName){

20 this.name=myName;

21 }

22 public static void main(String[] args){

23 Test t1=new Test();

24 System.out.println(t1.name);

25 Test t2=new Test("康熙");

26 System.out.println(t2.name);

27 }

28 }

29

class Test {

String name;

Test(){

name="韦小宝";

}

Test(String myName){

this.name=myName;

}

public static void main(String[] args){

Test t1=new Test();

System.out.println(t1.name);

Test t2=new Test("康熙");

System.out.println(t2.name);

}

执行程序，输出结果如下：韦小宝康熙

5、成员方法成员方法定义的类的操作和行为，一般形式为：
[方法修饰符] <方法返回值类型> <方法名>（[<参数列表>]）
{
方法体
}
成员方法修饰符主要有public、private、protected、final、static、abstract和synchronized七种，前三种的访问权限、说明形式和含义与成员变量一致。
与成员变量类似，成员方法也分为实例方法和类方法。如果方法定义中使用了static ,则该方法为类方法。public static void main(String [] args)就是一个典型的类方法

三、类的修饰符及其访问范围
前面说了修饰符，但是没有说起含义，这里讲解一下常见的类访问修饰符：

可见度

public

protected

private

缺省

同一类中可见

是

同一包中对子类可见

是

否

是

同一包中对非子类可见

是

否

是

不同包中对子类可见

是

否

不同包中对非子类可见

是

否

关于包、子类概念之后讲解。

Java程序在定义类时，除了使用class关键字标识之外，还可以在class之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类。修饰符之间的先后排列次序对类的性质没有任何影响。

一）非访问修饰符。

1，  抽象类：
   凡是用abstract修饰符修饰的类被称为抽象类。抽象类就是没有具体对象的概念类。
   抽象类是一种经过优化的概念组织方式：把共同特点抽象出来；其后在描述和处理某一种具体对象时，就只需描述不同的特殊之处。这种组织方式使得所有的概念层次分明，简洁洗练，非常符合人们日常的思维习惯。
   由于抽象类是它的所有子类的公共属性的集合，所以使用抽象类的一个优点就是可以充分利用这些公共属性来提高开发和维护程序的效率。
   值得一提的是，面向对象技术是要用更接近于人类思维方式的方法来处理实际问题，抽象类的设立就是这种思想的具体体现之一，它是模仿人类的思维模式的产物。

2，最终类：
   如果一个类被final修饰符所修饰和限定，说明这个类不可能有子类。
   被定义为final的类通常是一些有固定作用、用来完成某种标准功能的类。如Java系统定义好的用来实现网络功能的InterAddress、Socket等类都是final类。
      abstract和final修饰符不能同时修饰一个类，因为abstract类自身没有具体对象，需要派生出子类后在创建子类的对象；而final类不可能有子类。这样放在一起修饰就没有意义了。

3，有些类的修饰符也可以用来修饰类中的域或方法：

(1) 域：是类和对象的静态属性，定义域的操作就是说明变量或创建对象的操作。

<1> 静态域：
用static修饰符修饰的域是仅属于类的静态域。静态域是类中每个对象共享的域。他们是类的域，不属于任何一个类的具体对象。是一个公共的存储单元，任何一个类的对象访问它时，取到的都是相同的数值。

<2> 静态初始化器：
 静态初始化器是由关键字static引导的一对大括号括起的语句组。作用是：在加载时，初始化类的静态域。
 与构造函数相同，他们都是用来完成初始化的工作，但是静态初始化器与构造函数有三点不同：
 ①构造函数是对每个新创建的对象初始化，而静态初始化器是对类自身进行初始化。
 ②构造函数是在用new运算符产生新对象时由系统自动执行，而静态初始化器则是在它所属的类加载到内存时由系统调用执行。
 ③不同于构造函数，静态初始化器不是方法，没有方法名、返回值和参数列表。

<3> 最终域：
 用final修饰的域，实际上就是Java中的常量。
 用final修饰符说明常量时，需要注意以下几点：
 ①需要说明常量的数据类型。
 ②需要同时指出常量的具体取值。
 ③因为所有类对象的常量成员，其数值都固定一致，为了节省空间，常量通常声明为static。

<4> 易失域：
如果一个域被volatile修饰符所修饰，说明这个域可能同时被几个线程所控制和修改，即这个域不仅仅被当前程序所掌握，在运行过程中可能在其他未知的程序操作影响和改变该域的取值。在使用当中应该特别注意。
通常，volatile用来修饰接受外部输入的域。如表示当前时间的变量将系统的后台线程随时修改，以保证程序中取到的总是最新的当前系统时间，所以可以把它定义为易失域。

(2)方法：是类的动态属性，标志了类所具有的功能和操作。小括号是方法的标志。

<1> 抽象方法：
修饰符abstract修饰的抽象方法是一种仅有方法头，而没有具体的方法体和操作实现的方法。使用抽象方法的目的是使所有的子类，对外都呈现一个相同名字的方法，是一个统一的接口。所有的抽象方法，都必须存在于抽象类之中。

<2> 静态方法：
用static修饰符修饰的方法，是属于整个类的类方法，不用的是对象或实例的方法。调用这种方法时，应该使用类名作前缀；这种方法在内存中的代码段将随着类的定义而分配和装载，不被任何一个对象专有；只能处理属于整个类的成员变量。

<3> 最终方法：
用final修饰符修饰的类方法。功能和内部语句不能再更改的方法，不能再被继承。
注意：所有已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被缺省地认为是final的。

<4> 本地方法：
用native修饰符声明其他语言书写方法体并具体实现方法功能的特殊的方法。这里的其他语言包括C/C++/FROTRAN/汇编等。由于native的方法的方法体使用其他语言在程序外部写成，所以所有的native方法都没有方法体，而用一个分号代替。

<5> 同步方法：
如果synchronized修饰的方法是一个类的方法（即static的方法），那么在被调用执行前，将把系统类Class中对应当前类的对象加锁。如果synchronized修饰的是一个对象的方法（未用static修饰的方法），则这个方法在被调用执行前，将把当前对象加锁。Synchronized修饰符主要用于多线程共存的程序中的协调和同步。

二）访问控制符。
访问控制符是一组限定类、域或方法是否可以被程序里的其他部分访问和调用的修饰符。类的访问控制符只有一个public，域和方法的访问控制符有四个，分别是public、private、protected、private protected，另外还有一种没有定义专门的访问控制符的缺省情况。

1，  公有访问控制符public：
     Java的类是通过包的概念来组织的，包氏类的一个松散的集合。处于同一个包中的类可以不需要任何说明而方便的互相访问和引用，而对于不同包中的类，则不行。但当一个类被声明为public时，他就具有了被其他包中的类访问的可能性，只要这些其他包中的类在程序中使用import语句引入public类，就可以访问和引用这个类。
   类中被设定为public的方法是这个类对外的接口部分，避免了程序的其他部分直接去操作类内的数据，这实际就是数据封装思想的体现。
   每个Java程序的主类都必须是public类，也是基于相同的原因。
   用public修饰的类的域称为公共域。如果公共域属于公共类，则它能被所有的其他类所引用。public修饰符会造成安全性的数据封装性下降，所以一般应减少public域的使用。

2，缺省访问控制符：
   缺省访问控制权规定，该类只能被同一个包中的类访问和引用，而不可以被其他包中的类使用，这种访问特性又称为包访问性。
   同样道理，类内的域或方法如果美育访问控制符来限定，也就具有包访问性。
   简单说，定义在同一个程序中的所有类属于一个包。

3，私有访问控制符private :
用private修饰得域或方法只能被该类自身所访问和修改，而且不能被任何其他类（包括该类的子类）来获取和引用。private修饰符用来声明那些类的私有成员，它提供了最高的保护级别。

4，保护访问控制符protected :
用protected修饰的成员变量可以被三种类所引用：该类自身、与它在同一个包中的其它类、在其他包中的该类的子类。使用protected修饰符的主要作用是允许其他包中该类的子类来访问父类的特定属性。

5，私有保护访问控制符 private protected :
用private protected修饰的成员变量可以被两种类访问和引用，一种是该类本身，一种是该类的所有子类。把同一个包内的非子类排除在可访问的范围之外，使得成员变量更专于具有明确继承关系的类，而不是松散地组合在一起的包。

class Animal {
String name;
int age;
Animal(){
name="Dog";
age=3;
}
Animal(String name,int age){
this.name=name;
this.age=age;
}
}
public class AnimalDemo{
public static void main(String args[]){
Animal a=new Animal();
Animal b=new Animal("cat",5);
System.out.println(a.name+" is "+a.age+" years old");
System.out.println(b.name+" is "+b.age+" years old");
}
}

四、类的加载机制：

1、在虚拟机的生命周期中一个类只被加裁一次
2、加载的原则是：延迟加载
3、类加载的时机
1）当第一次创建对象时要加载
2）调用static方法时要加裁，访问static属性时要加裁，调用static代码块时要加载
3）当加载子类时会先加裁父类
4）创建对象引用时不加裁类
5）子类调用父类的static方法时会加裁
在这里要注意的是：当子类没有重写父类的static方法时，只加裁父类不加裁子类。当子类重写了父类的静态方法时既加裁父类又加裁子类。
6）访问static常量时，如果编译器在以计算出常量的值可以不加裁类，否则会加裁。
7）用Class.forName(类名)来显示的加载一个类

五、java编程多个类的程序运行。

在一个*.java的文件中，只能有一个public class的声明，但是允许有多个class的声明，即一个源文件（*.java）中只能有一个公共类，可以有若干默认类。举例：

[java]view plaincopyprint?

30 class Animal {

31 String name;

32 int age;

33 Animal(){

34 name="Dog";

35 age=3;

36 }

37 Animal(String name,int age){

38 this.name=name;

39 this.age=age;

40 }

41 }

42 public class AnimalDemo{

43 public static void main(String args[]){

44 Animal a=new Animal();

45 Animal b=new Animal("cat",5);

46 System.out.println(a.name+" is "+a.age+" years old");

47 System.out.println(b.name+" is "+b.age+" years old");

48 }

49 }

class Animal {

String name;

int age;

Animal(){

name="Dog";

age=3;

}

Animal(String name,int age){

this.name=name;

this.age=age;

}

public class AnimalDemo{

public static void main(String args[]){

Animal a=new Animal();

Animal b=new Animal("cat",5);

System.out.println(a.name+" is "+a.age+" years old");

System.out.println(b.name+" is "+b.age+" years old");

}

[java]view plaincopyprint?

50 <pre style="margin: 4px 0px; background-color: rgb(240, 240, 240);" class="java" name="code"><pre></pre>

51 <div>程序执行结果：Dog is 3 years old

52 cat is 5 years old</div>

53 本例中AnimalDemo.java源文件中有两个类：Animal类和 AnimalDemo类，AnimalDemo类作为公共类，也就是主类，该类中有主方法；默认类（Default类）Animal类定义了两个构造方法，没有主方法，程序编译时生成两个

54 字节码文件，分别是Animal.class 和 AnimalDemo.class。在AnimalDemo类中调用了

55 Animal类实例化对象，并进行相应的数据处理。注意当一个源文件中有多个类的时候，使用主类作为文件名。

56 同样，我们可以将一个源文件中的多个类分解成多个源文件，即一个类为一个源文件。比如上面的例子。源文件：Animal.java<pre class="java" name="code">class Animal {

57 String name;

58 int age;

59 Animal(){

60 name="Dog";

61 age=3;

62 }

63 Animal(String name,int age){

64 this.name=name;

65 this.age=age;

66 }

67 }</pre>

68 源文件：AnimalDemo.java<pre class="java" name="code">public class AnimalDemo{

69 public static void main(String args[]){

70 Animal a=new Animal();

71 Animal b=new Animal("cat",5);

72 System.out.println(a.name+" is "+a.age+" years old");

73 System.out.println(b.name+" is "+b.age+" years old");

74 }

75 }</pre>在命令提示符下，执行下面三个步骤：1、编译Animal.java文件（javacAnimal.java）2、编译AnimalDemo.java文件（javacAnimalDemo.java）3、执行AnimalDemo.javae文件

76 （javaAnimalDemo）。

77 也可以直接编译运行AnimalDemo文件，即直接从上面第二个步骤执行，当程序编译AnimalDemo源文件时，遇到 Animal a=new Animal()语句时，会自动编译Animal源文件。java程序中，就是由这样的类组成个应用程序，在编写过程中，一般采用

78 一个类一个源文件的方式进行编程，一遍对类进行维护和修改。<pre style="font-family: monospace; font-size: 18px; white-space: pre;" class="java" name="code"><pre class="java" name="code"><pre class="java" name="code"></pre>

79 <pre></pre>

80 <pre></pre>

81 <pre style="margin: 0px 0px 10px; padding: 0px; zoom: 1; word-wrap: break-word;" id="content-813471319" class="reply-text mb10" name="code"></pre>

82 <pre></pre>

83 <pre></pre>

84 <pre></pre>

85 <pre></pre>

87 </pre></pre></pre>

0 0