《JAVA程语言课程报告》
学 院： 江苏联合职业技术学院 专业班级： 计算机应用0961 学 号： 20 姓 名： 何佳雯 完成时间：
2013年3月28日
Java 历史与概述
Java概述
– 美国Sun公司开发的一种编程语言与平台
– 世界上第一种具有硬件、操作系统无关性的程序语言 – 在不同硬件、不同操作系统下运行时，不需要重新编译 – 一种“一次编译，到处使用”的语言
– 起源于1991年的绿色计划，原计划用于消费类电子产品 Java语言的特点
– 简单(Simple)
容易编写程序，程序小巧，能够在小型机器，甚至家电、机顶盒、手机上执行
– 面向对象(Object-Oriented)
是一种纯粹的面向对象语言，没有全局变量和全局函数，只有类和对象
– 分布式的(Distributed)
可以很容易地与TCP/IP通讯协议相配合，方便地实现B/S和C/S以及点对点网络程序结
构
Java语言的特点
– 鲁棒的(Robust)
Java程序具有相当高的稳定性。Java具有完善的变量类型检查、变量初始化检查、数组下标越界检查、无用变量回收机制，因此能够最大限度地提高程序的鲁棒性 – 安全的(Secure)
Java拥有多层的互锁(Interlocking)保护措施，能有效地防止病毒的侵入和破坏行为的发生
Java语言的特点
– 结构中立的(Architecture Neutral)
Java编译器产生一种结构中立的目标文件格式，可以在多种处理器和操作系统中执行，
1
而不用考虑不同机器的差异 – 可移植的(Portable)
Java的简单数据类型是不随操作系统变化的。Java程序库所定义的接口也是对所有的操作系统都适用的。这些都使Java具备良好的可移植性
Java语言的特点
– 解释的(Interpreted)
Java解释器能直接在任何机器上执行Java二进制码(Bytecodes)，这样就省去了在不同机器上编译、连接的时间。这对于缩短程序的开发过程，有极大的帮助 – 高效能的(High Performance)
Java二进制码能被迅速转换成机器码，Java二进制码的执行效率正在逐渐逼近其它编译语言的执行效率
Java语言的特点
– 多线程(Multi Threaded)
Java语言具有多线程的功能，这对于交互式程序以及实时响应程序是很有帮助的 – 动态的(Dynamic)
Java比C或C++语言更具有动态性，更能适应时刻在变的环境，Java不会因程序库的更新，而必须重新编译程序
Java编译与运行的特点
– 既是编译语言又是解释语言
– 编译性：将源程序编译成与平台无关的一种中间语言，称为Java二进制码 – 解释性：运行时，Java平台逐句分析解释并运行Java二进制码 Java平台的概念
– 平台：为程序提供运行环境的硬件和操作系统的总称 – Java平台：纯软件的，为Java提供统一的运行环境 Java平台的组成结构
– Java虚拟机(JVM)
– Java应用程序界面(Java API) Java平台的组成结构
– Java虚拟机：解释并运行Java二进制码
– Java API：由许多软件包组成，这些软件包可以实现很多功能，包括图形界面功能
Java 历史与概述
Java平台的组成结构
– 最底层是硬件层，表示Java系统运行的硬件和操作系统； – 第二层是Java虚拟机层，这层是Java平台的核心；
– 第三层是Java程序界面层，这层提供了许多功能软件包； – 最顶层是应用程序层，也就是在Java平台上运行的应用程序。 Java应用程序界面的主要内容
– 底层：Java平台目前可以运行的操作系统，如Solaris, Windows, Linux, Mac OS等；
– 中间层：Java API的内容：applet（小程序）, math（数学工具），text（文本处理），awt（图形界面），net（网络），util（常用功能），io（输入/输出），swing（Swing图形界面），lang（基本Java语言）等。
– 上层：Java的编译器javac，开发与调试工具
创建第一个Java程序
1. 用记事本编写源程序：
创建第一个Java程序
2
源程序：
/*
* 文件名: FirstApp.java
* 功 能: 显示\"天天好心情!\" * 编写: 张三
* 编写时间: 2004.06.03 * 修改: 李四
* 修改时间: 2004.08.15 */
public class FirstApp {
public static void main(String[] args) { // 显示\"天天好心情!\"
System.out.println(\"天天好心情!\"); } }
第二章 Java语言基础
面向对象基础
对象的基本特征
– 状态：对象的状态用一个或多个变量表示，这些变量称为成员变量– 行为：对象的行为用函数或子程序实现，它们称为成员函数 – 一个对象就是一组变量和函数形成的一个软件包
面向对象基础
面向对象程序的特点
– 一切都是对象： – 程序是对象的组合： – 对象有自主存储空间： – 对象属于特定的类：
面向对象基础
Java程序结构
– 对象是全局性的
– Java中没有全局变量和全局函数 – 所有的函数都属于特定的类
– 除少数几种基本变量以外，Java中的所有变量类型都是类
变 量
变量定义与变量类型
– 变量：用于保存数据。变量在使用前需要先进行定义和初始化
double resValue = 12.1 + 25.8;
– 变量的定义：给变量设定名字和类型
type name;
– “type”表示变量类型，“name”表示变量名 变量类型
– 简单变量的类型 变量类型的跨平台性
– 变量的表示范围不随操作系统变化
int型：32位，范围为-2147483648~2147483647
3
float型，32位，IEEE 754规范 double型：64位，IEEE 754规范
– 字符型变量是16位Unicode字符类型，可以直接表示包括中文在内的各国文字
变量名
– 变量名需要满足的条件：
变量名必须以字符开头；
必须是一串连续的Unicode字符，不能有空格，也不能有减号（否则会与减法相混淆）； 变量名不能是Java关键字，逻辑值（true或false），以及保留字null；
在同一个有效区域里的变量名必须唯一，不同区域（比如不同子程序里）里的变量名
可以重复。
变量名
– Java关键字列表 Java变量名的命名规范
– 变量名以小写字母开头，类名以大写字母开头，常量名全部由大写字母组成 – 如果变量名由多个单词组成，则将单词连在一起写，每个单词的首字母大写
例：flagDone, totalNum
– 常量：多个单词间以下划线连接
例：MAX_INTEGER, MAX_ARRAY_NUM
中文变量名
– 对于16位Unicode字符，汉字与英文字母没有区别
– 可以在变量名中使用汉字，也可以混合使用汉字、英文字母，如：
int 整数 = 5; char 汉字 = '文';
double 费用_Fee = 3.3;
常数的类型
– 默认的常数类型： 引用变量
– 简单变量仅能存储简单的数据，对于复杂的数据，必须用引用变量来表示
– 引用变量里存储的仅仅是一个指针，它指向真正的对象所在地。例如下面的例子： 变量的初始化
– 所谓初始化，就是给变量赋一个初值
– 任何变量，在访问它的值以前，必须先要给它赋一个值，否则结果是不可预料 – 简单变量的初始化：只需赋一个值即可，还可以在变量定义时即将其初始化 int aNum = 0;
double aValue = 0.0; char aChar = ''; 变量的初始化
– Java语言对变量初始化的要求非常严格，如果变量存在未初始化的可能，则提示出错，不能继续编译
– 在Delphi语言中，对于变量可能未初始化的问题只会给出一个警告，还可以继续编译 – C/C++语言根本不提示此类问题，完全由程序员自己把握 引用变量的初始化
– 用new语句在内存中创建一个对象，再将引用变量指向这个对象 TheClass aClass;
aClass = new TheClass();
4
– 程序第一行定义了一个引用变量，aClass，此时它还只是一个空的指针；
– 第二行语句在内存中创建了一个TheClass型的对象，再将变量aClass指向该对象
最终变量
– 最终变量的值在初始化之后就不能再变了。最终变量相当于常量 – 最终变量的定义：使用final关键字：
final int aConstInteger = 25;
– 最终变量的定义和初始化也可以分开： final int aConstInteger; aConstInteger = 25;
– 最终变量在定义之后应当尽快初始化，以免发生多次赋值而出错
运算符
什么是运算符
– 运算符对1个、2个或3个参数完成一项函数功能 – 按参数的数量划分：
一元运算符、二元运算符和三元运算符 – 按功能划分：
可分为5类：算术运算符、关系与条件运算符、移位与逻辑运算符、赋值运算符、其它运算符
运算符的形式
– 一元运算符又可分为前缀符号和后缀符号 – 前缀符号的运算符在运算数之前，如“++a” – 后缀符号的运算符在运算数之后，如“a++”
– 二元运算符只有一种形式，就是运算符在两个运算数之间，例如：“a + b” – 三元运算符只有一个：“op1 ? op2 : op3”，它相当于一个简化的条件选择语句 算术运算符
– 包括基本的四则运算：加法“+”，减法“-”，乘法“*”，除法“/”，余数“%” – 算术运算符都支持浮点数和整数运算 算术运算符
– 如果两个运算数是相同类型的，则运算的结果也是同样类型
– 如果两个运算数类型不同，Java会先将数值转换为较精确的类型，再进行计算，结果也是较精确的类型
– 数据类型精度的次序：
byte – 4个一元运算符，其中“++”和“--”运算符各有前缀和后缀两种形式 其它的算术运算符 – 最容易混淆的是“op++”和“++op” ，例如： int a1 = 10; int a2 = 10; int b1, b2; b1 = a1++; b2 = ++a2; 关系运算符 – 比较两个值是否满足某种关系。如果满足，则返回 “true”(真)，否则返回 “false”(假) – 常用的关系运算符： 5 关系运算符 – 在Java中，“=”代表给变量赋值，而用“= =”代表相等，这与传统的习惯不同 – 初学者往往习惯性地用“=”表示相等，从而出现“if (a = b) {...}”的错误 按位运算符在设置逻辑标志时非常有用，通过按位运算符可以方便地设置、修改、访问每个标志位的状态 赋值运算符 – “=”：最基本的赋值运算符，将一个变量或常量的值赋给另一个变量。例如： int a = 5; // a的值为5 a = 8; // 现在a的值为8 – 快捷赋值运算符，用于同时实现算术、移位或按位操作与赋值操作。例如： i = i + 2; – 可以用快捷赋值符号“+=”表示： i += 2; 赋值运算符 – 快捷赋值运算符列表： 其它运算符 – “? :”，是唯一的一个三元运算符，形式为： op1 ? op2 : op3 – 首先判断op1，如果op1为真，则返回op2的值；如果op1为假，则返回op3的值 – “(变量类型)”，将变量转换成指定类型： float b = 3.6; int c = (int)b * 2; – b被强制转换成整数，抛弃小数部分以后的值为3，于是c = 6 运算符的优先级列表 分支与循环结构 分支控制语句 – if语句：是最基本的分支控制语句，使程序根据条件有选择地执行语句 – if语句的形式如下： if (关系表达式) { 语句 } – 它的含义是：如果关系表达式为真，则执行后面花括号里的语句，否则就不执行花括号里的语句 分支与循环结构 分支控制语句 – 例：对于前面的例子，如果当a不是正数时也需要在屏幕上显示，语句如下： if (a > 0) { System.out.println(\"变量a是正数。\"); } else { System.out.println(\"变量a是负数或零。\"); } – 当a不是正数时，执行else内的代码，显示“变量a是负数或零” 分支控制语句 – 组合的if ... else 语句：例，要求当a是正数、a是负数、a是零时分别显示： if (a > 0) { 6 System.out.println(\"变量a是正数。\"); } else if (a < 0) { System.out.println(\"变量a是负数。\"); } else { System.out.println(\"变量a是零。\"); } 分支控制语句 – 处理多种选择问题的方法： 利用多个if ... else结构 利用switch语句处理 – switch语句的语法结构： switch语句将IntVar的值与每个case语句的整数值比较 如果符合，就执行这个case中的语句 如果不与任何一个case符合，就执行default中的语句 分支控制语句 – switch分支的特点： – 每个分支均以一个break语句结尾 – 作用是跳出switch结构 – 如果没有break语句，那么程序在执行完这个case的代码后，会接着执行下面一个case的代码 例题：不带break语句的switch结构 switch (n) { case 1: System.out.println(\"n的值是1\"); case 2: System.out.println(\"n的值是2\"); case 3: System.out.println(\"n的值是3\"); case 4: System.out.println(\"n的值是4\"); case 5: System.out.println(\"n的值是5\"); default: System.out.println(\"n的值不在预设范围内。\"); } 循环控制语句 – 循环控制语句的作用是反复执行一段代码 – 常用的循环结构： while循环 do ... while循环 for循环 – 循环结构的组成部分： 循环头（控制语句） 循环体（代码） 循环控制语句 7 – while循环 while (条件表达式) { 语句 } – 当条件表达式为真时，反复执行花括号中的语句，直到条件为假，则退出循环 – 例：计算1+2+3+...，一直到结果大于100，求此时加到的最大的数是多少 循环控制语句 – 例题程序如下： int sumx = 0; int x = 0; while (sumx <= 100) { x ++; sumx += x; } System.out.println(\"最大的加数为：\" + x + \"。\"); – 程序的核心是一个while循环结构，当sumx没有超过100的时候，反复执行累加程序 循环控制语句 – do...while结构，形式如下： do { 语句 } while (条件表达式) – while结构和do...while结构的差异： while循环：先判断，再执行。如果一开始循环条件就不满足，则循环内的语句根本不会执行 do...while循环：先执行，后判断。不管循环条件满不满足，循环内的语句至少会执行一遍 循环控制语句 – while和do ... while结构对比例题 // 例题1 int a = 105; while (a <= 100) { a += 20; } System.out.println(\"a的值是：\" + a); // 例题2 int a = 105; do { a += 20; } while (a <= 100) System.out.println(\"a的值是：\" + a); 循环控制语句 – for循环： for (初值; 终值; 增量) { 语句 } – for循环一般用于已知循环次数的程序中 – 初值部分用来初始化循环变量，终值部分设定循环的结束条件，增量部分用于在每次循环中改变循环变量的值 循环控制语句 – 例题：计算从1加到100的总和 8 int sum = 0; for (int i = 1; i <= 100; i++) { sum += i; } System.out.println(\"1加到100的总和为：\" + sum); 在for结构中，int i = 1定义了一个整数变量i，并且设它的初值为1； i <= 100给出了循环的结束条件，当i <= 100不成立时，循环就会自动跳出； i++设定了每个循环中循环变量i的增量，每次循环时i的值都会增加1。 中断控制语句 – Java语言支持3种中断语句： – break：强行退出循环，不执行循环体中剩余的语句和剩余的循环次数 – continue：停止继续执行循环体中下面的语句，跳回循环起始位置开始下一次循环 – return：退出整个函数 第三章 类的封装、继承和多态 类与对象 Java中的类 – 在Java程序中，类是由定义和主体构成的 完整的类定义格式： public abstract final class 类名 extends 父类名 implements 接口名 { 类的主体 } – 类定义中，必需的部分是 “class”关键字和类的名字，其它部分都是可选的 成员变量与成员函数 成员变量 – 成员变量的完整定义形式如下： accessLevel static final transient violatile type name – 其中用黑体字标的变量类型和变量名是必需项，其它都是可选项 成员变量 – name：成员变量名也是必需项，它的命名要求与普通变量名相同 – 在一个类里，你不能定义两个相同名称的成员变量，但允许成员变量和成员函数起相同的名字，例如： public class Calculator { public double a, b; public double add; public double add() { return(a + b); } } 成员函数 9 – 成员函数与类相似，是由函数定义和函数主体构成的，如下图所示： 函数定义部分包括函数的访问级、返回值的类型、函数名称和参数列表 函数主体是花括号里的部分，它包括实现函数功能所需要的代码 成员函数 – 能否在函数中改变参数的值 public class TestSum { public void Sum(double sumx, double x) { sumx = sumx + x; } public static void main(String[] args) { TestSum aTest = new TestSum(); double sumx, x; sumx = 0; x = 3; aTest.Sum(sumx, x); System.out.println(\"累加结果为：\" + sumx); } } 成员函数 public class TestStr { public void ChangeString(StringBuffer OldStr, StringBuffer NewStr) { OldStr.append(NewStr); } public static void main(String[] args) { TestStr aStr = new TestStr(); StringBuffer Str1 = new StringBuffer(\"新年\"); StringBuffer Str2 = new StringBuffer(\"快乐！\"); aStr.ChangeString(Str1, Str2); System.out.println(Str1); } } 成员函数 – 这种情况常出现于对象的构造函数中： public class Circle { public int x, y, radius; public Circle(int x, int y, int radius) { this.x = x; . . . } } – 构造函数的作用是为对象设定初值，因此函数的参数难免与成员变量重名，此时通过“this”就可以毫不费力地对二者进行区分 成员函数 – 一个函数只能有一个返回值： public double Sum(double x1, double x2) { double sumx; sumx = x1 + x2; return sumx; } 函数地返回值可以赋给变量： double y; y = Sum(5, 3); 10 成员函数 – 对于带返回值的函数，Java语言要求从程序结构上保证函数一定可以返回一个值 – 为便于理解，考虑下面的例子： public int Test() { if (7 > 5) { return 1; } } – 很明显，“7 > 5”永远成立，因此“return 1”语句一定会被执行，函数一定有返回值 – 但这段程序在编译时不能通过 成员函数 – 成员函数内可以有“this”，“super”对象，它们分别特指函数所属对象本身和它的父类 成员函数 – 函数定义的完整形式，其中黑体字的部分为必需项： accessLevel static abstract final native synchronized returnType methodName (paramList) throws exceptions 成员变量的初始化 – 对象的成员变量是自动初始化的 – 当用new关键字来产生一个对象时，对象的所有成员变量都自动初始化： DemoClass aDemo = new DemoClass(); – 初始化的结果： 整型、浮点型变量赋值为0 字符型赋值为空 逻辑型赋值为false 引用变量赋值为空，不指向任何一个对象 构造函数 – 构造函数是一类特殊的成员函数，它的函数名与类名相同，没有返回值，也不用将返回值类型设为void – 如果一个类有构造函数，在构造这个类的时候，将会自动调用构造函数 – 可以在构造函数中对指定的变量赋初值，与直接赋初值相比，构造函数灵活许多，并且不受变量先后次序的影响 构造函数 – 一个类可以同时拥有几个构造函数，每个构造函数的自变量不同，初始化对象时根据自变量的不同自动选择合适的构造函数 – 例题：源代码见教材，该例题中有三个构造函数： public Tree() { . . . } public Tree(double Height) { . . . } public Tree(int Age) { . . . } 类的封装性 封装性与访问级控制 – 类的一个优势在于类可以保护它的成员变量和成员函数不会被其它对象随意访问到 – 在Java程序里，可以为成员变量和函数设定四级访问级： 11 private protected public package 类的继承性 类的继承的概念 – 一个类可以从另一个类中继承它的成员变量和函数，前者称为子类，后者称为父类。类 的这种特点称为继承性 – 类的继承通过extends关键字来说明，extends关键字跟在类名称后面，形式如下： – class ClassName extends FatherClassName { ... } – 其中ClassName是子类名，FatherClassName是父类名 类的继承性的特点 – 在Java中，一个类只能有一个父类 – Java只支持单继承，而不支持多重继承 – 如果需要多重继承，Java提供了一种接口技术，可以部分地实现多重继承的功能 类的继承性的特点 – 在Java中定义的所有类都直接或间接地是Object类的子类。以Object类为根，所有Java类形成一棵类继承树，如下图所示： 类的继承性的特点 – 子类可以继承的部分： (1) 父类中公开级的成员； (2) 父类中保护级的成员； (3) 如果子类和父类在同一个包里，则子类继承父类中缺省的包访问级的成员； – 子类不能继承的部分： (1) 父类中私有级的成员； (2) 如果不在同一个包里，则缺省级的成员； (3) 同名的成员函数或成员变量； 继承中的构造函数 – 构造函数是比较特殊的一类 – 在继承时，构造函数不会被继承，也不会被覆盖 – 父类和子类的构造函数依然是独立存在，并且分别发挥着作用 class Drawing { Drawing() { System.out.println(\"Drawing constructor\"); } } public class Cartoon extends Drawing { Cartoon() { System.out.println(\"Cartoon constructor\"); } public static void main(String[] args) { Cartoon x = new Cartoon(); } } class BoardGame { BoardGame(int i) { System.out.println(\"BoardGame constructor\"); } } public class Chess extends BoardGame { Chess() { super(11); 12 System.out.println(\"Chess constructor\"); } public static void main(String[] args) { Chess x = new Chess(); } } 类的多态性 多态性的作用 – 数据抽象、继承性和多态性是面向对象编程思想的基本特性 – 多态性将函数的功能与实现分开，也就是说，将“做什么”与“怎样做”分开了 成员的覆盖 – 在类的继承中，除了继承来的父类成员外，子类也可以有自己的成员 – 如果子类的某个成员变量或成员函数与父类的同名，子类的成员函数或成员变量将隐藏父类的同名成员，这称为成员的覆盖： class Super { int aNumber = 10; } class Subbie extends Super { double aNumber = 2.87; } 成员的覆盖 – 例：BoardGame及其子类的Play函数： class BoardGame { public void Play() { System.out.println(\"Play a board game.\"); } } public class Chess extends BoardGame { public void Play() { System.out.println(\"Play a chess.\"); } } 类的多态性 – 如果用父类的变量指向子类，再调用同名的函数，会出现什么情况呢？ BoardGame aBoard = new Chess(); aBoard.Play(); – 运行程序，显示的结果是： Play a chess. – 可见，父类的变量指向子类对象，在调用函数时，实际调用的仍然是子类的函数，这就是类的多态性 多态性 – 这种调用过程称为“后期绑定” – 前面涉及到的函数调用都是“前期绑定”，编译时就根据变量类型定好了所调用的函数 – 后期绑定是在执行的时候，再根据变量实际指向的对象类型（不是变量本身的类型）来决定所调用的函数 – 利用后期绑定，一个函数调用语句可能不同类型的函数，这种现象就是多态性 函数的重载 – 重载是指一个类的多个成员函数具有相同的名称，但有不同的参数 public void Add(Complex x1, Complex x2) { realPart = x1.realPart + x2.realPart; imagPart = x1.imagPart + x2.imagPart; } public void Add(Complex x1, double x2) { realPart = x1.realPart + x2; imagPart = x1.imagPart; 13 } public void Add(double x1, Complex x2) { realPart = x1 + x2.realPart; imagPart = x2.imagPart; } public void Add(double x1, double x2) { realPart = x1 + x2; imagPart = 0; } 覆盖、多态性与重载的区别 – 重载：一个类中有多个函数有相同的名字，但参数不同（严格地说是参数类型列表不同） – 在调用这些函数时，Java根据调用时给出的参数自动选择适当的函数 – 可以认为，在Java里，两个函数名相同，不代表两个函数相同，只有函数名和参数都相同的时候才是“真正”相同 覆盖、多态性与重载的区别 – 覆盖和多态性就涉及到“真正”相同的函数之间的关系 – 覆盖：如果父类和子类的函数相同，当你通过子类调用函数时，你所调用的就只是子类的函数，父类的函数被覆盖了 – 多态性：反过来，当你通过父类调用函数时，如果变量所指向的是一个子类对象，那么所调的仍然是子类函数，这就是多态性 抽象类与抽象函数 抽象函数和抽象类的概念 – 抽象函数：仅有定义，没有具体实现的函数 – 抽象类：含有抽象函数的类 – 定义一个抽象类，需要在类的定义前面加上“abstract”关键字 – 定义一个抽象函数，需要在函数定义的前面加上“abstract”关键字 – 一个类如果被定义为抽象类，它就不能实例化，也就是说，不能有自己的对象 抽象类的使用 – 抽象化的Game类： public abstract class Game { public abstract void Play(); public abstract String GetRule(); } – 可以定义抽象类的变量，但不能创建对象： Game myGame; – 抽象类变量可以指向Game的子类，再利用多态性来调用子类的Play或GetRule函数 抽象类的使用 – 抽象函数的意义是没有具体实现的函数 – 它的作用就是被子类的相同函数覆盖，或通过多态性指向子类的相同函数 – 通过抽象函数，可以定义一整套完整的函数功能，再派生出若干子类来实现 – 不同的子类可以以不同的形式实现这些功能，但函数形式是完全一致的 – 抽象类必须有子类，不然就没有意义 抽象类的使用 – 抽象类中不仅仅有抽象函数，也可以有普通的成员函数和成员变量 – 但如果一个类中有抽象函数，那么这个类必须定义为抽象类 – 如果一个类继承了父类的几个抽象函数，但没有全部实现（如BoardGame类），那么这个 14 类也必须定义为抽象类 类的静态变量与静态函数 静态变量的概念 – 静态变量，又称为类变量，是与对象的成员变量相对的一种变量 – 静态变量不属于具体的对象，系统只为每个类分配一套类变量，而不管这个类产生了多 少实例对象 – 静态变量用“static”关键字定义 – ，所有的对象共享一套静态变量 静态变量的使用 – 例题：TestClass类： class TestClass { public static int testStatic; } – 有两种方法访问静态变量testStatic：通过对象访问或用类直接访问： TestClass aTest1 = new TestClass(); TestClass aTest2 = new TestClass(); aTest1.testStatic = 12; aTest2.testStatic += 5; TestClass.testStatic += 7; 静态函数的概念 – 实例函数：只能通过对象调用，每个对象都保存着实例函数的指针 – 实例函数有一个“this”指针，它指向对象本身，通过它可以访问到对象的实例变量 – 静态函数：通过类直接调用的成员函数 – 静态函数没有“this”指针，因此不能访问实例变量，只能访问静态变量 静态函数的应用 – 最常见的应用是在程序的入口处 – Java程序从类的main成员函数开始执行 – 但开始执行时，还没有建立任何对象，如何调用main函数呢？ – 办法就是把main函数定义为静态函数，这样无需建立对象就可以调用： class TestClass { public static void main(String [] args) { TestClass aTest = new TestClass(); } } 字符串的使用例题 – 例：将输入的字符串颠倒。 public class StringsDemo { public static void main(String[] args) { String palindrome = \"僧游云隐寺\"; int len = palindrome.length(); StringBuffer dest = new StringBuffer(len); for (int i = (len - 1); i >= 0; i--) { dest.append(palindrome.charAt(i)); } System.out.println(dest.toString()); } } String对象的其它产生方法 // 生成一个空的字符串 String myStr = new String(); 15 // 复制String对象的内容 String oldStr = \"东岳泰山\"; String myStr1 = new String(oldStr); //复制StringBuffer对象的内容 StringBuffer oldStr2 = new StringBuffer(\"西岳华山\"); String myStr2 = new String(oldStr2); //复制字符数组的内容 char[] oldStr3 = {'南', '岳', '衡', '山'}; String myStr3 = new String(oldStr3); StringBuffer对象的产生 – 只能用new关键字产生，有3种构造方法： // 生成一个空的字符串，这个字符串的初始容量为16个字符，但以后可以扩展 StringBuffer myStrBuf1 = new StringBuffer(); // 生成一个空的字符串，这个字符串的初始容量由length指定。 // 在本例中，字符串的初始容量为120个字符。 int length = 120; StringBuffer myStrBuf2 = new StringBuffer(length); // 复制String对象中的内容 String str = \"北岳恒山\"; StringBuffer myStrBuf3 = new StringBuffer(str); 字符串长度和字符串容量 – 如果StringBuffer对象要存放的字符数大于它的容量，StringBuffer对象会自动扩大字符串容量，以放下更多的字符 myStrBuf1.append(\"东岳泰山、西岳华山、南岳衡山、北岳恒山、中岳嵩山\"); System.out.println(myStrBuf1.capacity()); – 程序显示结果： 34 字符串的访问操作 – length()函数：获取字符串的长度 – 适用于String对象和StringBuffer对象 String myStr = \"僧游云隐寺\"; StringBuffer myStr2 = new StringBuffer(\"五岳归来不看山\"); int strlen1 = myStr.length(); int strlen2 = myStr2.length(); – 变量strlen1中保存myStr的长度，值为5 – 变量strlen2中保存myStr2的长度，值为7 字符串的访问操作 – capacity函数：得到字符串容量 – 仅适用于StringBuffer对象 – charAt()函数：获得字符串中的某个字符 – 适用于String对象和StringBuffer对象 char myChar1, myChar2; String myStr = \"僧游云隐寺\"; 16 StringBuffer myStr2 = new StringBuffer(\"五岳归来不看山\"); myChar1 = myStr.charAt(0); myChar2 = myStr2.charAt(6); – 将字符串转化为数字： – valueOf函数： static Integer Integer.valueOf(String str); static Double Double.valueOf(String str); – valueOf函数返回的是Integer或Double型对象，还需转换成整数或浮点数： int Integer.intValue(); double Double.doubleValue(); 数值类的用途 – 将字符串转化为数值的例题： String str1 = \"3532\"; String str2 = \"187.863\"; Integer strval1; Double strval2; strval1 = Integer.valueOf(str1); strval2 = Double.valueOf(str2); int i = strval1.intValue(); double d = strval2.doubleValue(); System.out.println(\"i=\" + i + \"; d=\" + d + \";\"); 数值类的用途 – 这种方法需要转换两次，使用比较繁琐，另外一种方法只需要一次转换： static int Integer.parseInt(String str); static double Double.parseDouble(String str); – 这两个函数都是静态函数，因此不需要建立Integer或Double对象，可以直接使用 几种特殊的浮点数 – Java中的浮点数可以包括“非数”，“正无穷大”，“负无穷大” 。例如下面的代码： System.out.println(0.0/0.0); System.out.println(1.0/0.0); System.out.println(-1.0/0.0); 几种特殊的浮点数 – Double类提供了两个静态函数，来判断一个浮点数是不是这三种特殊数值： static boolean Double.isNaN(double v); static boolean Double.isInfinite(double v); – 由此可以及时发现错误的计算数据 数组类 数组的定义与特点 – 数组：可以容纳很多同类型的数据的结构 – 数组中存放的每个数据称为数组的一个元素，元素的数量称为数组的长度 – 在Java语言中，数组的长度是在数组创立时就固定了的，以后不能更改 – 但与C++等语言不同，Java的数组长度是在运行期定下来的，而不是在设计期给定长度。因此灵活性更强一些 数组的定义与初始化 – 与普通变量一样，数组也是由定义、初始化两部分组成的 – 数组变量的定义与普通变量一样，只是在变量类型的后面加上“[]”以表示数组： int[] array1; 17 double[] array2; StringBuffer[] array3; BoardGame[] array4; 数组的定义与初始化 – 数组也是用new关键字来初始化的，初始化时必须给出数组的长度，如下所示： int len = 8; array1 = new int[10]; array2 = new double[len-1]; array3 = new StringBuffer[len*2]; array4 = new BoardGame[15]; – 虽然也是固定长度数组，但可以在运行时用变量来指定数组长度 快速初始化数组的方法 – Java提供了一种简便的方法，可以将数组的定义、初始化和赋初值合为一体： int[] myData1 = {0, 1, 3, 6, 8, 12, 634, 21564, 845646}; String[] myStr1 = { \"明月出天山\苍茫云海间\ \"长风几万里\吹度玉门关\ \"汉下白登道\胡窥青海湾\ \"由来征战地\不见有人还\ \"戍客望边色\思归多苦颜\ \"高楼当此夜\叹息未应闲\ 数组的复制 – 数组变量也属于引用变量，因此赋值语句只能复制指针，而不能复制整个数组： String[] myStr2; myStr2 = myStr1; – 为了复制数组，需要使用System.arraycopy函数，该函数的形式如下： public static void System.arraycopy(Object src, int srcIndex, Object dest, int destIndex, int length); 数组的复制例题 public class ArrayCopyDemo { public static void main(String[] args) { char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' }; char[] copyTo = new char[7]; System.arraycopy(copyFrom, 2, copyTo, 0, 7); System.out.println(new String(copyTo)); } } 多重数组 – 数组的元素也是数组，可表示数据表格： int[][] MagicSquare = { {8, 1, 6,}, {3, 5, 7,}, {4, 9, 2,}, }; – 多重数组中的元素用[][]的形式访问，如： System.out.println(MagicSquare[1][1]); 集合类 集合类的功能 – 如果要求长度可变，就不能使用数组，而应当使用集合类。这里简单介绍集合中的向量 18 类，它在功能上最接近于数组 – Vector类的使用例题： public class VectorDemo { public static void main(String[] args) { Vector strs = new Vector(); for (int i=0; i<5; i++) strs.addElement(Integer.toString(i)); for (int i=0; i Object 类 Object类的作用 – 在Java中，所有的类，不管有没有定义其父类，都以Object类作为直接或间接的父类 – 也就是说，所有的类都继承自Object类 – Object类定义了基本的成员变量和成员函数 对象间的比较 将对象转换成字符串 线程的等待与通知 返回对象所属的类 Object类的成员函数 – clone：将对象复制一份，并返回复制后的对象的指针。 – equals/hashcode：比较两个对象是否相等。 – finalize：当对象被回收时调用的，仅用于混合语言编程时，回收动态分配内存用。 – toString：将对象转换成恰当的字符串。 Object类的成员函数 – getClass：获得当前对象所属的类，返回的是Class对象，可以用obj.getClass().getName()来获得类名 – notify：唤醒一个处于等待状态的线程 – notifyAll：唤醒所有处于等待状态的线程 – wait：让当前线程等待，直到其它线程通过notify或notifyAll函数唤醒为止 三、课堂练习： 1、执行插入和删除数据的SQL语句 import java.sql.*; public class ExecuteSQL { public static void main(String args[]) throws Exception { //MySQL Class.forName(\"com.mysql.jdbc.Driver\"); //指定MySQL JDBC驱动程序 String url=\"jdbc:mysql://localhost/student?user=root&password=\"; Connection conn = DriverManager.getConnection(url);//连接url指定数据库 String sql=\"INSERT INTO stuinfo(stu_id,stu_name,sex,province) VALUES('98111042','李强','男','广西')\"; Statement stmt = conn.createStatement(); System.out.println(\"INSERT \"+stmt.executeUpdate(sql)); //执行INSERT语句插入一行数据 19 sql=\"DELETE FROM stuinfo WHERE(stu_id='98111042')\"; System.out.println(\"DELETE \"+stmt.executeUpdate(sql)); //执行DELETE语句删除一行数据 stmt.close(); conn.close(); //关闭数据库连接 }} 通过这次整理，我对上学期所学的JAVA语言程序设计有一个更深刻的了解，将所学的知识应用于实践。总之，通过本次的课程设计，使我平时学到的理论知识得到了很好地升华，理论与实际得到一次很好的结合，为我今后参加工作打下了坚实的基础，使我受益匪浅。 20 因篇幅问题不能全部显示，请点此查看更多更全内容