初:
- Java SDK工具：javac java编译器，将java源程序编译成字节码文件。
Java java解释器，解释执行java字节码文件。
Appletviewer Applet程序浏览器，测试和运行Applet程序。
Javadoc java文档生成器。
- 核心Java包：
Java.lang包：封装了所有应用所需的基本类。
Java.awt包： 封装了提供图形用户界面功能的抽象窗口工具类。
Java.applet包：封装了执行Applet应用程序所需的类。
Java.io包：封装了提供输入输出功能的类。
Java.net包：封装了提供网络通信功能的类。
Java.sql包：封装了提供和处理数据库的类。
Java.math包：封装了提供常用数学运算功能的类。
Javax扩展包：封装了与图形、多媒体、事件处理相关的类。（如：javax.swing）
- Java源文件的建立：
1) .创建java源代码文件。
2) .代码中字符区分大小写。
3) .一个可执行语句必须要有以下框架：【
public class Test
{
Public static void main(String args[])
{
·····;//程序代码
}
}
4) .文件保存必须用文件名Test.java保存，即文件名必须要与public class后的类名相同（包括大小写），并使用java作为扩展名。
5) .Java程序开发过程：
编写程序：文件名.java--------->编译器编译程序：javac 文件名.java------->生成字节码文件：文件名.class--------->运行应用程序：Java字节码文件（由Java解释器执行)
- 编译源文件：
1) .WIN+R打开cmd指示器，提示符输入编译命令：javac Test.java
/*若当前目录不是D：/jtest，则应该使用cd命令进入到该目录中。*/
- 执行字节码文件：
1) .字节码非在操作系统环境下执行，而是要通过Java虚拟机（JVM）运行。
2) . 执行： D:jtest>java Test (按Enter键)
- 源文件命名原则：
1) .若源文件中只有一个类，那么源文件名要与此类名相同，扩展名为java。
2) 若源文件中有多个类，则源文件名与有public的类名相同。
3) 若源文件中没有public类，则源文件名字可以与其中任意一个类名相同，扩展名为Java。
4) 类名一般以大写英文字母开头，后面可以是字母、数字等符号。类名的第一个字母不能是数字。
- 注释：
1) .“//”符号，表示从此之后到此行结束语句为注释。
2) .“/*······*/”符号，表示之间的语句为注释。（可多行）
3) .“/**······*/”符号，表示从“**”开始到“*/”结束的部分都作为注释部分（可多行）
- 1).基础程序说明：
【class Example1_1------------------类标志----类名
{
Public static void main(String args[])------------main（）方法
{
System.out.println------命令窗口输出(“Java.Easy! You know?”);---------语句结束标志
}
}
】
3) .System.out.println()还有“原样照印”及简单计算功能。
【
/*输出语句简单计算和“原样照印”*/
Class Example1_1
{
Public static void main(String args[])
{
System.out.println(“5+3=”+(5+3));
}
}
】
**注意：若编译之后提示：“错误：编码GBK的不可映射字符（0xB9)----”这一般是代码中的中文造成的，注释亦包括在内，此时，代码保存编码应当设置为ANSI编码，完美解决问题！**
第一章——数据类型
- Java基本数据类型：
类型 数据类型关键字 适用于 类型长度
字节 byte 非常小的整数 1 -128~127
短整型 short 较小的整数 2 -2^15~2^15-1
整数 int 一般整数 4 -2^31~2^31-1
长整形 long 非常大的整数 8
单精度 float 一般实数 4
双精度 double 非常大的实数 8
字符 char 单个字符 2
布尔 boolean 判断 1
- 常量与变量：
1).声明变量格式：
·变量： 数据类型 变量名1，变量名2，····;
*例： int a; int x,y,sum;//同时声明多个变量，变量之间用“，”间隔
·常量： final int DAY=24；//DAY的值在整个程序中值不变，将其声明为常量。
final double PI=3.14159;//声明圆周率常熟
2) .变量赋值：
变量=表达式；
*例： int x=5; //指定x为整形变量，并赋值为5
char c=’a’; //指定a为字符型变量，并赋初值’a’
·同时对多个相同的变量赋值，可以用逗号分隔。
例如： int X=5,Y=8,sum; sum=x+y; //将x+y的运算结果赋值给变量sum
3) .关键字：
关键字就是Java语言中已经规定的特定意义的单词，用来表示一种数据类型，或表示程序的结构等。不能把这些单词用做变量和常量名。
Java语言中规定的关键字：
【
Abstract、Boolean、break、byte、case、catch、char、class、continue、default、else、extends、false、final、finally、float、for、if、implements、import、instanceof、int、interface、long、native、new、null、package、private、protected、public、return、short、static、super、switch、synchronized、this、throw、throws、transient、true、try、void、volatile、while。
】
4) .转义字符：
转义字符 含义 转义字符 含义
退格 横向跳格（Ctrl-1）
f 走纸换页 ’ 单引导
换行 ” 双引导
回车 \ 反斜杠
- 基本数据类型应用示例：
(1) .Example2_1
(2) .Examplr2_2
(3) 字符型
1).字符型变量:一个字符型变量只能存放一个字符。给字符型变量赋值时， 符需要用单引号扩起来，例如：Char ch=’a’;
*由于’a’的Unicode字符集中的编码是97，因此，上面语句也可以写成：
char ch=97;
/*此处应用详见Example2_3*/
2) .字符串：用双引号括起来的多个（也可以是一个或空）字符常量称为字符串。例如”我对JAVA很痴迷！ ”、“a+b=”等，都是字符串。
·字符串相比较字符有一下区别：
·字符是由单引号括起来的单个字符。字符串是有双引号 扩起来的，而且可以是零个或多个字符。例如：’abc‘是不合法的，”“是合法的，表示空字符串。
（4）布尔型
Java表示逻辑值的基本类型称为布尔型。他只有两个值：true和false，且他们不对应于任何整数值。
*例如： boolean b = true;
/*布尔类型是所有诸如a<b这样的关系运算的返回类型，对管理控制语句的条件表达式也是必需的。*/
布尔类型的用法：Example2_4;
(4) 数据类型的转换
1) .自动类型转换：在程序中已经对变量定义了一种数据类型，若想以另一种数据类型表示时，要符合以下俩条件：·转换前的数据类型与转换后的数据类型兼容
·转换后的数据类型比转换前的数据类型表示的范围大。基本数据类型按精度从”低“到”高“的顺序为：
byte-------->short------->int--------->long-------->float---------->double
低--------------------------------------------------------------->高
当把级别低的变量的值赋给级别高的变量时，系统会自动进行数据类型变换。
2）. 强制类型转换：强制类型转换是指当把级别高的变量的值赋给级别低的变.量 时，必须使用类型转换运算。转换格式为：（类型名）要转换的值或变量；
例如：假设有：
Int a;
Double b=3.14;
则：
a=(int )b;//将b强制类型转换为int类型后，再赋值给a，结果a=3，b仍然是double类型，b的值仍然是3.14。由此可知，强制类型转换可能会降低数据精度。
若a=(int)b;直接转换：a=b;则会由以下错误：
- 基本运算符：
1) .分类：·中有一个运算对象的运算符为一元运算符。：：a++；
·需要两个运算对象的运算符称为二元运算符。：：赋值运算符（=）就是二元运算符，将左边对象赋予右边对象的值。
分为以下几大类：
（1）算术运算符。
（2）关系和条件运算符。
（3）逻辑运算符。
（4）赋值运算符。
（5）其他的运算符。
2) .算数运算符：+、-、*、/、%（取模）。
*运算过程可以灵活运用强制类型转换。
实例：Example2_5
*当一个整数和一个浮点数用运算符来执行单一算术操作时，结果为浮点型，整形数在操作之前会被自动转换为一个浮点型数。下表总结了根据运算对象的数据类型而得到运算结果的返回数据类型，他们在运算操作执行之前就自动进行数据类型转换。
|
结果的数据类型 |
运算对象的数据类型 |
|
long |
任何一个运算对象都不是float或double型，而且至少有一个运算对象为long。 |
|
int |
任何一个运算对象都不是float或double型，也不能为long型。 |
|
double |
至少有一个运算对象为double。 |
|
float |
至少有一个运算对象为float，但不能是double型。 |
·自增：++ 自减： --
· int x=2; int y=(++x)*5 ------> x=3,y=5
· int x=2; int y=(x++)*5 -------> x=3,y=10
3) .关系运算符：
|
运算符 |
运算 |
用法 |
返回true的情况 |
|
> |
大于 |
a>b |
a大于b |
|
>= |
不小于 |
a>=b |
a大于或等于b |
|
< |
小于 |
a<b |
a小于b |
|
<= |
不大于 |
a<=b |
a小于或等于b |
|
== |
等于 |
a==b |
a等于b |
|
!= |
不等于 |
a!=b |
a不等于b |
*写两个两个量的值相等，应当用“==”，而非“=”，“=”是赋值运算符。
实例; Example2_6
·条件运算符
|
运算符 |
运算 |
用法 |
返回true的情况 |
|
&& |
条件与 |
x&&y |
x和y都是true |
|
|| |
条件或 |
x||y |
x或y是true |
|
! |
条件非 |
!x |
x为false |
|
^ |
条件亦或 |
x^y |
x和y的逻辑值不相同 |
- 程序控制语句：
1) .复合语句：用大括号把一些语句括起来构成复合语句
{
X=25+x；
System.out.println(“x=”+x);
}
·控制语句：用于控制程序流程及执行的先后顺序，主要有顺序控制语句、条件控制语句和循环控制语句。
·包语句和引入语句：包语句和引入语句将在后面介绍。
2) . 键盘输入语句：
在java中使用简单文本扫描器Scanner类可以接受用户从键盘输入的数据。Scanner可以从System.in中读取数据。Scanner实现键盘输入数据的方法 如下：
Scanner sc =new Scanner(System.in);
int a =sc.nextInt();
double b= sc.nextDouble();
String str=sc.next();
//整型变量a可以接受键盘输入的整形数值；实型变量b可以接受键盘输入的实型数值；字符串变量str可以接受键盘输入的一串字符数据。实例：Example2_7
补充说明：在Java中：print：打印； println：是（print+line缩写）打印并换行！
3) .顺序控制语句：
顺序控制是程序的最基本结构，包含选择控制语句和循环控制语句的程序，在总体执行上也是按顺序结构执行的。实例：Example2_8
4) .if选择语句：
(1) .单分支：
if（条件表达式）---------->条件表达式必须有括号
{
若干语句.......
}
实例：Example2_9,Example2_10;
(2) .双分支：
if(表达式)
{ 语句块1; }
else
{ 语句块2; }
实例：Example2_11;
5) .switch 语句
switch语句是一个多分枝选择语句，也叫开关语句。他可以根据一个整形表达式有条件地选择一个语句执行。If语句只有两个分支可选择，而实际问题中常常需要用到多分支的选择，当然可以用嵌套if，但若分支太多则程序会冗杂，且效率低。
switch(变量名称或表达式)
{
Case 判断常量 1: {程序段 1; break;}
Case 判断常量 2: {程序段 2; break;}
·
·
·
Case 判断常量 n: {程序段 n; break;}
[default: {程序段 n+1; } ]
}
实例:Example2_13;
6) .循环语句
(1) .for循环
for(循环变量赋初值；循环条件；增量表达式）
{
循环体语句块；-------------->循环体
}
实例：Example2_14
*·for循环中的三个表达式可省略，但“；”不能省略！省略表达式则为无限循环： for( ; ; )
{
······//无限循环
}
·打破for无限循环：Example2_16
(2) .while循环
1) While(循环条件表达式)
{
循环体;
}
while语句执行条件表达式，它返回一个boolean值（true或flase）。如果条件表达式返回true,则执行大括号中的循环体语句。然后继续测试条件表达式并执行循环体代码，直到条件表达式返回false。
实例：Example2_17;
2) do····while语句
do
{
····循环体；
} while（循环条件表达式);
do····while语句与while语句的区别在于，语句先执行循环体在计算条件表达式，所以do···while语句的循环体至少被执行一次。Example2_18;
(3) .continue语句
Continue语句用来阻止本次循环。跳过后面剩余语句，转而执行循环的第一条语句，计算和判断循环条件，决定是否进入下一轮循环。实例：Example2_21;
第二章·对象程序
- 基本概念：
1) .对象：对象是系统中用来描述客观事物的一个实体，是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。
2) .类：
·对象是指具体的事物，而类是指一类事物。
·由类来确定具体对象的过程称为实例化，即类的实例化结果就是对象，而对一类对象的抽象就是类。
·类用class作为关键字。例：
变量：类型、款式、挂挡方式、排量大小
class 汽车
方法：刹车、加速、减速、改变挡位
`当要通过汽车类来创建一个轿车对象，并使用它的刹车行为为方法时，则要用以下格式进行实例化：
汽车 轿车=new（汽车）； //实例化汽车类，即创建轿车对象
轿车.刹车（）； //引用汽车对象的刹车方法
- 类：
·类、对象是java的核心和本质。
1) .类的定义：
(1) .类的一般形式：由类声明和类体组成，而类体又由成员变量和成员方法组成； public class 类名 <----------类声明
{
成员变量； <------------类体
成员方法；
}
·以下为一个具体类的形式：
public class Hello-------------------------------->类声明
{
static String str;---------------------------->成员变量
public static void main(String args[])
{
Str=”Hello World!”; ----->成员方法
System.out.println(str);
}
}
(2) .类声明： 由四部分组成：类修饰符、类关键字class、声明父类、实现接口。其一般形式：
[public][abstract|final]class类名[extends父类名][implements 接口列表]
{
····;
}
·类修饰符：可选项public 、abstract、final是类修饰符。用来说明这个类是一个什么样的类.
public:这个关键字声明了类可以在其它类中使用。缺省时，该类只能被同一个包中的其他类使用。
abstract：声明此类为抽象类，即这个类不能被实例化。一个抽象类可以包含抽象方法，而抽象方法是没有实现空的方法，所以抽象类不具备实际功能，只用于衍生子类。
final：声明该类不能被继承，不能有子类。也就是说，不能用它通过扩展的办法来创建新类。
·类的关键字class：通常类名要用大写字母开头；
·声明父类：extends为声明该类的父类，表明该类是其父类的子类。一个子类可以从他的父类继承变量和方法。*在extends之后只能有一个父类，即extends只能实现单继承。创建子类格式:
class SubClass extends 父类名
{
····；
}
·实现接口：为了在类声明中实现接口，要使用关键字implements，并且在其后面给出接口名。当实现多接口时，各接口名以逗号分隔：
implements 接口1，接口2，···，····
*接口是一种的特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。一个类可以实现多个接口，以某种诚度实现“多继承”。
2) .成员变量和局部变量：
变量 :成员变量（在类体中定义，在整个类中都有效）
局部变量（在方法中定义，只在本方法中有效）
（1）.成员变量：
数据类型 变量名；
*声明的变量类型可以是基本数据类型，也可以是引用数据类型。
数据类型：基本类型（整形、浮点型、逻辑型、字符型）
引用数据型（数组、类对象）
一般声明成员变量的形式：
[可访问性修饰符][static][final][transient][volatile]类型 变量名
1 2 3 4 5
1：说明该变量的可访问属性，即定义哪些类可以访问该变量。该修饰符可分为public、protected、package、private，
2：static：说明该成员变量是一个静态变量（类变量），以区别一般的实例变量。类变量的所有实例使用的是同一个副本。
3：final：说明一个常量。
4：transient：声明瞬态变量，瞬态变量不是对象的持久部分。
5：volatile:声明一个可能同时被并存运行中的几个线程所控制和修改的变量，即这个变量不仅被当前程序所控制，而且在运行过程中可能存在其他位置程序的操作来影响和改变该变量的值，volatile关键字把这个信息传送给Java的云行系统。
（2）.局部变量
在方法中声明的变量以及方法中的参数称为局部变量。局部变量除了作用范围仅适用于本方法之外，其余均于上面讨论的成员变量一致。
例如：
class Data
{
int x=12,y=15;
public void sum()
{
int s; s=x+y; //使用成员变量x=12，y=5
}
}
（3）.屏蔽成员变量
若果局部变量名和成员变量名相同，则成员变量被屏蔽。
class Data
{
int x=12,y=5;
public void sum()
{
int x=3;//局部变量x屏蔽了成员变量
int s;
s=x+y;
}
}-----------------s=3+5=8
·若在sum方法内部还需要成员变量x，则要使用关键字this来引用当前对象，它的值是调用该方法的对象。
class Data
{
int x=12,y=5;
public void sum()
{
int x=3;//局部变量x
int s;
s=this.x+y;//在sum（）方法内使用成员变量，则用this来说明。
}
}-------------s=12+5=17
- 成员方法：
1).方法的一般形式：
返回类型 方法名（数据类型 1 参数1，数据类型2 参数 2,···)------------>方法声明
{
````(局部变量定义）；
···（方法功能实现）；
Return （返回值）；
}
例：
Public static void main（String Args[])----------->方法声明，无返回值
{
String str=”Hello World!”;
System.out.println(str);
}
3) .方法的返回值:
方法的返回值是方法向外界输出的信息。一个方法可以有返回值，也可没有（此时方法类型为void），方法的返回值一般在方法体中通过return语句返回。Return语句一般形式：
return 表达式；------>将方法要输出得东西反馈给主调方法。
实例：3_1
4) .方法的调用:
函数名（实际参数1，实际参数2，```，实际参数n);
*main()方法成为主方法，可以调用其它方法但不允许被其它方法调用。除了main（）方法以外，其他任何方法的关系都是平等的，可以相互调用。例3_3
- 对象：
类是一个抽象概念，对象是类的具体化。
一个对象的生命周期包括三个阶段：创建、使用、释放。
1) .对象的创建:
类名 对象名 =new 类名([参数列表]);----------->该表达式隐含了对象声明、实例化和初始化三个部分。
（1）.对象声明： 类名 对象名;
*对象的引用类似于指针
（2）.实例化（为对象分配内存空间和进行初始化的过程）
对象名=new 构造方法();
2) .对象的使用：
对象要通过访问对象变量或调用对象方法来使用。
通过运算符“.”可以实现对对象自己的变量访问和方法的调用。变量和方法可以通过设定访问权限来限制其他对象对它的访问。
(1) .访问对象的变量：对象创建之后，对象就有了自己的变量。对象通过使用运算符“.”实现对自己的变量访问。
访问对象成员变量： 对象名.成员变量;
例如：class A { int x ;}
欲对其变能量x赋值，则先创建并实例化类A的对象a，然后再通过对象给变量x；
A a= new A(); a.x=5;
(2) . 调用对象的方法：
对象名.方法名([参数列表]);
(3) . 释放对象
当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。但由于垃圾收集器自动收集垃圾操作的优先级较低，因此也可以用其他一些办法来释放对象所占用的内存。
例如：System.gc();
要求垃圾回收，此时垃圾回收线程将优先得到运行。
*另外，还可以使用finalize方法将对象从内存中删除。Finalize方法可以完成包括关闭已打开的文件、确保在内存不遗留任何信息等功能。Finalize方法是Object类的一个成员方法，Object类处于Java类分级结构的顶部，所有类都是它的子类。其他子类可以重载finalize方法来完成对象的最后处理工作。
5.面向对象的特征： Java三个特性：封装性、继承性、多态性。
1) .封装性：封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节。在Java中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象的行为。通过对象的封装，实现了模块化和信息隐藏。
(1) 修饰符
为了对类对象封装，通过对类成员修饰符施以一定的访问权限，从而实现类中成员的信息隐藏。格式：
Class 类名
{
[变量修饰符] 类型 成员变量名;
[方法修饰符] 返回类型 方法名（参数）{```}
}
变量修饰符：[public或protected或private]、[static]、[final]、[transient]、[volatile]。
方法修饰符：[public或protected或private]、[static]、[final或abstract]、[native]和[synchronized].
(2) 访问权限的限定
·private: 在一个类中被限定为private的成员，只能被这个类本身访问，其他类无法访问，如果一个类的构造方法声明为private，则其他类不能生成该类的一个实例。
·default： 在一个类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
·protected： 在一个类中被限定为protected的成员，可以被这个类本身、他的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
·public ：在一个类中限定为public的成员，可以被所有的类访问
|
限定词 |
同一个类 |
同一个包 |
不同包的子类 |
不同包非子类 |
|
Private |
√ |
|
|
|
|
Default |
√ |
√ |
|
|
|
Protected |
√ |
√ |
√ |
|
|
Public |
√ |
√ |
√ |
√ |
2).继承性
即一个类可以从另一个类即其他的的父类继承状态和行为。背继承的父类也可以称为超类；继承父类的类称为子类。
(1) 子类的定义：
class SuperClass
{···}
class SubClass extends SuperClass
{····}
*通过继承可以实现代码复用。Java所有的类都是通过直接或间接得继承java.lang.Object类得到的.
实例：Example3——11，3——10，3——11——1
(2) 成员变量的隐藏和方法的重写：
子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。
*子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是方法体不同。
子类中重写了父类的方法，则运行时系统调用子类的 方法；若果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。
例：Example3——12
(3) Super 关键字
Java中同关键字super来实现对父类成员的访问，super用了来引用当前对象的父类。Super使用三种情况:
·访问父类被隐藏的成员变量或方法。
Super.variable;
·调用父类中被重写的方法。
Super.Method([paramlist]);
·调用父类的构造方法。（子类不继承父类的构造方法，当要在子类中使用父类的构造方法时，则可以使用super来表示，并且super必须是子类构造方法中的第一条语句。
例如：Example3_12_3
(4) This 关键字
This时java的关键字，表示某个对象，this可以用于构造方法和 实例方法，但不能用于类方法。
·this用于构造方法时，代表调用该构造方法所创建的对象。
·this用于实例方法时，代表调用该方法的当前对象。
This的使用格式为： this.当前类的成员方法();或
this.当前类的成员变量；
Example3_12_4
3).多态性:
多态是指一个程序中同名的方法共存的情况，有时需要利用这种“重名”现象来提供程序的抽象性和简洁性。
(1) .编译时多态、运行时多态。
4).其他修饰符的用法：
(1).final关键字：可以修饰类、类的成员变量和成员方法，但对其作用是各不相同。
·final修饰成员变量: 可以用final修饰变量，目的是为了防止变量的内容被修改，经final修饰后，变量就成为了常量。一般形式：
Final 类型 变量名；
*在用final修饰成员变量时，在定义变量的同时就要给出初始值。
·final 修饰成员的方法：当一个方法被final修饰后，则该方法不能被子类重写。其形式为： final 返回类型 方法名（参数）
{
····
}
·final 修饰类： 一个类用final修饰后，则该类不能被继承，即不能成为超类。其形式为： final class 类名
{
····
}
(2) .static关键字：
声明时用static关键字修饰，则声明为静态变量和静态方法。在调用静态方法时，不要进行实例化而直接调用。Example3_13
(3) .类成员与实例成员的区别
·实例变量和类变能量：每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。
·实例方法和类方法：实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。 但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可以由实例对象进行调用。类方法中不能使用this或super关键字。 Example3_14
- 接口：
（1）.接口：接口是抽象类的一种，只包含常量和方法的定义，而没有变量和具体方法的实现，且其方法都是抽象方法。它的用处体现在下面几个方面：
·通过接口实现不相关类的相同行为，而无需考虑这些类之间的关系。
·通过接口指明多个类需要实现的方法。
·通过接口了解对象的交互界面，而无需了解对象所对应的类。
1).接口定义的一般方式：
接口定义包括接口声明和接口体。
|
[public] interface 接口名[extends 父接口名] { ··· //接口体 } |
*extends子句与类声明的extends子句基本相同，不同的是一个接口可有多少个父接口，用逗号隔开，而一个类只能有一个父类。
2) .接口的实现
在类的声明中用implement子句来表示一个类使用某个接口，在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法。一个类可以实现多个接口，在implements子句用逗号分开。
实例：Example3_16
（2）。接口应用：
例3——17，3——18.
- 包：
(1) .包的创建：
·包定义：包是类的容器，用于分割类名空间。把一个源程序归入到某个包的方法用package来实现.
·package语句的一般形式为：
|
Package 包名： |
包名有层次关系，包名的层次必须与java开发系统的文件系统目录结构相同。简言之，包名就是类所在的目录路径，各层目录之间以“，”符号间隔。通常包用小写字母表示，这与包类名以大写字母开头的命名约定有所不同。
·一个包内的java代码可以访问该包的所有类以及类中的非私有变量和方法。
(2) .包的引用：
·要使用包中的类，必须用关键字import导入这些类所在的包。
|
import 包类.类名; |
·import语句一般形式：
*当要引用包中所有的类或接口时，类名可以用通配符“*”代替。
第五章：图形用户界面设计
- 图形用户界面概述：
(1) .awt、swing图形用户界面包
图形用户界面的构件一般包括菜单、输出组件、按钮、画板、窗口和对话框等，这些组件构成Java抽象窗口工具包（abstract window toolkit，AWT）。
awt图形用户界面包称为awt组件，也叫重量组件。
swing图形用户界面包称为swing组件，也叫轻量组件。
swing是awt的子类。
(2) .swing组件的层次结构
swing组件在awt基础上建立，包括标准图形用户界面的要素，如：窗口、对话框、构件、事件处理、版面设计管理及接口和例外处理等。
swing组件层次结构：
java.lang.Object
java.awt.Component
java.awt.Container
java.applet.Applet
javax.swing.lapplet
java.awt.Window
java.awt.France
java.swing.JFrame
javax.swing.JComponent
- 窗体容器和组件：
(1) .窗体容器JFarme类
JFrame是带有标题、边框的顶层窗体。窗体是一个容器，在其内部可以添加其他组件。
1) .创建窗体
·法一：创建JFrame类的子类，并重写其构造方法；
·法二：创建JFrame类的一个对象；
JFrame win = new JFrame(“最简窗体”);
2) .JFrame类的方法：常用如下：
|
方法名 |
功能 |
方法名 |
功能 |
|
JFrame(); |
创建无标题的窗体 |
setSize(int width,int height); |
设置窗体大小 |
|
JFrame(String s); |
创建标题为s的窗体 |
Validate(); |
使窗体中的组件能显示出来 |
|
setMenuBar(MenuBar mb); |
设置菜单 |
setTitle(String title); |
设置标题内容 |
|
dispose(); |
关闭窗体，释放占用资源 |
getTitle(); |
获取标题内容 |
|
setVisible(bolean b); |
设置窗体可见性 |
setDefaultCloseOperation(int operation) |
设置窗体的关闭按钮可用，其中常数operation为EXIT_ON_CLOSE |
实例：构造对象设计窗体：Example5_1 利用子类设计窗体：Example5_2
(2).按钮和事件处理:
1).按钮JButton类
在Java中，javax.swing包中的JButton类用于构建按钮对象。
·JButton类的常用用法：
|
方法名 |
功能 |
|
|
|
JButton() |
创建不带标签文本或图表的按钮 |
setText(String s) |
设置按钮上的标签文本内容 |
|
JButton(Action a) |
创建一个按钮，其属性从Action中获取 |
setIcon(Icon icon) |
设置按钮上的图标 |
|
JButton（Icon icon) |
创建一个带图标的按钮 |
setHorizontalTextPosition(int textPosition) |
参数textPosition确定按钮上图标的位置，取值为SwingConstants.RIGHT、SwingConstants.LFFT、SwingConstants.CENTER、SwingConstants.LEADING、SwingConstants.TRAILING |
|
JButton(String text) |
创建一个带标签文本的按钮 |
setVerticalTextPosition(int textPosition) |
参数textPosition确定按钮上图标的位置，取值为SwingConstants.CENTER、SwingConstants.TOP、SwingConstants.BOTTOM |
|
JButton（String text,Icon icon) |
创建一个带标签文本和图标的按钮 |
setMnemonic(char c) |
设置按钮的快捷键为（Alt +C） |
|
getLable() |
获取按钮上的标签文本内容 |
setEnabled（boolean a） |
设置按钮可否单击 |
|
setLabel(String label) |
设置按钮的标签文本内容 |
addActionListener(ActionListener l) |
设置事件源的监视器 |
|
removeActionListener(ActionListener l) |
删除时间监视器 |
3) .创建按钮对象： JButton btn = new JButton(String text);
*由于按钮是一个普通的组件，设计时必须放置到一个容器中。
实例：Example5_3
·处理按钮事件
要定义按钮的处理事件，就要用到ActionListener接口，ActionListener是java.awt.event包中的一个接口，定义了事件的处理方法。Java.awt.event包对这个接口的定义是：
Public interface ActionListener extends EventListener
{ //说明抽象方法
Public abstract void actionPerformed(ActionEvent e)
}
在设计按钮对象btn处理事件的类时，就要实现这个接口。其一般形式为：
class ClassName implements ActionListener
{
····
Btn.addActionListener(this);
·····
Public void actionPerformed(ActionEvent e)
{
·····
}
}
基本代码：
|
import javax.swing.*; import java.awt.FlowLayout; import java.awt.event.*; class Btn extends JFrame implements ActionListener { ImageIcon icon=new ImageIcon("win.jpg"); JButton jbtn=new JButton("oppen new win",icon); Btn() { setSize(400,300); setVisible(1==1); setDefaultCloseOperation(EXIT_ON_CLOSE); setLayout(new FlowLayout()); add(jbtn); validate(); jbtn.addActionListener(this); } public void actionPerformed(ActionEvent e) { JFrame newf=new JFrame("new bord"); newf.setVisible(2==2); } } public class Example5_4_1 { public static void main(String args[]) {
new Btn(); } } |
- 面板容器和界面布局管理：
（1）.面板JPanel类
面板JPanel是一个可放置，
- JComponent类组建的使用：
- 菜单与对话框：
- 树：