JAVA 编 程 技 术 主编 贾振华 2010年1月

第3章 JAVA的类和对象

非结构化阶段：20世纪五、六十年代，关注与算法实现有关的技术问题和效率问题上，很少关注程序设计的方法问题。使得软件的复用和维护都极为困难。 JAVA 程 序 设 计 的 发 展 非结构化阶段：20世纪五、六十年代，关注与算法实现有关的技术问题和效率问题上，很少关注程序设计的方法问题。使得软件的复用和维护都极为困难。 结构化阶段（面向过程）： 20世纪七、八十年代将问题按功能分模块处理且每一模块内部均是由顺序、选择和循环三种基本结构组成。 面向对象阶段：出现于20世纪八十年代末，九十年代以来的软件设计主流。

结构化程序设计 面向对象程序设计 通常由若干个程序模块组成，每个程序模块都可以是子程序或函数 数据和功能分离，代码难于维护和复用 JAVA 面 向 对 象 的 程 序 设 计 的 方 法 结构化程序设计 通常由若干个程序模块组成，每个程序模块都可以是子程序或函数 数据和功能分离，代码难于维护和复用 面向对象程序设计 基本组成单位是类 程序在运行时由类生成对象，对象是面向对象程序的核心 对象之间通过发送消息进行通信，互相协作完成相应功能

JAVA 万 物 皆 “对 象” Java是面向对象的编程语言，其基本思想是将现实世界中的事物抽象为对象，抽象出来的对象被赋给相应的状态和行为，通过对消息的响应完成一定的任务。在现实生活中，任何事物都可以被认为是对象(Object)，如： ① 电梯 ② 街头的自动售货机 ③ 街上跑的汽车 ④ 凳子 ⑤ 人 ……

类(Class)和对象( Object )是面向对象程序设计方法中最核心的概念。 JAVA 什 么 是 面 向 对 象？ 类(Class)和对象( Object )是面向对象程序设计方法中最核心的概念。 类是对某一类事物的描述(共性)，是抽象的、概念上的定义；而对象则是实际存在的属该类事物的具体的个体（个性），因而也称为实例(Instance) 。 在面向对象设计中，对象并不会凭空产生，首先必须识别出问题中的对象，并对这些对象加以定义，定义一个规范在Java中称为Class，使用类定义出对象的规范，再根据类来构建出一个个的对象，然后通过对象所提供的操作接口来与程序互动。

汽车设计图就是“汽车类”，由这个图 纸设计出来的若干个汽车就是按照该类生产 出的“汽车对象”。 JAVA 面 向 对 象 中 的 “类” 第1辆 第2辆 第3辆

对象是具有某些特殊属性（数据）和行为方式（方法）的实体。 JAVA 面 向 对 象 中 的 “对 象” 对象是具有某些特殊属性（数据）和行为方式（方法）的实体。 对象可以是有生命的个体，比如一个人或一只老虎。也可以是无生命的个体，比如一辆汽车或一台计算机。也可以是一个抽象的概念，如天气的变化或鼠标所产生的事件。 两个特征：属性（Property）和行为（Behavior） 如：一个人的属性有：姓名、性别、年龄、身高、体重等 行为有：唱歌、打球、骑车、学习等。

类描述了对象的属性（静态特征）和对象的行为（动态特征）。类是对象的模板、图纸。 JAVA 类 和 对 象 类描述了对象的属性（静态特征）和对象的行为（动态特征）。类是对象的模板、图纸。 对象(Object)则是类(Class)的一个实例(Instance)，是个实实在在的个体。 如果将对象比做汽车，那么类就是汽车的设计图纸。 面向对象程序设计思想的重点是类的设计，而不是对象的设计。

Java为我们提供了大量的类库，如果从已知的类库入手来构造自己的程序，不仅能有效地简化程序设计，而且能很好地学习面向对象程序设计方法。 类 和 对 象 类是对一个或几个相似对象的描述，它把不同对象具有的共性抽象出来，定义某类对象共有的变量和方法，从而使程序员实现代码复用，所以，类是同一类对象的原型。创建一个类，相当于构造一个新的数据类型，而实例化一个类就得到一个对象。 Java为我们提供了大量的类库，如果从已知的类库入手来构造自己的程序，不仅能有效地简化程序设计，而且能很好地学习面向对象程序设计方法。

单一对象的存在并没有多大的作用，只有多个对象相互作用才会完成复杂的行为。 对象和对象之间是通过传递消息来完成相互通信的。 JAVA 对 象 之 间 的 信 息 传 递 单一对象的存在并没有多大的作用，只有多个对象相互作用才会完成复杂的行为。 对象和对象之间是通过传递消息来完成相互通信的。 一个消息由三方面内容组成： 1）消息的接收者，即消息的目标对象； 2）接收对象采用的方法； 3）执行方法所需用的参数(Parameters)。 例如：一辆自行车放在车棚中并没有什么用，当我们人骑 上它，并加速时才体现它的作用，其中接收者（自行车）， 采用的方法（加速），所需的参数（上升到更高的档位）。

封装性：利用抽象数据类型将数据和基于数据的操作封装在一起，保护数据并隐蔽具体的细节，只保留有限的接口与外界联系。 JAVA 面 向 对 象 的 基 本 特 征 封装性：利用抽象数据类型将数据和基于数据的操作封装在一起，保护数据并隐蔽具体的细节，只保留有限的接口与外界联系。 继承性：使特殊类（子类）的对象拥有一般类 （父类）的全部属性与方法，同时可以增添自 身的属性和方法。 多态性：一个程序中同名的多个不同方法共存 的情况。常用重载和覆盖。

封装是一种信息隐蔽技术 利用抽象数据类型将数据和基于数据的操 作封装在一起 用户只能看到对象的封装界面信息，对象 的内部细节对用户是隐蔽的 JAVA 面 向 对 象 之“封 装” 封装是一种信息隐蔽技术 利用抽象数据类型将数据和基于数据的操 作封装在一起 用户只能看到对象的封装界面信息，对象 的内部细节对用户是隐蔽的 封装的目的在于将对象的使用者和设计者 分开，使用者不必知道行为实现的细节， 只需使用设计者提供的消息来访问对象

对象向外界提供的方法，外界可以通过这些方 法与对象进行交互 受保护的内部实现 功能的实现细节，不能从类外访问。 JAVA 面 向 对 象 之“封 装” 清楚的边界 所有对象的内部信息被限定在这个边界内 接口 对象向外界提供的方法，外界可以通过这些方 法与对象进行交互 受保护的内部实现 功能的实现细节，不能从类外访问。

在面向对象的程序设计中，类封装了数据及对数据的操作，是程序中的最小模块 JAVA 封 装 的 意 义 在面向对象的程序设计中，类封装了数据及对数据的操作，是程序中的最小模块 禁止了外界直接操作类中的数据，模块与模块之间只能通过严格控制的接口进行交互，这使得模块之间的偶合度大大降低 保证了模块具有较好的独立性，程序维护和修改较为容易

是指新的类可以获得已有类（称为超类、基类或父类）的属性和行为，称新类为已有类的派生类（也称为子类） JAVA 面 向 对 象 之“继 承” 是指新的类可以获得已有类（称为超类、基类或父类）的属性和行为，称新类为已有类的派生类（也称为子类） 在继承过程中派生类继承了基类的特性，包括方法和实例变量 派生类也可修改继承的方法或增加新的方法，使之更适合特殊的需要 有助于解决软件的可重用性问题，使程序结构清晰，降低了编码和维护的工作量

类层次结构为网状结构，设计及实现比较复杂 Java语言仅支持单继承 Java语言可通过实现接口来实现多继承功能 面 向 对 象 之“继 承” 单继承 任何一个派生类都只有单一的直接父类 类层次结构为树状结构 多继承 一个类可以有一个以上的直接父类 类层次结构为网状结构，设计及实现比较复杂 Java语言仅支持单继承 Java语言可通过实现接口来实现多继承功能

不同类的对象可以响应同名的消息(方法) ，具体的实现方法却不同 JAVA 面 向 对 象 之“多 态” 一个程序中同名的不同方法共存 主要通过子类对父类方法的覆盖来实现 不同类的对象可以响应同名的消息(方法) ，具体的实现方法却不同 使语言具有灵活、抽象、行为共享、代码共享的优势，很好地解决了应用程序方法同名问题

类是抽象思想的运用。其内部包括属性和方法两个主要部分。 JAVA “类”的 概 念 类是抽象思想的运用。其内部包括属性和方法两个主要部分。 类的作用是定义对象，类是对象的模板(template)一个对象又称作类的一个实例(instance)。 类与对象的关系类似于非面向对象语言中基本类型(type)和变量(varible)。类是一个类型定义，对象是一个变量声明。一旦建立了类，就可以基于类创建对象 实例化对象/创建类实例（由类创建对象） 通过类的定义可以实现代码的复用。

忽略问题中与当前目标无关的方面，以便更充分地注意与当前目标有关的方面 JAVA 类 中 的 抽 象 抽象 忽略问题中与当前目标无关的方面，以便更充分地注意与当前目标有关的方面 计算机软件开发中所使用的抽象有 数据抽象 过程抽象

数据抽象就是针对对象的属性，比如建立一个鸟这样的类，鸟会有以下特征，两个翅膀，两支脚，有羽毛等等特性，写成类都是鸟的属性 JAVA 数 据 抽 象 与 过 程 抽 象 数据抽象：指对象的属性而言。 过程抽象：指对象的行为而言。 数据抽象就是针对对象的属性，比如建立一个鸟这样的类，鸟会有以下特征，两个翅膀，两支脚，有羽毛等等特性，写成类都是鸟的属性 过程抽象就是针对对象的行为特征，比如鸟会飞，会跳等等，这些方面的就会抽象为方法，即过程，写成类都是鸟的方法。

int Hour; int Minute; int Second; 方法(行为) SetTime(); ShowTime(); JAVA 抽 象 举 例 1、钟表 数据(属性) int Hour; int Minute; int Second; 方法(行为) SetTime(); ShowTime();

char *name; char *gender; int age; int id; 方法(行为) 生物行为 Eat(), Walk(),… JAVA 抽 象 举 例 2、人 数据(属性) char *name; char *gender; int age; int id; 方法(行为) 生物行为 Eat(), Walk(),… 社会行为 Work(), Study(),…

对象就是变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。 具有静态特征和动态特征。即： JAVA “对 象”的 概 念 对象就是变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。 具有静态特征和动态特征。即： 属性(成员变量)：描述对象静态特征的一个数据项。 方法(服务、成员函数)：描述对象动态特征(行为)的一个操作序列。 对象的属性域可以是Java中的任意的数据类型 (简单类型、类、接口、数组)

类 对象 类是具有共同属性和行为的对象的抽象。 类可以定义为数据和方法的集合 对象具有特殊属性和行为方式的实体。 JAVA 类 和 对 象 封装的实体=数据+方法 类是具有共同属性和行为的对象的抽象。 类可以定义为数据和方法的集合 对象具有特殊属性和行为方式的实体。 数据或变量 类 方 法 实例化 抽象 属性或状态 对象 操作或行为

类描述了对象的属性（静态特征）和对象的行为（动态特征）。类是对象的模板、图纸。 JAVA 类 和 对 象 类描述了对象的属性（静态特征）和对象的行为（动态特征）。类是对象的模板、图纸。 对象(Object)则是类(Class)的一个实例(Instance)，是个实实在在的个体。 如果将对象比做汽车，那么类就是汽车的设计图纸。 面向对象程序设计思想的重点是类的设计，而不是对象的设计。 一个文件中可以定义数个类，但只能有一个类被设置为public，文件名称必须与这个同名。

Java语言把数据成员称为域变量、属性、成员变量等；而把函数成员称为成员方法，简称为方法。 类 的 构 成 类由数据成员与函数成员封装而成。 Java语言把数据成员称为域变量、属性、成员变量等；而把函数成员称为成员方法，简称为方法。 例如：圆柱体类（Class Cylinder）。 pi radius height area() volume () 成员变量 成员方法

定义类（声明类）实际就是定义类的静态属性和动态属性（方法）。用户定义一个类实际上就是定义一个新的抽象数据类型。 JAVA 类 的 定 义 定义类（声明类）实际就是定义类的静态属性和动态属性（方法）。用户定义一个类实际上就是定义一个新的抽象数据类型。 使用类之前，必须先定义它，然后才可利用所定义的类来声明相应的变量，并创建对象。 包（package）本质上是一个类的集合。包即使一种组织形式，又是一种访问控制功能。

类的定义格式为： JAVA 类 的 定 义 成员变量（对象属性） 成员方法 （对象行为或操作） [类修饰符]class name { type variable1; … type variableN;   type methodname1(parameter-list){ //方法体 } type methodnameN(parameter-list){ 成员变量（对象属性） 成员方法 （对象行为或操作）

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 JAVA 类 的 修 饰 符 public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 friendly（default），默认的修饰符，只有在相同包中的对象才能使用这样的类。       abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。       final， 将一个类生命为最终（即非继承类），表示他不能被其他类继承。     

格式：<修饰符><数据类型><名称>(=<初值>) 修饰符可以为： JAVA 类 的 成 员 变 量 作用范围是整个类。与局部变量不同。 可以使用修饰符来控制变量的作用范围。 格式：<修饰符><数据类型><名称>(=<初值>) 修饰符可以为： static：定义类变量，区分实例变量。 final：用来声明常量，值只能用不能改。 transient：定义暂时性变量，用它声明一个实例变量，当对象存储时，它的值不需要维持。 volatile：定义共享变量，用于多线程共享。被N个线程控制和修改。

类的方法是用来定义对类的成员变量进行操作的，是实现类内部功能的机制，同时也是类与外界进行交互的重要窗口。 JAVA 类 的 成 员 方 法 类的方法是用来定义对类的成员变量进行操作的，是实现类内部功能的机制，同时也是类与外界进行交互的重要窗口。 Java中没有独立的函数和过程，所有的子程序都是作为类方法定义的。 声明方法的语法格式如下： [修饰符] 返回值的数据类型 方法名(形参列表) [throws 异常列表]{ 语句序列； return [表达式]； }

JAVA 圆 柱 体 类 的 定 义 示 例 class Cylinder //定义圆柱体类Cylinder { double radius; //声明成员变量radius int height; //声明成员变量height double pi = 3.14159265; //声明数据成员pi并赋初值 private void area( ) //定义成员方法area()，用来计算底面积 System.out.println("圆柱底面积="+ pi*radius* radius); } void volume( ) //定义成员方法volume ()，用来计算体积 System.out.println("圆柱体体积="+((pi*radius* radius)*height);

对象的声明和创建 类名 对象名； //声明 对象名 = new 类名（参数）；//创建 (2) 对象的使用 对象名.成员变量名； JAVA 类 的 对 象 对象的声明和创建 类名 对象名； //声明 对象名 = new 类名（参数）；//创建 (2) 对象的使用 对象名.成员变量名； 对象名.成员方法名（参数列表）； (3) 对象的销毁 自动垃圾回收机制周期性的释放无用的对象

public class RectangleDemo{ double length; double width; JAVA 类 和 对 象 的 使 用 示 例 public class RectangleDemo{ double length; double width; void setRectangle(double l,double w){ length=l; width=w;} double area(){ return length*width;} public static void main(String args[]){ RectangleDemo r1; r1=new RectangleDemo(); r1.setRectangle(10,20); System.out.println(“area:”+r1.area());} }

装箱就是自动将基本数据类型转换为包装器类型； 拆箱就是自动将包装器类型转换为基本数据类型。 JAVA 装 箱 和 拆 箱 装箱就是自动将基本数据类型转换为包装器类型； 拆箱就是自动将包装器类型转换为基本数据类型。 Integer i = new Integer(10); Integer i = 10; //自动装箱 int n = i; //自动拆箱 参考网页：http://www.cnblogs.com/dolphin0520/p/3780005.html

基本数据类型对应的包装器类型： int（4字节） Integer byte（1字节） Byte short（2字节） Short JAVA 装 箱 和 拆 箱 基本数据类型对应的包装器类型： int（4字节） Integer byte（1字节） Byte short（2字节） Short long（8字节） Long float（4字节） Float double（8字节） Double char（2字节） Character boolean（未定） Boolean

JAVA 装 箱 和 拆 箱 下面这段代码的输出结果是什么？ public class Main { public static void main(String[] args) { Integer i1 = 100; Integer i2 = 100; Integer i3 = 200; Integer i4 = 200; System.out.println(i1==i2); System.out.println(i3==i4); } 在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。 事实上输出结果是：1、true 2、false

public 类、变量、方法 A protected 变量、方法 B+C default B private D JAVA 所有子类C 修 饰 符 总 结 所有类A 包中类B 包中子 类E 所有子类C 本类D public 类、变量、方法 A protected 变量、方法 B+C default B private D

用来说明类、方法或变量的类型。 static 变量、方法 类变量和方法 final 类、变量、方法 常量、终类和方法 native 方法 JAVA 修 饰 符 总 结 用来说明类、方法或变量的类型。 static 变量、方法 类变量和方法 final 类、变量、方法 常量、终类和方法 native 方法 方法体可用其他语言 abstract 类、方法 抽象类和方法 syncronized 线程互斥

final修饰符修饰的成员变量是最终成员变量，不能被修改，同样修饰方法时最终成员方法，不能被改变，也不能被子类重载。 JAVA final 修 饰 符 final修饰符修饰的成员变量是最终成员变量，不能被修改，同样修饰方法时最终成员方法，不能被改变，也不能被子类重载。 用final修饰符修饰的方法不能被重新定义或修改方法的内容，这样可以防止有些子类继承父类的某个方法，然后改写方法并重新定义，形成同名但功能不同的方法，这样引用时就会有方法的重载，如果父类方法有问题也不能及时发现，对关键的方法重定义造成安全漏洞。

为了终止递归调用，通常用if语句来进行控制当条件满足时执行递归调用，否则终止。 例如： JAVA 递 归 方 法 递归问题分为“回推”和“递推”两个阶段 递归调用分为直接递归和间接递归 为了终止递归调用，通常用if语句来进行控制当条件满足时执行递归调用，否则终止。 例如： 有五个人，第五个人比第四个人大两岁，第四个比第三个大两岁，… ，第一个人刚刚好十岁求第五个人多大岁数？

递推法求阶乘：从1开始，乘2，乘3，…,一直乘到n（我们一般用for语句） 递归法求阶乘：n！= n*（n-1）！ JAVA 用 递 归 方 法 求 阶 乘 递推法求阶乘：从1开始，乘2，乘3，…,一直乘到n（我们一般用for语句） 递归法求阶乘：n！= n*（n-1）！

JAVA 汉诺（hanoi）塔经典递归问题 三个为例：

1、将n-1个盘子从一个针移动到另一个针上（n>1）。这是一个递归的过程。 2、将一个盘子从一根针移动到另一个针上。 JAVA 汉诺（hanoi）塔经典递归问题 将n个盘子从A针移动到C针的三个步骤： 1、将A上n-1个盘子借助C移动到B针上 2、将A上剩下的最大的盘子移动到C 3、将n-1个盘子从B借助A移动到C针 三个步骤分为两类操作 1、将n-1个盘子从一个针移动到另一个针上（n>1）。这是一个递归的过程。 2、将一个盘子从一根针移动到另一个针上。

构造函数名称与类名称相同 构造函数没有返回类型 其任务是在创建对象时初始化其内部状态 若无定义系统默认有一个无参构造方法 JAVA 类 的 构 造 方 法 构造函数名称与类名称相同 构造函数没有返回类型 其任务是在创建对象时初始化其内部状态 若无定义系统默认有一个无参构造方法 class Fruit { boolean seedLess; boolean seasonal; float price; Fruit(boolean seed, boolean season, float p) { seedLess = seed; seasonal = season; price = p; }

JAVA Account 类 的 定 义 public class Account { private String accountNumber; private double balance; public Account() { this("empty", 0.0); } public Account(String accountNumber, double balance) { this.accountNumber = accountNumber; this.balance = balance; public String getAccountNumber() { return accountNumber; public double getBalance() { return balance; public void deposit(double money) { balance += money; public double withdraw(double money) { balance -= money; return money;

一种是传值调用（call-by-value），这种方法把变元值复制到子例程的形式参数中。因此，对子例程参数的修改不会影响调用中的参数。 JAVA 方 法 中 的 变 量 传 递 一种是传值调用（call-by-value），这种方法把变元值复制到子例程的形式参数中。因此，对子例程参数的修改不会影响调用中的参数。 另一种是引用调用（call-by-reference），这种方法中，传递给参数的是参数的引用（不是参数值）。在子例程内部，这个引用被用于访问调用中的实际参数。这就意味着对参数的改变会影响用于调用子例程的参数。

Java提供的自动类型转换，也可以应用于重载方法的参数，但是自动类型转换只能在参数和变元之间不能直接匹配时使用，理解这一点很重要。 方 法 重 载 (method overloading) 在Java中，同一个类中的两个或多个方法可以共享同一个名称，只要它们的参数声明不一样就可以，就称为方法重载，这是Java实现多态性的方法之一。（只有返回类型不同，不构成方法重载） Java提供的自动类型转换，也可以应用于重载方法的参数，但是自动类型转换只能在参数和变元之间不能直接匹配时使用，理解这一点很重要。 重载的价值在于允许通过使用同一个名称来访问相关的方法。

与方法一样，构造函数也可被重载，你可以用不同的方式来构造对象了。 JAVA 构 造 函 数 的 重 载 与方法一样，构造函数也可被重载，你可以用不同的方式来构造对象了。 一个构造函数可以把它自己的一个类作为参数吗？可以。重载构造函数允许一个对象初始化另一个对象，这样使用的效率是非常高的。 class Summation{ int sum； Summation(Summation obj){ sum = obj.sum; }

如果要访问一个父类的重写方法，可以使用super关键字 JAVA 方 法 的 覆 盖（重 写 override） 当子类中和父类中的方法的名称相同的时候，子类会覆盖隐藏父类的方法。也就是说，子类在调用方法时，默认调用它自己定义的方法，而将从父类那里继承而来的方法“隐藏” 如果要访问一个父类的重写方法，可以使用super关键字 方法重写只在两个方法的名称与类型签名一致时才发生。如果有不一致的地方，那么两个方法就只是重名而已。签名不同只是对父类的方法的重载。

JAVA 重 写 的 方 法 支 持 多 态 性 方法重写构成了Java最为强大的概念之一：动态方法分配（dynamic method dispatch）。动态方法分配是一种机制，通过该机制对一个被重写方法的调用会在运行时解决，而不是在编译时解决。动态分配十分重要，因为这就是Java实现运行时多态性的机制。 当通过父类引用调用一个被重写方法时，Java会根据在调用发生时引用的对象的类型来确定所要执行的方法。当引用不同类型的对象时，将调用被重写方法的不同版本。

JAVA 方 法 的 重 写 示 例 class Bookputong { String bookname; //成员变量 System.out.println("图书馆藏书"); } void L_book(){ //定义成员方法 System.out.println("一般图书借出期限一个月"); public class refbook extends Bookputong{ System.out.println("此书是工具书，不外借"); public static void main(String[] args) { refbook book1=new refbook(); book1.L_book(); //引用方法

this是区别在一个对象中的一个成员方法引用另外一个对象中同名成员方法的关键字。 JAVA this 关 键 字 this是区别在一个对象中的一个成员方法引用另外一个对象中同名成员方法的关键字。  this关键字的使用格式是 this.成员变量/方法。this代表变量本身，一个类中有两个同名方法，一个属于类（成员变量），一个属于某个特定的方法（局部变量），this变量把他们区分开。当有重载的构造方法时，用来引用同类的其他构造方法，其使用格式是this(参数)。 this关键字在程序里的作用和它的词义接近，它在函数内部就是这个函数所属的对象的引用变量。

subbook(String bookname){ this.bookname = bookname; JAVA this 关 键 字 的 使 用 class Bookputong{ String bookname; subbook(String bookname){ this.bookname = bookname; //将参数中的bookname赋值给Bookputong类的成员变量bookname System.out.println("in subbook:bookname=“ + bookname); }

声明为static的变量本质上都是全局变量，此静态变量是所有对象共享的，不生成变量副本 声明为static的方法有几个限制： JAVA 深 入 理 解 static 类可以创建一个无需引用特定的实例就可以只让自己使用的成员。当一个成员声明为static后，无须引用任何对象就可以在创建类的对象之前访问该成员。（类成员） 声明为static的变量本质上都是全局变量，此静态变量是所有对象共享的，不生成变量副本 声明为static的方法有几个限制： 1、它们只能调用其他static方法 2、它们只访问static数据 3、它们没有this引用

JAVA static 代 码 块 有时一个类在创建对象之前，需要一些初始化类型。例如，它可能需要建立与远程站点的连接，也可能需要在使用任何类的方法之前初始化某些变量。为了处理这些类型的情况，Java允许声明一个static代码块。Static代码块在类第一次被加载时执行。因此它是在使用类之前执行的。

在类加载时，做一些起始动作的程序块。格式： static{ 程序块； } JAVA 静 态 初 始 化 在类加载时，做一些起始动作的程序块。格式： static{ 程序块； } class StaticDemo{ boolean sex; String name; String type; static{ type=“学生”； } float score;

2、Static Member Class 静态成员类 3、Local Class 局部类 4、Anonymous Class匿名类 JAVA 内 部 类（Nested Classes） 1、Member Class成员类 2、Static Member Class 静态成员类 3、Local Class 局部类 4、Anonymous Class匿名类

匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。 这就要采用另一种形式的new语句，如下： JAVA Anonymous Class 匿 名 类 匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。 这就要采用另一种形式的new语句，如下：  new <类或接口> <类的主体>  这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。它还创建那个类的一个新实例，并把它作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数，后跟匿名类的主体。 如果匿名类对另一个类进行扩展，它的主体可以访问类的成员、覆盖它的方法等等，这和其他任何标准的类都是一样的。如果匿名类实现了一个接口，它的主体必须实现接口的方法。

Java中内部匿名类用的最多的地方也许就是在 Frame中加入Listener。 如下： java 代码 Anonymous Class 匿 名 类 Java中内部匿名类用的最多的地方也许就是在 Frame中加入Listener。  如下： java 代码  import java.awt.*;      import java.awt.event.*;       public class QFrame extends Frame {           public QFrame() {                  this.setTitle(\"my application\");                  addWindowListener(new WindowAdapter() {                       public void windowClosing(WindowEvent e) {                        dispose();                        System.exit(0); }    });           this.setBounds(10,10,200,200); }

当一个类的成员为类的对象时，要用new运 2、类对象作为方法的参数 JAVA 类 的 使 用 1、类对象作为类的成员 当一个类的成员为类的对象时，要用new运 算符为这个对象分配存储空间。 2、类对象作为方法的参数 类的对象存储的是对象的引用，因此在方法调用时，实参传递对象的引用。 3、方法返回值为类对象 方法的返回类型也可以为类对象。

如果在程序中没有声明包，类将被存放在默认的包中，这个默认包是没有名字的，对于包含类比较多的程序，不建议采用默认包的形式。 JAVA 包 的 创 建 和 使 用 包是类的逻辑组织形式。在程序中可以声明类所在的包，同一包中类的名字不能重复。通过包可以对类的访问权限进行控制。此外，包是有层次结构的，即包中可以包含子包。 如果在程序中没有声明包，类将被存放在默认的包中，这个默认包是没有名字的，对于包含类比较多的程序，不建议采用默认包的形式。 package < 包名 > import < 包名 >.< 类名 > (包的导入) import java.awt.Button import javax.swing.*; //导入包中所有的类

一个包中只有访问权限为public的类，才能被其他包中的类引用，其他包中具有缺省访问权限的类只能在同一包中使用。 JAVA 包 的 访 问 权 限 一个包中只有访问权限为public的类，才能被其他包中的类引用，其他包中具有缺省访问权限的类只能在同一包中使用。 不同包中类成员的访问权限 1）public类中的public成员可以被其他包中的类访问。public类中的protected成员可以被它派生其他包中的子类访问。 2）缺省访问权限的类成员都不能被其他包中的类访问。