第一章 Java的类 信息管理教研室 孙士兵

第一章 Java的类 1.1 有关面向对象的概念 1.2 Java语言的特点 1.3 Java的开发环境 1.4 第一个Java程序 1.5 Java类型系统 1.6 Java中字符串的类 1.7 Java中的类、方法和变量 1.8 Java名空间及访问规则 1.9 Java中的抽象类、接口和程序包 1.10 对象的构造函数

抽象数据类型、类、类型层次（子类），继承性、多态性。 1.1 有关面向对象的概念 面向对象程序设计围绕的几个主要概念: 抽象数据类型、类、类型层次（子类），继承性、多态性。 面向对象程序设计:一种新的思维方法,更接近人类处理现实世界问题的自然表示方法。 假设你面对现实世界的一个对象,你不会把它的属性和处理方法分开,程序设计也是一样 面向对象的语言有:C++,smalltalk,VB,Java等

1.1 有关面向对象的概念 数据抽象类型 现实生活中的对象 计算机中 的对象的原型 class Car { int color_number; int door_number; int speed; void brake() { … } void speedUp() {…}; void slowDown() { … } } 现实生活中的对象 计算机中 的对象的原型

类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元。 1.1 有关面向对象的概念 什么是类？ 类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元。 程序中的对象 是类的一个实例，是一个软件单元，它由一组结构化的数据和在其上的一组操作构成。 variables methods

软件对象通过相互间传递消息来相互作用和通信 一个消息由三部分组成: 1. 接受消息的对象 2. 要完成方法的名字 3. 方法需要的参数 1.1 有关面向对象的概念 变量：即指对象的所知道的状态 方法：指对象的功能单元。 什么是消息？ 软件对象通过相互间传递消息来相互作用和通信 一个消息由三部分组成: 1. 接受消息的对象 2. 要完成方法的名字 3. 方法需要的参数 对象B 对象 A message

创建一个对象 Hello obj=new Hello(); 调用方法 obj.showString(“Hello World!”) 1.1 有关面向对象的概念 一个例子 在程序中操作对象是类的一个实例:即对象 创建一个对象 Hello obj=new Hello(); 调用方法 obj.showString(“Hello World!”) class Hello { } private String s； public void showString (） { System.out.println(s);} public void changeString(String str) { s=str; return s;}

封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际 1.1 有关面向对象的概念 什么是封装? 封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际 上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 公有数据 数据 私有数据 方法 方法 对象A 对象B

子类是作为另一个类的扩充或修正所定义的一个类. 1.1 有关面向对象的概念 什么是子类? 子类是作为另一个类的扩充或修正所定义的一个类. bicycle (super class) sub class Mountain bikes Tandem bikes Racing bikes

继承是子类利用父类中定义的方法和变量就像它们属于子类本身一样. 1.1 有关面向对象的概念 什么是继承? 继承是子类利用父类中定义的方法和变量就像它们属于子类本身一样. class Car { int color_number; int door_number; int speed; push_break() { … } add_oil() { … } } class Trash_Car extends Car { double amount; fill_trash() { … } }

1.1 有关面向对象的概念 什么是方法的覆盖? 在子类中重新定义父类中已有的方法。 class Car { int color_number; int door_number; int speed; push_break() { speed=0; } add_oil() { … } } class Trash_Car extends Car { double amount; fill_trash() { … } push_break() { speed=speed-10; } }

在同一个类中至少有两个方法用同一个名字，但有不同的参数。 1.1 有关面向对象的概念 什么是方法的重载(多态性)？ 在同一个类中至少有两个方法用同一个名字，但有不同的参数。 void show(int int_num) 123 1.23 void show(double double_num) 类 123,1.23 void show(nit nit_ um, float float_um)

严格的语言定义:“没有依据机器的不同而不同” 或“由编译器决定”等字眼,最后的目标码都是一致的,初值都是确定的 1.2 Java语言的特点 Java是什么？ Java= “C++”--“复杂性和奇异性”+“安全性和可移植性” Java由那些特性？ (1) 面向对象 封装性、多态性、继承性、动态链接 (2) 操作平台无关性 严格的语言定义:“没有依据机器的不同而不同” 或“由编译器决定”等字眼,最后的目标码都是一致的,初值都是确定的

1.2 Java语言的特点 两种工作模式的比较 pentium pentium pentium pentium 编译器 Java编译器 二进制 Java编译器 Java解释器 二进制 Powerpc Powerpc Powerpc Powerpc 源 程 序 源 程 序 中间码 pentium pentium pentium pentium SPARC SPARC SPARC SPARC

1.2 Java语言的特点 . 调入包含,继承所用道的所有类, 内存分配确定,编程真正可执行的机器码 不存在伪造的指针 不违反访问权限 编译,没有绝对地址 调入包含,继承所用道的所有类, 内存分配确定,编程真正可执行的机器码 Java源程序 (.java文件) Java编译器 Java Bytecode (.class文件) 系统执行平台 Bytecode 解释器 Bytecode 载入器 字节码校验器 不存在伪造的指针 不违反访问权限 不非法访问对象 不导致操作栈溢出

1.2 Java语言的特点 Java虚拟机 不同的操作系统有不同的虚 拟机. 它类似一个小巧而高效的CPU. byte-code代码是与平台无关的 是虚拟机的机器指令. Java字节代码运行的两种方式: interpreter(解释方式) Just-in-time(即时编译):有代码 生成器将字节代码转换成本机 的机器代码,然后可以以较高速 度执行. Java interpreter Just-in-time compiler Runtime System Operating System Hardware

1.2 Java语言的特点 (3) 安全问题 Java是在网络环境下使用的语言 一个安全的网络至少要防止以下几种破坏的可能性: 毁灭系统资源 消耗系统资源 挖掘系统或个人机密 骚扰正常工作的进行

1.2 Java语言的特点 Bytecode检查 限定对象的 存取权限 系统堆栈溢出 参数类型一致 语言定义 public protected private final 取消指针 自动回收 垃圾 Java源程序 (.java文件) Java编译器 Java Bytecode (.class文件) Bytecode 载入器 Bytecode 解释器 系统执行平台 程序执行系统 WWW浏览器 限制Java小应用程序 的不正当使用

1.2 Java语言的特点 (4) 多线程 Java提供现成的类Thread，只要继承这个类就可以编写多线程的程序。 (5) Java与C及C++的区别 不再有#include 和#define 等于处理功能 不再有structure,union及typedef 不再有函数、不再有指针、不再有多重继承 不再有goto 不再有操作符重载(Operatior Overloading) 取消自动类型转换,要求强制转换

1.3 Java的开发环境 Java开发环境 JDK JDK中有Java编译器和bytecode解释器Applwtviewer是小应用程序的bytecode解释器 JDK的安装 直接执行JDK.exe

java\bin的目录下包含义下主要文件: javac: Java编译器, 用来将java程序编译成 Bytecode 产生如下目录结构 java\bin的目录下包含义下主要文件: javac: Java编译器, 用来将java程序编译成 Bytecode java: Java编译器,执行已经转换成Bytecode的 java应用程序. jdb: Java调试器, 用来调试java程序 javap: 反编译,将类文件还原回方法和变量. javadoc：文档生成器,创建HTML文件 appletviwer : Java解释器, 用来解释已经转换成 Bytecode的java小应用程序.

1.3 Java的开发环境 \java\lib子目录 库函数,其中classese.zip不要解开. 在autoexec.bat中加入以下两条命令 1. PATH c:\…\java\bin 2. SET CLASSPATH=. ; c:\...\lib\classes.zip; c:\myclasses;

1.3 Java的开发环境 C:\ java lib bin classes.zip javac appletviewer 用户类文件 所在目录 myclasses 当前目录

1.3 Java的开发环境 vj1.1++的使用 1.进入vj,创建一个project 2.加入java文件 3. 编辑java文件 4. 编译java文件 5. Build一个project文件 6. 运行java程序 --如果是小应用程序,则直接在VJ环境下运行 --如果是应用程序,则在dos下运行

文件名要一致性 HelloWorldApp.java 编译程序 : javac HelloWorldApp.java class HelloWorldApp { public static void main(String args[]) { System.out.println(“Hi, ”+args[0]); } 编辑存盘：主类名(含有main方法)和 文件名要一致性 HelloWorldApp.java 编译程序 : javac HelloWorldApp.java 运行程序 : java HelloWorldApp “myjava” 运行结果 : Hi, myjava

1. 声明一个类 : public class HelloWorldApp{} , 类名的第一个字母要大写 1.4 你的第一个Java程序 public class HelloWorldApp { public static void main(String args[]) { System.out.println(“Hi, ”+args[0]); }} 1. 声明一个类 : public class HelloWorldApp{} , 类名的第一个字母要大写 2. 一个类中可有很多方法, main方法是运行程序的第一个方法，方法名的第一个字母要小写. 3. System.out.println是向屏幕输出,相当于C中的printf();

c:>java HelloWorldApp myjava! 6. 字符串的拼接 public class HelloWorldApp { public static void main(String args[]) { System.out.println(“Hi, ”+args[0]); }} 4. 命令行参数的获取 c:>java HelloWorldApp myjava! 6. 字符串的拼接

Java小应用程序不能直接执行和使用,必须要在浏览器中执行 import java.applet.Applet; import java.awt.*; public class HelloApplet extends Applet { public void paint(Graphics g) { g.drawString(“Hello World”,0,50); } } 编辑存盘： 主类名(extends Applet)和文件名一致 编译代码 : javac HelloApplet.java 编写HTML文件 : HelloApplet.html

1. appletviwer HelloApplet.html 2. 在浏览器中运行 运行结果: 1.4 你的第一个Java程序 <html><body> <applet code=“HellApplet.class” width=200 height=100> </applet></body></html> 运行applet程序: 1. appletviwer HelloApplet.html 2. 在浏览器中运行 运行结果: Hello World!

1. import语句相当于C语言中的include每 1.4 你的第一个Java程序 import java.applet.Applet; import java.awt.*; public class HelloApplet extends Applet { public void paint(Graphics g) { g.drawString(“Hello World”,0,50); } } 理解程序 1. import语句相当于C语言中的include每 2. 每一个applet都是java.applet.Applet的子类 用extends继承 3. applet中没有main方法

1.4 你的第一个Java程序 import java.applet.Applet; import java.awt.*; public class HelloApplet extends Applet { public void paint(Graphics g) { g.drawString(“Hello World”,0,50); } } 4. 当applet被浏览器运行时,paint语句自动执行 5. 在applet中与屏幕输出有关的操作通过Graphics对象来实现 6. 一个Java源文件内最多只能有一个public 类,称为主类，且必须和文件名同名

1.5 Java类型系统 Java type system primitive reference null char numeric boolean class interface array integral floating-point byte short int long float double

1.5 Java类型系统 byte 8 位 2 的补码 (byte) 0 short 16位 2 的补码 (short) 0 int 32 位 2 的补码 0 long 64位 2 的补码 0L float 32位 IEEE 754浮点数标准 0.0f double 64位 IEEE 754浮点数标准 0.0d char 16位 同一码字符集 ‘\u0000’ (Unicode character)

1.5 Java类型系统 程序:保留字,标识符(类名、域名、方法名、符号常量、局部变量，标号、…)，操作符、界定符，字面常量。 声明一个变量 int data=10; Boolean isAlived; Java中的操作符:与C基本一致 Java中不再有指针了

1.5 Java类型系统 在Java中”引用“是指向一个对象在内存中的位置,在本质上是一种带有很强的完整性和安全性的限制的指针. 当你声明某个类,接口或数组类型的一个变量时,那个变量的值总是某个对象的引用或者是null引用. 指针就是简单的地址而已,引用除了表示地址而外,还象被引用的数据对象的缩影,还提供其他信息. 指针可以有++,--运算,引用不可以运算.

1.5 Java类型系统 例: String s1;String s2; s1 s1=“a string”; s2 s2=s1; 10001 a string s1=“a string”; s2 10001 s2=s1; class Mydate { int year; int month; int day; } today 10008 Mydate today=new MyDate()

1.5 Java类型系统 能够动态取得的内存有两种,一种是对象实体,一种数组. Java用new申请内存,不需要自己释放不用的内存. 在Java中，定义数组时不必给出数组的大小，因为Java的数组是动态分配的。 数组变量实际上是一个引用变量，因此要实例化才能使用。 例：int Array[]； Array=new int[8]；

1.5 Java类型系统 例：String arrayOfString[]=new String[10]；每个数组元素包含一个对字符串对象的引用，此时值分配了包含字符串引用的空间，并没有对字符串本身分配内存，此时不能访问。 arrayOfString[0] arrayOfString[1] arrayOfString[8] arrayOfString[9] 对 字 符 串 的 引 用 arrayOfString 对数组的引用 for(int i=0;i<arrayString.length;i++) arrayOfString[i]=new String(“Hello”+i)

1.6 Java中的字符串 Java中的字符串类 String和StringBuffer String 类的定义和实例的生成 str=“this is a string” 或: String str1=new String(“hello”); 或: String str2=“aaaa”; String类与其它类型的转换 例1:将实型数转换成字符串 System.out.println(String.valueOf(Math.PI)); .

1.6 Java中的字符串 有两个字符串str1,str2 str1=str2; 是指两个引用指向同一个地址 str1.equals(str2) 是指两个字符串内容相等 获取String对象的信息 例如：String s=“this is a string”; int len=s.length(); boolean result=s.equal(“this is a 特test”); char ch=s.charAt(6);

StringBuffer的字符串的内容是可以改变的 创建StringBuffer对象 1.6 Java中的字符串 StringBuffer的字符串的内容是可以改变的 创建StringBuffer对象 StringBuffer str=new Stringbuffer(“hello”); 获取StringBuffer对象的信息 int len=str.length(); 例:StringBuffer sb=new StringBuffer(“Drink Java!”); sb.insert(6,”Hot ”); System.out.println(sb.toString()); System.out.println 接受的是String类 Drink Hot Java!

1.7 Java中的类、方法和变量 试用一个简单的类 class CarDemo { public static void main(String args[]) { Car Democar=new Car(); DemoCar.set_number(3838); DemoCar.show_number(); }} class Car { int car_number; void set_number(int car_num) { car_number=car_num;} void show_number() { System.out.println (“My car No. is :”+car_number); } } My car number is 3838

1.7 Java中的类、方法和变量 类的继承 关系 class TrashCar extends Car { int capacity; void set_capacity(int trash_car_capacity) { capacity=trash_car_capacity;} void show_capacity(); { System.out.println(“My capacity is: ”+ capacity);}} 1.7 Java中的类、方法和变量 类的继承 关系 class Car { int car_number; void set_number(int car_num) { car_number=car_num;} void show_number() {System.out.println (“My car No. is :”+car_number); } }

TrashCar中继承了Car中的两个方法 1.7 Java中的类、方法和变量 TrashCar中继承了Car中的两个方法 class CarDemo { public static void main(String args[]) { TrashCar DemoTrashCar=new TrashCar(); DemoTrashCar.set_number(4949); DemoTrashCar.set_capacity(20); DemoTrashCar.show_number(); DemoTrashCar.show_capacity(); } Car是父类, TrashCar是子类

1.7 Java中的类、方法和变量 何时选择继承性? 一个很好的经验: “B是一个A吗?” 如果是则让B做A的子类. 常犯的错误A有一个B吗? 例如让汽车轮子成为汽车的子类是错误的

public, abstract, final或者没有 public、protected、private 1.7 Java中的类、方法和变量 public, abstract, final或者没有 类的严格定义及修饰字 [类的修饰字] class 类名称 [extends 父类名称] { …. } 方法和变量的定义及修饰字 public、protected、private [变量修饰字] 变量数据类型 变量名1,变量名2[=变量初值]…; [方法修饰字] 方法的返回值类型 方法名称(参数1,参数2,… { …//方法的内容 }

1.8 Java名空间及访问规则 每个类都创造了有自己的名字空间，指方法和变量可以知道彼此的存在，可以使用。 abstract类不能直接产生属于这个类的对象 final类不能被其他任何类所继承(安全的考虑) public类不但可以被同一程序包中的其它类使用,别的程序包中的类也可以使用. friendly(缺省)类只能被本包中的其它类使用

变量和方法的修饰字public、protected、private 1.8 Java名空间及访问规则 变量和方法的修饰字public、protected、private public: 任何其它类、对象只要可以看到这个类的话，那么它就可以存取变量的数据，或使用方法。 class ABC { public int pub_i=5； public void show)() { System.out.println (“pub_i”+pub_i); }

{ public static void main(String args[]) { ABC abc=new ABC(); 1.8 Java名空间及访问规则 class Demo { public static void main(String args[]) { ABC abc=new ABC(); System.out.println(“abc.pub_i”+abc.pub_i); abc.pub_i=10; abc.show(); } abc.pub_i=5 pub_i=10;

如果一个类中变量或方法有修饰字protected，同一类，同一包可以使用。不同包的类要使用，必须是该类的子类可以存取变量或调用 1.8 Java名空间及访问规则 protected变量和方法 如果一个类中变量或方法有修饰字protected，同一类，同一包可以使用。不同包的类要使用，必须是该类的子类可以存取变量或调用 public class ABC { protected int pro_i=5; protected void show() { System.out.println (“pro_i=” +pro_i;) }

1.8 Java名空间及访问规则 不同中的类不能使用 class DEF { public static void main(String args[]) { ABC abc=new ABC(); System.out.println (“abc.pro_i=“+abc.pro_i); abc.pub_i=10; abc.show(); }

1.8 Java名空间及访问规则 不同包但是是子类 import mytest.pack.ABC; class DEF extends ABC { public static void main(String agrs[]) { DEF def=new DEF(); System.out.println(def.i); def.i=10; def.show(); } } pro_i=5 pro_i=10

1.8 Java名空间及访问规则 private 不允许任何其他类存取和调用 friendly(前边没有修饰字的情况) 在同一程序包中出现的类才可以直接使用它的数据和方法.

当子类中的变量名与父类的相同,原来的变量被遮盖. 1.8 Java名空间及访问规则 当子类中的变量名与父类的相同,原来的变量被遮盖. class demo { public static void main(String args[]) { C c=new C(); c.println_out(); }} class A { int data_a=3;} class B extends A { int data_a=5;} class C extends B { void print_out() { System.out.println(“data_a= ”+data_a); System.out.println(“A.data_a= ”+A.data_a); System.out.println(“B.data_a= ”+B.data_a); }} data_a=5 A.data_a=3 B.data_a=5

方法的覆盖(overriding)和重载(overloading) 1.8 Java名空间及访问规则 方法的覆盖(overriding)和重载(overloading) 子孙类中定义的方法和祖先类中某个方法同名,同参数行,则祖先类中的该方法被覆盖. 方法的重载是指一个对象的多态性,即多个方法用相同的名称,但参数行不同. void show(int int_num) 123 1.23 void show(double double_num) 类 123,1.23 void show(nit nit_ um, float float_um)

1.8 Java名空间及访问规则 到此为止-----final final在方法之前,防止该方法被覆盖. 属于类的变量和方法----static static 在变量或方法之前, 表明它们是属于类的, object b char data object c Object b static int share_data object b class ABCD { char data; static int_share_data; } class Demo { ABCD a,b,c,d}

1.8 Java名空间及访问规则 静态变量在各实例间共享 如果是public静态变量,则其它类可以不通过实例化访问它们 静态方法称为类的方法,因此不用实例化即可调用(面向过程) 一个对象的方法可以访问对象的数据成员,尽管不属于方法的局部变量 一个类的方法只能访问自己的局部变量

1.8 Java名空间及访问规则 例:不正确的引用 class StaticError { String mystring=“hello”; public static void main(String args[]) { System.out.println(mystring);} } 错误信息:can’t make a static reference to nonstatic variable. 为什么不正确? 只有对象的方法可以访问对象的变量.

1.8 Java名空间及访问规则 解决的办法: 1. 将变量改称类变量 class StaticError { static String mystring=“hello”; public static void main(String args[]) { System.out.println(mystring);} }

1.8 Java名空间及访问规则 2. 先创建一个类的实例 class NoStaticError { public static void main(String args[]) { String mystring=“hello”; System.out.println(mystring);} }

1.9 Java中的抽象类、接口和程序包 抽象类是指不能直接被实例化的类,因此一般作为其它类的超类,与final类正好相反 抽象类中的抽象的方法-在该类中定义但不在该类中提供实现,由继承类提供细节 public abstract class SomeAbstractClass { void method1() { System.out.println(“Hi, Java”);} void method2(); } 定义抽象方法的类必须是抽象类.

1.9 Java中的抽象类、接口和程序包 //已有两个类Circle和Rectangle,完成相关参数的计算 class Circle { public int r; Circle(int r) {this.r=r} //this指"这个对象的" public int area() {return 3*r*r; } //取近似 } class Rectange { public int width,height; //这里不需"this" Rectangle (int w, int h) {width=w,height=h;} public int area() {return width*height; }

for (i=0;i<shape.length;i++) { area_total+=shape[i].area(); 1.9 Java中的抽象类、接口和程序包 假设有若干个Circle,以及若干个Rectangle,希望计算它们的总面积,直截了当的做法是将它们分别放到两个数组中,用两个循环,加上一个加法,这种做法是不漂亮的 如果还有其它形状,triangle,ellipses等,上述方法显得“累赘”,我们希望有一种统一的表示,例如用一个数组shape[],接受所有的形状,然后用 for (i=0;i<shape.length;i++) { area_total+=shape[i].area();

abstract class Shape { abstract float area();} class Circle extends Shape { public int r; Circle(int r) {this.r=r;} public float area() { return 3.14*r*r; } } class Square extends Shape {public int width,height; Rectangle (int w, int h){ width=w,height=h;} public float area() {return width*height; } 1.9 Java中的抽象、接口和程序包

1.9 Java中的抽象类、接口和程序包 interface Stack 利用接口可实现多重 继承(可同时实现多个接口） { void push(object x); object pop();} 利用接口可实现多重 继承(可同时实现多个接口） 接口的作用和抽象类 类似,指定原型,不直 接定义方法的内容. 关键字implement用 来实现方法,即在使用时要用给出方法的实际内容 接口中的方法和变量 是public的 class A extends Applet implements Stack { void push(object x) { …;//具体内容 } object pop() …;//具体内容}

使用程序包中的类要用import命令.表示路径,*表示使用包中的所有类 import java.io.FileInputStream； 程序包：相当于其它语言中的库函数 打包 package Graphics; class Square {…;} class Circle {…;} class Triangle {…;} 使用程序包中的类要用import命令.表示路径,*表示使用包中的所有类 import java.io.FileInputStream； import java.io.*； io java FileInputStream

1.10 对象的构造函数 使用new来做内存配置 class Demo1 //数组的配置 { public static void main(String args[]) { int array[][]; array=new int[5][5]; array[1][4]=5; } 使用new来做内存配置 class myClass //对象实体的产生 { int data=5;} class Demo2 { public static void main(String args[]) { myClass obj;//建立一个引用 obj=new myClass(); System.out.println(obj.data); }}

Constructor和finalizer 1.10 对象的构造函数 Constructor和finalizer constructor(构造函数),在一个类中和类同名的方法叫构造函数.系统在产生对象时会自动执行. class UsePoint { Point point_A=new Point(); Point point_B=new Point(5,7); } class Point { int x,y; Point() { x =0;y=0;} Point(int new_x,int new_y) { x=new_x,y=new_y;} }

1.10 对象的构造函数 构造函数应包含哪些内容? 构造函数多半定义一些初值或内存配置工作 一个类可以有多个构造函数(重载),根据参数的不同决定执行哪一个. 如果程序中没有定义构造函数,则创造实例时使用的是缺省函数,它是一个无内容的空函数.

this的作用是要将自己这个对象当作参数,传送给别的对象中的方法. 1.10 对象的构造函数 this this指自己这个对象 this的作用是要将自己这个对象当作参数,传送给别的对象中的方法. class Circle { int r; Circle(int r) {this.r=r;} public area() { return r*r*3;} } class ThisClass { public static void main() { Bank bank=new Bank(); bank.someMethod(this); }

1.10 对象的构造函数 super指这个对象的父类 super用来引用父类中的方法及变量数据. public class apple extends fruits { public apple(int price) { super(price); } } 以上句子表示使用超类的构造函数生成实例 super必须是子类构造器的第一条语句

小结 一个Java程序(包括小应用程序)由若干个类组成,它们分布在由CLASSPATH指定的一个目录中 一个Java程序中只能由一个主类,并且与文件同名. CLASSPATH指定多个目录,它们和起来被看成是这个目录的根,根中的类构成缺省包 目录树中每个子目录中的类的集合对应Java一个包(package),子目录的层次与包的记法的层次对应

package myclass.calculate 小结 package myclass.calculate class A{} class B{} classC{} C:\ java myclass lib javasource bin classes.zip calculate myjava.java javac A B C appletviewer java import java.io.*; import java.awt.Graphics; import mycalss.calculate.*; public class test {} 让PATH包含…\java\bin SET CLASSPATH =.; C:\...\myclasses

--package,class/object,member,局部变量 --public ,private,protected,default 小结 名空间及访问规则 --package,class/object,member,局部变量 --public ,private,protected,default 成员的可视性描述 public protected 缺省 private yes no yes* 同一类中 同一包中 不同包的 子类中 非子类 也不同包

小结 对象模型 ---Java的类和对象(一般,抽象,接口) --继承机制(单继承,多实现) static, import, final的含义和作用

小结 避免在类中使用太多的基本类型 private String senderName; private String senderStreet; private String senderCity; private String senderState; private String senderZip; private String receiverName; private String receiverStreet; private String receiverCity; private String receiverState; private String receiverZip; address sender address receiver