导图社区 Java
- 748
- 18
- 4
- 举报
Java
Java知识思维导图，包括：1、Java环境及配置；2、语法、数据类型及表达式；3、结构化程序设计；4、数组与字符串；5、类和对象。
提示: 本内容由社区用户上传并分享。平台不对内容的真实性、合法性、知识产权归属及是否侵害第三方权利进行事前审核或保证。本内容可能包含受版权保护的图片、字体或其他第三方素材，使用前请自行确认授权范围。
- 类和对象
- 数组与字…
- 结构化程…
- 语法、数…
- 相似推荐
- 大纲
Java
计算机语言：机器语言、汇编语言、高级语言 Java语言的特点：跨平台特性、面向对象、解释型、安全性、简单易用
1、Java环境及配置
什么是JDK Sun公司将java的开发工具和运行环境所涉及到的应用程序和相关文件放在一起，称之为JDK（java development kit） JDK版本 （1）J2EE（Java 2 Platform Enterprise Edition） （2）J2SE（Java 2 Platform Standard Edition） （3）J2ME（Java 2 Platform Micro Edition） 下载地址：http://www.oracle.com/technetwork/java/javase/downloads/index.html Java虚拟机（JVM）： JAVA程序运行环境，安装JDK同时会安装JVM 配置环境变量 1、增加JAVA_HOME  2、增加classpath  .;%JAVA_HOME%lib;%JAVA_HOME%lib\tools.jar 3、修改PATH： 增加“;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin” 第一个JAVA程序 public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World"); } } 程序注解： 1、程序名称必须跟代码中public类名称一致，后缀名是.java,一个程序中 只能有一个public类存在。 2、面向对象语言必须以类（class）形式存在，类是java程序最小单位 3、main函数是程序入口 4、Java源码大小写敏感 注释：单行注释// 多行注释/* */ /** */ JAVA运行过程  命令编译和运行 命令编译： 首先启动命令行窗口，切换到当前程序目录 Javac –d destdir srcFile javac –d . HelloWord.java 命令运行： java 类名（程序中声明的类名，大小写需要严格一致） java HelloWorld JDK目录说明 Bin：存放JDK各种工具命令，常用的javac、java等命令 db目录：JDK6-7附带的一个轻量级的数据库，名字叫做Derby。 Jre：运行java程序所必须的环境，包括前面提到的java虚拟机（jvm） Lib：lib目录中包含了Java开发环境所需的库文件。 include目录中包含了一些支持Java native方法的C\C++头文件 Sample：JDK提供的一些简单示例代码。 Src.zip:JAVA所有核心类库的源代码
2、语法、数据类型及表达式
1、标识符
标识符命名规则 定义:Java对各种变量,方法和类等要素命名时使用的字符序列称为标识符 规则: 标识符应以字母,下划线,美元符号开头 标识符应以字母,下划线,美元符号或数字组成 标识符对大小写敏感,长度无限止 标识符不能与关键字冲突 合法的标识符： Indentifier、username、user_name、_userName、$username 非法的标识符： class、98.3、Hello World 命名约定： 类名, 接口名：每个单词的首字母应该大写。 class MyFirstClass interface Weapon 字段、方法以及对象：第一个单词首字母应小写，其他单词首字母大写。 boolean isWoman void setName(String name) 常量：全部用大写字母表示。 public final int GREEN public final int HEAD_ COUNT Java包（Package）：它们全都字母小写。 package java.awt.event 关键字列表 
2、数据类型
 
3、常量
常量：就是持续不变的值 常量类型： 整型常量： 十进制（12）十六进制（0x12），八进制（012） 长整型常量： 13L 浮点数常量： (1) 单精度浮点数 5.1f，.4f ，2e3f ，0f (2) 双精度浮点数 5.1，.4，2e-3 布尔常量: true和false 字符常量: ‘a’ ，¡?’，'\u0027' ‘\r‘表示接受键盘输入，相当于按下了回车键； ‘\n‘是换行； ‘\t‘是制表符，相当于table键； ‘\b‘是退格键，相当于Back Space； ‘\‘‘是单引号，而‘\“‘是双引号； ‘\\‘是一个斜杠“\”。 字符串常量: “Hello World“，”123”， "Welcome \nXXX“ null常量: null常量只有一个值，用null表示，表示对象的引用为空 常量定义 定义格式： final 数据类型 常量名称[=值] public class Constant { public static void main(String[] args) { final int MYINT=10; MYINT=20;//编译器会报错 System.out.println("the number is " + MYINT); } }
4、变量
变量概念 变量就是，用来存储各种类型的数据。先声明，再使用系统为程序分配的一块内存单元 变量的元素 变量名，变量值，变量的作用范围 定义格式： 数据类型 变量名称[=值] int x=0,y; y=x+3； x和y就是变量 见例子MyVar.java // 下面的程序声明了两个变量，一个是整型，一个是字符型 public class MyVar { public static void main(String args[]) { // int num = 3 ; // 声明一整型变量num，赋值为3 // char ch = 'z'; // 声明一字符变量ch，赋值为z char ch = 'z'; byte by2 = 10; short s2 = 35; int i2 = -32; long l2 = 34555L; //当成Long型处理，赋值后部必须加“L” char ch2 = 'A'; float f2 = 897.89F; //java默认浮点型是Double，如果想当成Float处理，赋值后部必须加“F” double d2 = 34.345; boolean b2 = false; String myString = "abc"; System.out.println("char ch = " + ch); System.out.println("短整型变量by2 = " + by2); System.out.println("短整型变量s2 = " + s2); System.out.println("整型变量i2 = " + i2); System.out.println("长整型变量l2 = " + l2); System.out.println("字符变量ch2 = " + ch2); System.out.println("浮点数类型f2 = " + f2); System.out.println("双精度型变量d2 = " + d2); System.out.println("布尔型变量b2 = " + b2); System.out.println("myString = " + myString); myString = "efg"; System.out.println("myString = " + myString); //System.out.println(num+ "是整数！"); // 输出num的值 //System.out.println(ch + "是字符！"); // 输出ch的值 } }
5、数据类型转换
类型转换分为两种：自动类型转换(隐式转换)和强制类型转换(显式转换) 隐含类型转换发生在把一个子类型赋给一个超类型时。  见AutoConversion.java public class AutoConversion { public static void main(String[] args) { int a = 6; //int可以自动转换为float类型 float f = a; //下面将输出6.0 System.out.println(f); //定义一个byte类型的整数变量 byte b = 9; // 下面代码将出错，byte型不能自动类型转换为char型 //char c = b; // 下面是byte型变量可以自动类型转换为double型 double d = b; //下面将输出9.0 System.out.println(d); char ch='a'; a=ch; System.out.println("a="+a); } } 练习：写一个java程序 定义一个byte型的数据，将其转换成float型的数据，然后打印在显示器上； byte number=9; float myfloat=number; System.out.println("Myfloat="+myfloat); 定义一个short型的数据，将其转换成double型的数据，然后打印在显示器上。 short num=9; double mydouble=num; System.out.println("Mydouble="+mydouble); 强制转换：当数据类型需要进行转换，但是不能隐式自动转换时，可以进行强制 转换。但强制转换有数据丢失风险。 强制转换方法： （数据类型）value 例子：NarrowConversion.java public class NarrowConversion { public static void main(String[] args) { int iValue = 233; //强制把一个int类型的值转换为byte类型的值 byte bValue = (byte)iValue; //将输出-23 System.out.println(bValue); double dValue = 3.98; //强制把一个double类型的值转换为int int toI = (int)dValue; // 将输出3 System.out.println(toI); } }
6、运算符和表达式
算数运算符与表达式
Java中常用的算术运算符如下： + 加运算符 - 减运算符 * 乘运算符 / 除运算符 % 取模运算(除运算的余数) ++ 增量运算符 -- 减量运算符 例子： NumberOper.java public class NumberOper { public static void main(String args[]) { //变量初始化 int a = 30; int b = 20; int x =50,y=60,x1,y1; //定义结果变量 int r1,r2,r3,r4,r5,r6,r7,r8,r9; //计算结果 r1 = a + b; r2 = a-b; r3 = a * b; r4 = a / b; r5 = a % b; r6 = a ++; System.out.println("r6=a++ :" + r6); r7 = b--; r8 = ++ a; System.out.println("r8=a++ :" + r8); r9 = -- b; x1= ++x +6; //输出结果 System.out.println("a = " + a + " b = " + b); //a,b的值 System.out.println("a+b = " + r1); System.out.println("a-b = " + r2); System.out.println("a*b = " + r3); System.out.println("a/b = " + r4); System.out.println("a%b = " + r5); System.out.println("a++ =" + r6); System.out.println("b-- =" + r7); System.out.println("++a =" + r8); System.out.println("--b =" + r9); System.out.println("x1 = " + x1 + "++x = " + x); } }
关系运算符和表达式
关系运算符用于比较两个数据之间的大小关系，关系运算表达式返回布尔值，即“真”或“假”。Java中的常用关系运算符如下： = = 等于 ! = 不等于 > 大于 >= 大于等于 例子： RelationOper.java public class RelationOper { public static void main(String args[]) { //变量初始化 int a = 30; int b = 20; //定义结果变量 boolean r1,r2,r3,r4,r5,r6; //计算结果 r1 = a == b; r2 = a != b; r3 = a > b; r4 = a r5 = a >= b; r6 = a //输出结果 System.out.println("a = " + a + " b = " + b); System.out.println("a==b = " + r1); System.out.println("a!=b = " + r2); System.out.println("a>b = " + r3); System.out.println("a System.out.println("a>=b = " + r5); System.out.println("a } }
逻辑运算符和表达式
 其中简洁与和简洁或的执行结果分别与非简洁与和非简洁或的执行结果是一致的。 不同在于简洁与检测出符号左端的值为假时，不再判断符号右端的值，直接将运算结果置为假；而简洁或与非简洁或的不同在于简洁或检测出符号左端为真时，不再判断符号右端的值，直接将运算结果置为真。 例如： Boolean a = false; Boolean b = true; a && b检测到a为假，则无需判断b的值，直接将值置为假；而b || a时检测到b为真，则无需判断a的值，直接将值置为真。 例子： LogicOper.java public class LogicOper { public static void main(String args[]) { //变量初始化 boolean a = false; boolean b = true; //定义结果变量 boolean r1,r2,r3,r4,r5,r6; //计算结果 r1 = !a; r2 = a & b; r3 = a | b; r4 = a ^ b; r5 = a && b; r6 = a || b; //输出结果 System.out.println("a = " + a + " b = " + b); System.out.println("!a = " + r1); System.out.println("a&b = " + r2); System.out.println("a|b = " + r3); System.out.println("a^b = " + r4); System.out.println("a&&b = " + r5); System.out.println("a||b = " + r6); } }
赋值运算符和表达式
 赋值运算符分为简单运算符和复杂运算符。简单运算符指“=”，而复杂运算符是指算术运算符、逻辑运算符、位运算符中的双目运算符后面再加上“=” 例子： AssignOper.java // 在程序中赋值采用“=” public class AssignOper { public static void main(String args[]) { int num = 22; // 声明整数变量num，并赋值为22 System.out.println("第一次赋值后，num = "+num); // 输出num的值 num = num - 3; // 将变量num的值减3之后再赋给num变量 num *=2; System.out.println("改变之后的值，num = "+num); //输出后num的值 } }
其他运算符
三目运算符(?:)相当于条件判断，表达式x?y:z用于判断x是否为真，如果为真，表达式的值为y，否则表达式的值为z。 例如： int x = 5; int a = (x>3)?5:3; 则a的值为5。如果x = 2，则a的值为3。
运算符优先级

7、练习
1、 int i=5,j=5,p1,p2; p1=(i++)+(i++); p2=(++j)+(++j); 执行完上面三个语句后，i,j,p1,p2的取值各是多少？请自行编码完成。 p1=(5)+(6)=11,i=7 p2=(6)+(7)=13,j=7 操作数在++前面，先参与运算，再自增 操作数在++后面，先自增，再参与运算
3、结构化程序设计
顺序
顺序结构就是按照书写的顺序执行的语句构成的程序段，按照语句顺序一句一句的执行。 
选择
1、有一函数：  编写一程序，给定x值，输出y值。 [解答]： import java.io.*; public class Test_9 { public static void main(String[] args) throws NumberFormatException,IOException { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); System.out.println("请输入数字x的值:"); double x = Double.parseDouble(br.readLine()); double y = 0; if (x y = x; } else { if (x >= 1 && x y = 3 * x - 2; } else { y = 4 * x; } } System.out.println("y=" + y); } }
if else 的语法结构
1、基本结构
if( ){ } else{ }
2、省略else分支
if(boolean expression){ code block }
3、多层嵌套
if(boolean expression1){ code1; code2; code3; } else if(boolean expression2){ code block2} else{ code block3 }
switch语句
switch语句的基本格式为： switch(表达式1) //表达式1必须是整型或字符型、常量 { case 表达式2: 语句或块2; break; case表达式3: 语句或块3; break; case 表达式n: 语句或块n; break; default: 语句或块; break; }
example
TestIfElse
例子： TestIfElse 变量age保存了年龄值，年龄大于60岁，则输出老年人；年龄大于40小于等于 60则输出为中年人；年龄大于18小于等于40则输出青年人；其它年龄输出未成年人 import java.util.Scanner; public class TestIfElse { public static void main(String[] args) { Scanner scanner = new Scanner(System.in);// 创建输入流扫描器 System.out.println("请输入你的年龄：");// 提示用户输入 int age = Integer.parseInt(scanner.nextLine());// 获取用户输入的一行文本 int age = 35; if (age > 60) { System.out.println("老年人"); } else if (age > 40 && age { System.out.println("中年人"); } else if (age > 18 && age { System.out.println("青年人"); } else { System.out.println("未成年"); } } }
TestSwitch
例子： TestSwitch.java 变量Score保存一字符，char 如果字符为A，则输出优秀； 字符为B输出良好； 如果为C输出及格； 如果为D输出不及格； 如果为其它字符则输出成绩输入错误。 public class TestSwitch { public static void main(String[] args) { //声明变量score，并为其赋值为'C' char score = 'T'; //执行swicth分支语句 switch (score) { case 'A': System.out.println("优秀."); break; case 'B': System.out.println("良好."); break; case 'C': System.out.println("及格"); break; case 'D': System.out.println("不及格"); break; default: System.out.println("成绩输入错误"); } } }
循环
For
for(初始化（初始表达式）;循环条件（布尔表达式）;修正语句(步进)) { 循环体语句块 } 说明： 无论初始表达式，布尔表达式，还是步进，都可以置空。 初始表达式在整个循环过程中只执行一次。 for (int i=1;i System.out.println(“i=“ + i); } …… 第一步 初始化 i=1 第二步循环条件：判断i 真：执行循环体语句，到第三步修正语句，再循环条件…. 假：跳出循环 例子： 1、把100~200之间的不能被3整除的数输出 。TestForThree.java public class TestForThree { public static void main(String args[]) { int i; for (i=100;i { if (i%3!=0) { System.out.println(i); } } } } 2、用for循环完成1+2+3+4+…..+99 + 100的计算。TestFor.java public class TestFor { public static void main(String[] args) { //循环的初始化条件,循环条件，循环迭代语句都在下面一行 //int count = 0; int sum = 0; for (int count = 1 ; count { sum = sum + count; //System.out.println(count); } System.out.println("循环结束,计算结果为：\n" + sum); } }
While
While循环： 格式： while(布尔表达式){ 循环体语句块 } int i=1； while（i { System.out.println(“i = “ + i); i++; } 先判断，再循环，再判断，再循环 例子： TestWhileThree.java and TestWhile.java 1、把100~200之间的不能被3整除的数输出 public class TestWhileThree { public static void main(String args[]){ int i=100; while (i { if (i%3!=0) { System.out.println(i); } i++; } } } 2、用循环完成1+2+3+4+…..+99 + 100的计算。 public class TestWhile { public static void main(String[] args) { //循环的初始化条件,循环条件，循环迭代语句都在下面一行 int sum = 0,i=1; while (i { sum = sum + i; i++; System.out.println(sum); } System.out.println("循环结束,计算结果为：\n" + sum); } }
do...while
do while循环 do { 语句或语句块; }while(布尔测试)； 注意：while表达式的括号后要加“;” 例子： TestDoWhileThree.java and TestDoWhile.java 1、把100~200之间的不能被3整除的数输出 public class TestDoWhileThree { public static void main(String args[]) {int i=100; do { if (i%3!=0) { System.out.println(i); } i++; }while (i } } 2、用do while循环完成1+2+3+4+…..+99 + 100的计算。 public class TestDoWhile { public static void main(String[] args) { //循环的初始化条件,循环条件，循环迭代语句都在下面一行 //int count = 0; int sum = 0,i=1; do { sum = sum + i; i++; System.out.println(sum); }while(i System.out.println("循环结束,计算结果为：\n" + sum); } }
嵌套结构
以上选择或循环结构都是可以嵌套使用： public class TestNestedLoop { public static void main(String[] args) { //外层循环 for (int i = 1; i { //内层循环 for (j = 1; j { System.out.println("i*j=" +(i* j)); } } } }
控制语句
break与continue语句 break：终止循环体中的执行语句和switch语句，跳转到当前循环的下一条语句 continue：只能用于while、do while、for语句中，终止当前这次循环，执行下一次循环 例子：TestBreakContinue.java public class TestBreakContinue { public static void main(String[] args) { //一个简单的for循环 for (int i = 0; i { //System.out.println("i的值是" + i); if (i == 2) { System.out.println("进入i=2"); //break; continue; } System.out.println("i=" + i); } } }
练习
练习1：请输入两个整数a,b，比较a+b和a*b哪个大,输出判断结果。 练习2：有一张厚度为0.1毫米的纸，假设它足够大，重复将其对折，问对折多少次之后，其厚度可以抵达（再对折一次就超过）珠穆朗玛峰的高度？ 练习3:用1元纸币兑换1分，2分和5分的硬币，要求兑换总数为50枚，问可以有多少种组合，每种组合对应1分，2分，5分分别是多少？ 练习:4：编写程序，一个变量保存分数 如果该值大于等于85，系统提示“H”； 如果该值小于85且大于等于60，系统提示“M”； 如果该值小于60，系统提示“L” （用switch case）实现 如果系统提示结果为H，打印“成绩优秀”； 如果系统提示结果为M，打印“成绩良好”； 如果系统提示结果为L，打印“成绩不及格”； 练习5：打印99乘法表。（两种样式）
4、数组与字符串
数组
数组时编程语言中最常见的一种数据结构，用于存储多个数据，一个数组可以 存储多个同一类型的数据，不能存储多种数据类型的数据。 使用数组步骤： 声明数组：数据类型[] 数组名 分配内存：数组名= new 数据类型[个数] int[] score; score = new int[3]; 
声明数组
一维数组：数据类型[ ] 数组名
int [] a; int [][] arr;
二维数组：数组元素的类型[ ][ ] 数组的名字;
创建数组
数组名字 = new 数组元素的类型[数组元素的个数] ; 例： a = new int[10]; arr=new int[3][]; arr[0]=new int[4]; arr[1]=new int[4]; arr[2]=new int[4];
数组的初值
数组的每一个元素会有缺省值： 整型 0、 boolean: false 引用对象类型：null
数组赋值
分布式赋值
int a[]; a=new int [3]; a[0]=1; a[1]=2; a[2]=3;
在创建数组空间的时候， 同事将初值给出来
int a[] = {1,2,3} int a[]=new int [ ] {1,2,3}
使用数组元素
通过数组下标引用数组：数组名[下标] 下标是一个整型常量或整型表达式。一维数组元素的下标从0开始，如果数组长度为n，则元素的最大下标为n-1。 例：int a[10] 定义一个10元素整型数组a，数组元素分别是 a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7], a[8],a[9] 数组可以通过下标访问自己的元素： int a[ ]=new int[10]; for(int i=0;i { a[i]=i; System.out.print(a[i]+""); }
OneCharArray.java
例子：OneCharArray.java public class OneCharArray { public static void main(String[] args) { char[] s; int[] it; s = new char[26]; it= new int[26]; for ( int i= 0; i s[ i] = (char) ('A'+ i); it[i] = 'A'+ i; System.out.print(s[i]+" "); System.out.println(it[i]); } } } 
自己从键盘上输入一个数组
import java.io.*; public class TestInputArr{ public static void main(String args[]) throws IOException{ int sum=0; BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int [] temp; temp = new int[10]; for(int i=0;i System.out.println("please input the "+(i+1)+"\'s number:"); temp[i]=Integer.parseInt(br.readLine()); sum+=temp[i]; } System.out.println("The Sum of temp[i]="+sum); } } 
二维数组
在Java中，多维数组（multidimensional arrays）是由若干行和若干列组成数组。在人们工作生活与学习中，要使用二维表格、矩阵、行列式等，都可以表示成多维数组。例如： int D[ ][ ] = new int[3][4]; 该语句声明并创建了一个3行4列的数组D。这个数组在逻辑上可以表示成一个int类型的矩阵。  也就是说，这个数组在逻辑上可以表示为： D[0][0] D[0][1] D[0][2] D[0][3] D[1][0] D[1][1] D[1][2] D[1][3] D[2][0] D[2][1] D[2][2] D[2][3] 声明定义： 数据类型 数组名[]= new 数据类型[行数][列数] 数据类型 数组名[]={{第0行的值},{第一行的值},{第二行的值},…..} int intArr[][] ={{1,2,3},{2,3,4}} intArr[1][2]=5; intArr[0][2]=32; intArr[][] ={{1,2,32},{2,3,5}} 引用：intArr[0][0],intArr[0][1]….
TestTwoArr.java
// 二维数组的使用说明，这里采用静态赋值的方式 public class TestTwoArr { public static void main(String args[]){ int i,j,sum=0; int num[][]={{60,78,85,90},{78,88,98,100}; // 声明数组并设置初值 for(i=0;i { System.out.print("第 "+(i+1)+" 个人的成绩为："); for(j=0;j System.out.print(num[i][j]+" "); sum+=num[i][j]; } System.out.println(); } System.out.println("\n总成绩是 "+sum+" 分！"); } } 
TestTwoDimension.java
public class TestTwoDimension{ public static void main(String[] args) { //定义一个二维数组 int[][] a; //把a当成一维数组进行初始化，初始化a是一个长度为3的数组 //a数组的数组元素又是引用类型 a = new int[3][]; //把a数组当成一维数组，遍历a数组的每个数组元素 for (int i = 0; i { System.out.println(a[i]); } //初始化a数组的第一个元素 a[0] = new int[2]; //访问a数组的第一个元素所指数组的第二个元素 a[0][1] = 6; //a数组的第一个元素是一个一维数组，遍历这个一维数组 for (int i = 0 ; i { System.out.println(a[0][i]); } } } 
main方法说明
在Java应用程序中必须要有public static void main(String args[])主方法。Main()方法中的参数是一个字符串数组args[]，这个数组的元素args[0]，args[1]，…，args[n]的值都是字符串。args是命令行参数，其功能是接收运行程序时通过命令行输入的参数。其一般形式为： java 类文件名 字符串1 字符串2 … 字符串n 其中，类文件名和各字符串间用空格分隔。 例子： TestMain.java public class TestMain { /* public：表示公共方法 static：表示此方法为一静态方法，可以由类名直接调用 void：表示此方法无返回值 main：系统定义的方法名称 String args[]：接收运行时参数 */ public static void main(String[] args) { // 取得输入参数的长度 int j = args.length ; if(j!=2) { System.out.println("输入参数个数有错误！") ; // 退出程序 System.exit(1) ; } for (int i=0;i { System.out.println(args[i]) ; } } } 
练习
练习1:一个数组保存了五位整数，找出其中最大值和最小值。 public class FindMaxMin { public static void main(String[] args) { int[] arr={3,5,2,6,4}; int max,min; max=min=arr[0]; for(int i=1;i { if(max if(min>arr[i]) min=arr[i]; } System.out.println("Maximum value : " + max); System.out.println("Minimum value : " + min); } } 练习2：例 用冒泡法对10个整数排序（从小到大） 排序过程：从小到大排序 （1）比较第一个数与第二个数，若为a[0]>a[1]，则交换；然 后比较第二个数与第三个数；依次类推，直至第n-1个数和第 n个数比较为止——第一趟冒泡排序，结果最大的数被安置在 最后一个元素位置上。在交换过程中，需要使用过渡的临时变量： t=a[j]; a[j]=a[j+1]; a[j+1]=t; （2）对前n-1个数进行第二趟冒泡排序，结果使次大的数被安置在 第n-1个元素位置 （3）重复上述过程，共经过n-1趟冒泡排序后，排序结束 public class SortBubble{ public static void main(String[] args) { int[] a = {2,1,9,4,6,8,11,5,3,10}; int t,i,j; for(i=0;i for(j=0;j if(a[j]>a[j+1]){ t=a[j]; a[j]=a[j+1]; a[j+1]=t; } } } for(i=0;i System.out.println("a[" + i + "]=" + a[i]); } } }
String
API 文档的位置： java.lang.object 声明字符串变量： String str； 创建字符串： str = new String（”hello world！”); 声明和创建同时进行： String str = new String（”hello world！”); 或者 String str = “hello world！”；
获取字符串长度
例子：TestStringLength.java public class TestStringLength { public static void main(String[] args){ int n; String myStr = "hello"; n = myStr.length(); System.out.println("mystr's length= "+n); } } 
比较字符串
判断两个字符串中的字符是否相等。 1、equals方法的声明格式 public boolean equals(Object obj) 其比较规则为：当参数obj引用的对象与当前对象为同一个对象时，就返回true,否则返回false. equalsIgnoreCase
startsWith
public boolean startsWith(String s) 判断当前字符串对象的前缀是否是参数指定的字符串 s，如 String tom= "220302620629021",jerry= "21079670924022"; tom．startsWith("220")的值是 true； jerry．startsWith("220")的值是 false．
endsWith
可以使用 public boolean endsWith(String s) 方法，判断一个字符串的后缀是否 是字 符串 s，如 String tom= "220302620629021", jerry= "21079670924022"; tom.endsWith("021")的值是 true jerry.endsWith("021")的值是 false
字符串区域对比
boolean regionMatches（boolean ignoreCase，int toffset，String other，int ooffset，int len）； regionMatches（int toffset，String other，int ooffset，int len）； 上述两个方法用来比较两个字符串中指定区域的子串。 入口参数中: 用toffset和ooffset分别指出当前字符串中的子串起始位置和要与之比较的字符串中的子串起始地址；len 指出比较长度。 前一种方法可区分大写字母和小写字母，如果在 boolean ignoreCase处写 true，表示将不区分大小写，写false则表示将区分大小写。 而后一个方法认为大小写字母有区别。由此可见，实际上前一个方法隐含了后一个方法的功能。 比如: String s1= “tsinghua” String s2=“it is TsingHua”； s1.regionMatches（0，s2，6，7）; 最后一个语句表示将s1字符串从第0个字符“t”开始和s2字符串的第6个字符“T”开始逐个比较， 共比较7个字符，由于区分大小写，所以结果为false。 但如果最后一个语句改为： s1.regionMatches（true，0，s2，6，7）； 则结果为true，因为入口参数中true表示忽略大小写区别。
字符串比较
字符串比较：compareTo，compareToIgoreCase 方法 符串对象可以使用 String 类中的 public int compareTo string s方法，按字典序与参数 s 指定的字符串比较大小． 如果当前字符串与 s 相同，该方法返回值 0 如果当前字符串对象大于s，该方法返回正值，如果小于 s，该方法返回负值。
字符串检索
public int indexOf (String s) 字符串调用该方法从当前字符串的头开始检索字符串 s，并返回首次出现 s 的位置．如果没有检索到字符串 s，该方法返回的值是-1． . public int lastIndexOf (String s) 字符串调用该方法从当前字符串的头开始检索字符串 s，并返回最后出现 s 的位置．如果没有检索到字符串 s，该方法返回的值是-1．
字符串截取
public String substring(int startpoint) 字符串对象调用该方法获得一个当前字符串的子串，该子串是从当前字符串的startpoint 处截取到最后所得到的字符串． public String substring(int start ，int end) 字符串对象调用该方法获得一个当前字符串的子串，该子串是从当前字符串的 start 处截取到 end 处所得到的字符串，但不包括 end 处所对应的字符．
字符串替换
public String replace(char oldChar,char newChar) 字符串对象 s 调用该方法可以获得一个串对象，这个串对象是用参数newChar指定的字符串替换s中由oldChar指定的所有字符而得到的字符串。 public String replaceAll(String old ，String new) 字符串对象 s 调用该方法可以获得一个串对象，这个串对象是通过用参数new 指定的字符串替换 s 中由 old 指定的所有字符串而得到的字符串。 Public String trim() 一个字符串 s 通过调用方法 trim()得到一个字符串对象，该字符串对象是 s 去掉前后空格后的字符串。
类型转换
字符串转成整型
字符串转换为整型： public static int parseInt(String s) Byte，Short，Long 等类型相应的类方法 public static byte parseByte(String s) public static short parseShort(String s) public static long parseLong(String s)
其它类型转换为字符串
public String valueOf (byte) public String valueOf (int) public String valueOf (long) public String valueOf( float)
字符和字符串
当处理字符串时，Character 类中的一些类方法是很有用的，这些方法可以用来进行字符分类，比如判断一个字符是否是数字字符或改变一个字符大小写等。 public static boolean isDigit(char ch) 如果 ch 是数字字符方法返回true，否则返回false。 public static boolean isLetter(char ch) 如果ch 是字母方法返回true，否则返回false。 public static boolean isLetterOrDigit(char ch) 如果 ch 是数字字符或字母方法返回true，否则返回false。 public static boolean isLowerCase(char ch) 如果 ch 是小写字母方法返回true，否则返回false。 public static boolean isUpperCase(char ch如果ch是大写字母方法返回true，否则返回 false。public static char toLowerCase(char ch)返回 ch 的小写形式。 public static char toUpperCase(char ch)返回 ch 的大写形式。 public static boolean isSpaceChar(char ch) 如果 ch 是空格返回true。
课堂练习：1、TestStringAll.java 2、TestFunction.java
例子：TestStringAll.java public class TestStringAll{ public static void main(String[] args) { boolean flag =false; int strLength ; int x; String str1 = new String("hello"); String str2 = new String("hello"); String str3 = new String("Hello"); String str4 = "Say hello or good"; String str5= "1234"; System.out.println("str1 length= " + str1.length()); System.out.println("str1 StartWith he: " + str1.startsWith("he")); System.out.println("str1 endsWithlo: " + str1.endsWith("lo")); System.out.println("regonMatches:" + str4.regionMatches(4,str1,0,3)); flag = str1.equals(str2); System.out.println("flag = " + flag); if(str1==str2) { System.out.println("str1==str2"); } if(str1.equalsIgnoreCase(str3)) { System.out.println("str1==str3"); } System.out.println("str1 compare str4: " + str1.compareTo(str4)); System.out.println(" str4 IndexOf he: " + str4.indexOf("he")); System.out.println(" str4 LastIndexOf he: " + str4.lastIndexOf('o')); System.out.println(" str4 substring from 4: " + str4.substring(4)); System.out.println(" str1 replace from 'e' to 'f': " + str1.replace('e','f')); System.out.println(" str4 replace from 'or' to 'and': " + str4.replaceAll("or","and")); x = 100 + Integer.parseInt(str5); System.out.println("string to int: " + x); } }  例子2:TestFunction.java import java.util.*; public class TestFunction { public static void main(String[] args) { boolean f1,f2,f3,f4; char c1 = '2'; char c2='a'; char c3='!'; char c4='B'; char c5,c6; char c7=' '; f1 =Character.isDigit(c1); //flag =Character.isDigit(str5);只能是字符 System.out.println("c1是数字吗？ " + f1); f1=Character.isLetter(c1); System.out.println("c1是字母吗？ " + f1); f2=Character.isLetter(c2); System.out.println("c2是字母吗？ " + f2); f2=Character.isDigit(c2); System.out.println("c2是数字吗？ " + f2); f3=Character.isLetterOrDigit(c1); System.out.println("c1是数字或者字母吗？ " + f3); f3=Character.isLetterOrDigit(c3); System.out.println("c3是数字或者字母吗？ " + f3); f4=Character.isLowerCase(c4); System.out.println("c4是小写字母吗？ " + f4); f4=Character.isLowerCase(c2); System.out.println("c2是小写字母吗？ " + f4); f4=Character.isUpperCase(c4); System.out.println("c4是大写字母吗？ " + f4); f4=Character.isUpperCase(c2); System.out.println("c2是大写字母吗？ " + f4); c5=Character.toLowerCase(c4); System.out.println("c4的小写形式是 " + c5); c6=Character.toUpperCase(c2); System.out.println("c2的大写形式是 " + c6); f4=Character.isSpaceChar(c7); System.out.println("c7是空格吗？ " + f4); } }
练习
1、编写一程序，查找某一字符串是否包含有 “abc”。 public class Test_1{ public static void main(String[] args) { String s = "yangen abc"; int a = s.indexOf("abc"); //a位找到abc的下标，找不到则返回-1 if (a != -1) { System.out.print("包含字符串abc"); } else { System.out.print("不包含字符串abc"); } } } 2、设一字符串中包含有大写字母的字符，也有下写字母的字符，编写一程序，将其中的大小写字母的字符分别输出。 public class Test_2 { public static void main(String[] args) { String s="sdfKJjKjjsjdfKKJkjkjSDFsdf"; String s1="",s2="",s3; for(int i=0;i s3="ABCDEFGHIJKLMNOPQRSTUVWXYZ"; if(s3.indexOf(s.charAt(i))!=-1){ s1=s1+s.charAt(i); }else{ s2=s2+s.charAt(i); } } System.out.println("大写字母 ："); System.out.println(s1); System.out.println("小写字母 ："); System.out.println(s2); } } 3、输出一字符串，统计其中有多少个单词。(单词之间用空格分隔)。 import java.util.*; public class Test_3{ public static void main(String[] args) { int i = 0; String s = "Hello world i love java"; StringTokenizer st = new StringTokenizer(s, " "); while (st.hasMoreTokens()) { i++; System.out.println(st.nextToken()); } System.out.print("单词个数 :" + i); } } 4、一个字符串“AcEfGHCecc123a”中的小写字母变成大写字母，并将大写字母变成小写字母输出到屏幕，并且统计出大写字母、小写字母的数量。 import java.util.*; public class ConvertChar { public static void main(String args[]) { int upperChar,lowChar; String s=new String("abcABC123"); System.out.println(s); char a[]=s.toCharArray(); for(int i=0;i { if(Character.isLowerCase(a[i])) { a[i]=Character.toUpperCase(a[i]); lowChar++; } else if(Character.isUpperCase(a[i])) { a[i]=Character.toLowerCase(a[i]); upperChar++; } } s=new String(a); System.out.println(s); } }
向量
向量：对象的集合。 其中，各元素可以不必同类型，元素可以增加和删除，不能直接加入原始数据类型
向量使用
首先必须在程序开始处加入： import java.util.Vector; //================== Vector v = new Vector(); String s = new String(“Hello”); v.add(s); v.add(“Goodbye”); System.out.println(v); System.out.println(v.size()); 结果： [Hello, Goodbye] 2 boolean success = v.remove(s);//v.remove(“Hello”) System.out.println(v); System.out.println(success); System.out.println(v.size()); [Goodbye] True 1
Vector方法
public boolean add(object o) public boolean remove(object o) public int size() public Enumeration element()
在向量中使用封装器
由于Java不把原始数î类型当作对象来处理，向量中就不允许存储原始数î类型的数î，为此，Java又引入如下新的类以封装原始数î类型： Integer Float Double Character Boolean 举例 Integer I = new Integer(211); int i = I.intValue(); System.out.println(i); 封装器类小结 Integer new Integer(int i) intValue() Float new Float(float f) floatValue() Double new Double(double d) doubleValue() Character new Character(char c) charValue() Boolean new Boolean(boolean b) booleanValue() String name = new String(“John Smith”); Integer age = new Integer(30); Double salary = new Double(8675.88); Vector record = new Vector(); record.add(name); record.add(age); record.add(salary); System.out.println(record);
遍历器Iterator
import java.util.Iterator 用途：遍历未知数量的对象 Vector v=null; v=new Vector(); v.add("Tom"); v.add("Smith"); v.add("Jack"); Iterator it=v.iterator(); while(it.hasNext()){ String name=(String)it.next(); System.out.println("name:"+name); } 当next不抛异常的时候，hasnext为true
枚举
Enumeration(枚举)类允许列举向量元素， 通过elements()方法得到Enumeration对象。 public boolean hasMoreElements() public Object nextElement() import java.util.*; Vector dogs = new Vector(); dogs.add(“Rambo”); dogs.add(“Feisy”); Enumeration names = dogs.elements(); System.out.println(names.hasMoreElements()); System.out.println(names. nextElement()); System.out.println(names.hasMoreElements()); System.out.println(names. nextElement()); System.out.println(names.hasMoreElements()); 显示结果 true Rambo true Feisy false public class ThreeStoogesExample{ public static void main(String args[]) { Vector stooges = new Vector(); stooges.add("Larry"); stooges.add("Curly"); stooges.add("Moe"); stooges.remove("Curly"); stooges.add("Shemp"); System.out.println("The " + stooges.size()+ "Stooges"); Vector actors = new Vector(); actors.add("Bob"); actors.add("Ted"); actors.add("Alice"); actors.add(stooges); System.out.println(actors.size()); System.out.println(actors); } } The 3Stooges 4 [Bob, Ted, Alice, [Larry, Moe, Shemp]]
5、类和对象

类和对象的定义
什么是类： 类是对现实生活中对象的抽象，是一种抽象的数据类型。  什么是对象： 对象是类的实例化。 
类和对象的创建
创建类：class { ……; }  创建对象： 
成员变量和成员方法
 返回值类型 函数名 （参数类型 形式参数1，参数类型 形式参数2，….） { 程序代码 return 返回值； ｝ 形式参数：在方法被调用时用于接收外部传入的数据的变量。 参数类型：就是该形式参数的数据类型。 返回值：方法在执行完毕后返还给调用它的程序的数据。 返回值类型：函数要返回的结果的数据类型，如果没有返回值用void关键字 实参：调用函数时实际传给函数形式参数的数据。 
对象的使用
 课堂练习： 1、请创建一个Person类，并测试Person的方法。 2、请创建一个Student类，并测试Student的方法。 其中，Student类里面，有name、age、telephonenum、studentID、address、score、grade的成员属性，有selectcourse（）、eat（）、sleep（）、exam（）四个成员方法。 并请测试Student的四个成员方法。
构造方法
构造方法的定义： 是类的一种特殊方法，java中每个类都有构造方法，它的功能是类的实例初始化状态。 构造方法格式： class 类名称{ 访问权限 类名称 （类型1 参数1，类型2 参数2，......）{ 程序语句； ..... // 构造方法没有返回值} } 在构造方法的方法声明中牢记以下几点： 1、构造方法的名称必须与类的名称一致。 2、构造方法的声明处不能有任何返回值类型的声明。 3、不能在构造方法中使用return返回一个值 如果在类中没有明确定义构造方法，构造实例的时候会自动调用默认构造方法。 如果定义了构造方法，则调用定义的构造方法来创建实例。 例子：TestConstruct2.java 
包package和import
计算机操作系统使用文件夹或者目录来存放相关或者同类的文档，在Java编程语言中，提供了一个包的概念来组织相关的类。包在物理上就是一个文件夹，逻辑上代表一个分类概念。 包就是指一组类。例如一个名叫Company的包，可以包含一组类，如Employee(雇员)、Manager(管理者)和Department(部门)等。声明包的基本格式如下： package 包名; 其中：Package为关键字，包名为标识符。 使用包时的注意事项如下： (1) Package语句要作为程序非注释语句的第一行语句。 (2) 包内的类名惟一。 (3) 引用包中的类时，使用import语句。import语句的基本格式为 import 包名.类名 其中import为关键字，包名和类名之间用圆点(.)隔开。 (4)通过import可以导入自己写的包，也可以导入JDK自带的包。JDK中的 java.lang.* 默认自动导入。 例子： PackageImport.java（导入自己开发的包） CheckLoginImport.java（导入JDK自带的包）
类和方法的设计
识别类的一个简单经验就是寻找问题分析中的名词 比如：在订单处理系统中有这样一些名词： 订单（order）、送货地址（address）、货款（payment）、帐户（account）……根据这些名词，我们就可以创建order、address、 payment、 account等类 确定类中的方法： 通过寻找和名词相关的动词来确定方法 比如：物品被添加进订单，订单被运送或取消 货款被支付……
访问控制修饰符
访问控制符是一组起到限定类、属性或方法被程序里的其他部分访问和调用的修饰符。 类修饰符：public、缺省 属性和方法修饰符：public、private、protected、缺省 public（公有） 类声明为public，则表明这个类可以被所有的其他类访问和引用，即其他类可以创建这个类的对象，并访问这个类内部的可见的成员变量、调用可见的方法 若成员变量声明为public，其他类的方法可以直接访问它，但这样破坏了封闭性 若方法声明为public，其他类可以直接调用这个方法，这样的方法往往作为操作类对象的接口 缺省 若没有设置访问控制符，则说明该类、属性或方法具有缺省访问控制权限。这样的类、属性和方法只能被同一个包中的类访问和引用，因此，我们又将其称为包访问性。 private 用private修饰的属性和方法只能被类自身访问和修改，而不能被任何其他类（包括子类）获取和引用。应该将不希望他人随意引用或修改的属性设置成private，以此将它们隐藏起来，从而实现面向对象的程序设计思想。 protected 用protected修饰的成员变量可以被三种类所引用： 该类自身 同一个包中的其他类 在其他包中的该类的子类 作用：允许存在其他包中该类的子类访问 
面向对象的三大特性
封装
封装性： 将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而 是通过该类提供的方法来实现信息的操作和访问。 封装作用： 1、隐藏类的实现细节。 2、让使用者只能通过事先定好的方法来访问数据，从而可以在该方法里加入控制逻辑，限制对属性的不合理访问。 3、便于修改，提高代码的可维护性。
继承
Java编程语言中允许用extends关键字从一个类扩展出一个新类，新类继承超类 的非私有 (public protected 缺省)成员变量和方法，并可以覆盖方法。 格式： class Subclass extends Superclass { } 例子：InheritClass.java
子类与父类的属性和方法
子类继承父类的所有内容，但父类中的private部分不能直接访问 子类中新增加的属性和方法是对父类的扩展 子类中定义的与父类同名的属性是对父类属性的隐藏，同名的方法是对父类方法的重载或覆盖
子类的构造函数
1、子类继承父类无参构造函数 2、若子类无构造函数，则它将继承父类的无参构造函数作为自己的构造函数；若子类定义了构造函数，则在创建新对象时，先执行父类的无参构造函数，再执行自己的构造函数 3、对于父类中含参构造函数，子类可以在自己的构造函数中使用super调用它。 例子：DCI.java   
类对象之间的类型转换
子类对象转换为父类对象时，可以用显式或隐式实现，即子类对象可以直接向父类对象赋值； 父类对象向子类对象赋值时，必须使用显式转换，即强制类型转换。 例子:TypeV.java  
类的成员覆盖
类成员覆盖是指在子类中新增加的成员变量或成员方法的名称与父类相同。 成员变量：在子类中，访问的是子类定义的成员变量，若要使用父类的成员，需要使用关键字super 作为前缀； 成员函数：若参数表完全一样，欲使用父类中的成员函数，也需要使用super 作为前缀。 例子:OverTest.java  
多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。 重载：对于相同的方法名，通过不同的参数得到不同的处理结果。 1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。 2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 例子： MultiplyState.java
类相关的几个关键字
this
this变量指向当前对象或实例。 str = "名字: " + name + "\nSalary: " + salary; 上例中的语句可以换成下面的语句。 str = "名字: " + this.name + "\nSalary: " + this.salary; 这两者是等同的，因为在Java编程语言中，系统自动将this关键字与当前对象的变量相关联。
extends
类声明中用关键字extends扩展了其超类之后，super用在扩展类中引用其超类 中的成员变量。 例子： SuperTest.java
static
static可以修饰类中的属性和方法。 静态属性在类定义时静态地分配空间。它属于类，不属于某个特定的对象，因此可以通过类进行访问。往往将属于类的公共属性说明成static。 用static修饰的方法属于整个类的方法，其特点为： 调用该方法时，前缀应该使用类名 该方法在内存中的代码段随着类定义分配和加载 由于该方法属于整个类，所以，它不能操纵和处理属于某个对象的成员变量，而只能处理static成员变量。
重载
重载：对于相同的方法名，通过不同的参数得到不同的处理结果。 例子： MyOverride.java
抽象类与修饰符 abstract
用abstract 修饰的类被称为抽象类。所谓抽象类就是没有具体实例对象的类。它的主要用途是用来描述概念性的抽象内容，这样可以提高开发效率，更好地统一用户接口。 abstract 修饰方法。表明该方法是一个抽象的方法，即没有函数体。必须在子类中具体描述方法的实现过程。抽象方法必须存在于抽象类之中。 例子：Polymorphism.java 
修饰符final
用final声明的类（最终类）不能再有子类；方法（最终方法）不能再被覆盖或重载；成员变量（最终属性）初始化后，不能再被赋值。 用final声明的类：通常是一些有固定作用、用来完成某种标准功能的类 用final声明的属性：通常用来描述属于该类对象的一些常量值 用final声明的方法：用来限制子类对父类方法的重载，确保程序的安全性和正确性。 FinalTest.java 
接口
接口可以被用来实现类间多继承结构。接口内部只能定义 public 的抽象方法和静态的、公有常量，因此所有的方法需要在子类中实现。
接口的定义
接口的定义格式: [修饰符] interface 接口名称 { //方法和静态常量 } 由于接口中定义的方法都是抽象、公有的，常量都是静态、公有的，所以修饰符可以省略。 例子:InterfaceTest.java  
接口的继承
 
接口多态
例子:StackQueue.java   
6、Swing图形控件库
7、文件读写
输入输出方法
什么是数据流 ? 流是可被顺序访问的无限长的字符序列。  在java中有关流的操作使用 io 包 import java.io.*;
File类
File类似IO包中唯一代表磁盘文件本身的对象。File类定义了一些与平台无关的方法操作文件，通过File类的各种方法，能够完成创建、删除文件、重命名文件、判断文件是否存在、读写权限等操作。 例子：FileTest.java   
流类
  Java 的流式输入/输出建立在四个抽象类的基础上：InputStream, OutputStream, Reader和Writer。它们用来创建具体流式子类。尽管程序通过具体子类执行输入/输出操作，但顶层的类定义了所有流类的基本通用功能。 InputStream 和OutputStream 设计成字节流类。Reader 和Writer 为字符流设计。字节流类和字符流类形成分离的层次结构。一般说来，处理字符或字符串时应使用字符流类，处理字节或二进制对象时应用字节流类。 一般在操作文件流时，不管是字节流还是字符流都可以按照以下的方式进行： 1、使用File类找到一个文件 2、通过File类的对象去实例化字节流或字符流的子类 3、进行字节（字符）的读、写操作 4、关闭文件流
字节流
  程序说明： 此程序分为两个部分，一部分是向文件中写入内容（第6行~第26行），另一部分是从文件中读取内容（第27行~第50行）： 1、程序第4行通过一个File类找到C盘下的一个temp.txt文件。 2、向文件写入内容： （1）、第6~第11行通过File类的对象去实例化OutputStream的对象，此时是通过其子类FileOutputStream实例化的OutputStream对象，属于对象的向上转型。 （2）、因为字节流主要以操作byte数组为主，所以程序第17行通过String类中的getBytes()方法，将字符串转换成一byte数组。 （3）、第14行~第20行调用OutputStream类中的write()方法将byte数组中的内容写入到文件中。 （4）、第21行~第26行调用OutputStream类中的close()方法，关闭数据流操作。 3、从文件中读入内容： （1）、第28行~第34行通过File类的对象去实例化InputStream的对象，此时是通过其子类FileInputStream实例化的InputStream对象，属于对象的向上转型。 （2）、因为字节流主要以操作byte数组为主，所以程序第47行声明一1024大小的 byte数组，此数组用于存放读入的数据。 （3）、第38行~第44行调用InputStream类中的read()方法将文件中的内容读入到byte数组中，同时返回读入数据的个数。 （4）、第45行~第51行调用InputStream类中的close()方法，关闭数据流操作。 （5）、第52行将byte数组转成字符串输出。 从上面这道范例中读者可以发现，大部分的方法操作时都进行了异常处理，这是因为所使用的方法处都用throws关键字抛出了异常，所以这里需要进行异常捕捉。 
InputStream
 InputStream 是一个定义了Java流式字节输入模式的抽象类。该类的所有方法在 出错条件下都会引发一个IOException 异常。表中显示了InputStream的方法： 
OutputStream
 OutputStream是定义了流式字节输出模式的抽象类。该类的所有方法返回一个void 值并且在出错情况下引发一个IOException异常。表中显示了OutputStream的方法。 
FileInputStream
FileInputStream 类创建一个能从文件 读取 字节的InputStream 类，它的两个常用的构造方法如下： FileInputStream(String filepath) FileInputStream(File fileObj) 这两个构造方法都能引发FileNotFoundException异常。这里，filepath 是文件的绝对路径，fileObj是描述文件的File对象。 下面的例子创建了两个使用同样磁盘文件且各含一个上面所描述的构造方法的FileInputStreams类： InputStream f0 = new FileInputStream("c:\\test.txt") ; File f = new File("c:\\test.txt"); InputStream f1 = new FileInputStream(f); 尽管第一个构造方法可能更常用到，而第二个构造方法则允许在把文件赋给输入流之前用File方法更进一步检查文件。当一个FileInputStream被创建时，它可以被公开读取。
FileOutputStream
FileOutputStream 创建了一个可以向文件写入字节的类OutputStream，它常用的构造方法如下： FileOutputStream(String filePath) FileOutputStream(File fileObj) FileOutputStream(String filePath, boolean append) 它们可以引发IOException或SecurityException异常。这里filePath是文件的绝对路径，fileObj是描述该文件的File对象。如果append为true，文件则以设置搜索路径模式打开。FileOutputStream的创建不依赖于文件是否存在。在创建对象时，FileOutputStream会在打开输出文件之前就创建它。这种情况下如果试图打开一个只读文件，会引发一个IOException异常。 在下面的例子中，用FileOutputStream类向文件中写入一字符串，并用FileInputStream读出写入的内容。 例子：StreamDemo.java
字符流
尽管字节流提供了处理任何类型输入/输出操作的足够的功能，但它们不能直接操作Unicode字符。既然Java的一个主要目标是支持“一次编写，处处运行”，包含直接的字符输入／输出的支持是必要的。本节将讨论几个字符输入／输出类。如前所述，字符流层次结构的顶层是Reader 和Writer 抽象类，将从它们开始介绍。   程序说明 此程序与上面范例类似，也同样分为两部分，一部分是向文件中写入内容（第8行~第34行），另一部分是从文件中读取内容（第36行~第65行）： 1、程序第6行通过一个File类找到C盘下的一个temp.txt文件。 2、向文件写入内容： （1）、第7行~第15行通过File类的对象去实例化Writer的对象，此时是通过其子类FileWriter实例化的Writer对象，属于对象的向上转型。 （2）、因为字符流主要以操作字符为主，所以程序第17行声明一String类的对象str。 （3）、第18行~第26行调用Writer类中的write()方法将字符串中的内容写入到文件中。 （4）、第27行~第34行调用Writer类中的close()方法，关闭数据流操作。 3、从文件中读入内容： （1）、第37行~第45行通过File类的对象去实例化Reader的对象，此时是通过其子类FileReader实例化的Reader对象，属于对象的向上转型。 （2）、因为字节流主要以操作char数组为主，所以程序第47行声明一1024大小的char数组，此数组用于存放读入的数据。 （3）、第49行~第57行调用Reader类中的read()方法将文件中的内容读入到char 数组中，同时返回读入数据的个数。 （4）、第58行~第65行调用Reader类中的close()方法，关闭数据流操作。 （5）、第67行将char数组转成字符串输出。 
Reader
 Reader是定义Java的流式字符输入模式的抽象类。该类的所有方法在出错情况下都将引发IOException 异常。 
Writer
 Writer 是定义流式字符输出的抽象类。所有该类的方法都返回一个void 值并在出错条件下引发IOException 异常。 
FileReader
FileReader类创建了一个可以读取文件内容的Reader类。它最常用的构造方法显示如下： FileReader(String filePath) FileReader(File fileObj) 每一个都能引发一个FileNotFoundException异常。这里，filePath是一个文件的完整路径，fileObj是描述该文件的File 对象。
FileWriter
FileWriter 创建一个可以写件的Writer 类。它最常用的构造¹法如下： FileWriter(String filePath) FileWriter(String filePath, boolean append) FileWriter(File fileObj) 它们可以引发IOException或SecurityException异常。这里，filePath是文件的绝对路径，fileObj是描述该文件的File对象。如果append为true，输出是附加到文件尾的。FileWriter类的创建不依赖于文件存在与否。在创建文件之前，FileWriter将在创建对象时打开它来作为输出。如果试图打开一个只读文件，将引发一个IOException异常。
说明一点
 FileWriter类并不是直接继承自Writer类，而是继承了Writer的子类（OutputStreamWriter）此类为字节流和字符流的转换类，也就说真正从文件中读取进来的数据还是字节，只是在内存中将字节转换成了字符，所以得出一个结论，字符流用到了缓冲区，而字节流没有用到缓冲区。另外也可以用Writer类中的flush()方法，强制清空缓冲区。
System.in和System.out
为了支持标准输入输出设备，Java定义了两个特殊的流对象：System.in和System.out。 System.in对应键盘，是InputStream类型的，程序使用System.in可以读取从键盘上输入的数据； System.out对应显示器，是PrintStream类型的，PrintStream是OutputStream的一个子类，程序使用System.out可以将数据输出到显示器上。 键盘可以被当作一个特殊的输入流，显示器可以被当作一个特殊的输出流。
打印流
PrintStream类提供了一系列的print和println方法，可以实现将基本数据类型的格式转化成字符串输出。在前面的程序中大量用到“System.out.println”语句中的System.out就是PrintStream类的一个实例对象。PrintStream有下面几个构造方法： PrintStream(OutputStream out) PrintStream(OutputStream out,boolean auotflush) PrintStream(OutputStream out,boolean auotflush, String encoding) 其中autoflush控制在Java中遇到换行符(\n)时是否自动清空缓冲区，encoding是指定编码方式。关于编码方式，本章在后面有详细的介绍。 println方法与print方法的区别是：前者会在打印完的内容后再多打印一个换行符(\n)，所以println()等于print("\n")。Java的PrintStream对象具有多个重载的print和println方法，它们可输出各种类型（包括Object）的数据。对于基本数据类型的数据，print和println方法会先将它们转换成字符串的形式然后再输出，而不是输出原始的字节内容，如：整数221的打印结果是字符‘2’、‘2’、‘1’所组合成的一个字符串，而不是整数221在内存中的原始字节数据。对于一个非基本数据类型的对象，print和println方法会先调用对象的toString方法，然后再输出toString方法所返回的字符串。 IO包中提供了一个与PrintStream对应的PrintWriter类，PrintWriter类的有下列几个构造方法： PrintWriter(OutputStream) PrintWriter(OutputStream, boolean) PrintWriter(Writer) PrintWriter(Writer, boolean) PrintWriter即使遇到换行符(\n)也不会自动清空缓冲区，只在设置了autoflush模式下使用了println方法后才自动清空缓冲区。PrintWriter相对PrintStream最有利的一个地方就是println方法的行为，在Windows的文本换行是"\r\n"，而Linux下的文本换行是"\n"，如果希望程序能够生成平台相关的文本换行，而不是在各种平台下都用"\n"作为文本换行，那么就应该使用PrintWriter的println方法时，PrintWriter的println方法能根据不同的操作系统而生成相应的换行符。 下面的范例通过PrintWriter类向屏幕上打印信息。 例子:SystemPrintDemo.java  下面的范例通过PrintWriter向文件中打印信息。 范例：FilePrint.java 
8、数据库应用
JDBC
JDBC(Java Database Connection，Java数据库连接)是一种用于执行SQL语句的JavaAPI(应用程序设计接口)。JDBC提供了一种标准的应用程序设计接口，使得开发人员使用Java语言开发完整的数据库应用程序变得极为简单。通过JDBC，开发人员几乎可以将SQL语句传递给任何一种数据库，而无需为各种数据库编写单独的访问程序。JDBC可以自动将SQL语句传递给相应的数据库管理系统。 
JDBC编程步骤
1、加载数据库驱动。 Class.forName("com.mysql.jdbc.Driver"); 2、通过DriverManager获取数据库连接。 Connection con = DriverManager.getConnection(url,userName,password); 3、通过Connection对象创建Statement对象。 Statement sql = con.createStatement(); 4、使用Statement执行sql语句。 sql.execute("drop table if exists student"); ResultSet result = sql.executeQuery(query); 5、操作结果集。 while(result.next()){ number = result.getInt("id"); name = result.getString("name"); math = result.getInt("math"); System.out.println(" "+number + "\t" + name + "\t" + math); } 6、回收数据库资源。 sql.close(); con.close();
ConnectToMySQL.java
import java.sql.*; public class ConnectToMySQL { public static Connection getConnection() throws SQLException,java.lang.ClassNotFoundException{ try{ //加载MySql的驱动类 Class.forName("com.mysql.jdbc.Driver"); }catch(ClassNotFoundException e){ System.out.println("找不到驱动程序类 ，加载驱动失败！"); //e.printStackTrace() ; } //String url = "jdbc:mysql://localhost:3306/learn?useUnicode=true&characterEncoding=gbk"; String url = "jdbc:mysql://localhost:3306/learn?useUnicode=true&characterEncoding=ISO-8859-1"; String userName = "root"; String password = ""; Connection con = DriverManager.getConnection(url,userName,password); return con; } public static void main(String[] args) { try{ Connection con = getConnection(); Statement sql = con.createStatement(); sql.execute("drop table if exists student"); sql.execute("create table student(id int not null auto_increment,name varchar(20) not null default 'name',math int not null default 60,primary key(id));"); sql.execute("insert student values(1,'Tom','99')"); sql.execute("insert student values(2,'Mike','77')"); sql.execute("insert student values(3,'Alice','65')"); String query = "select * from student"; ResultSet result = sql.executeQuery(query); System.out.println("Student表数据如下："); System.out.println("---------------------------------"); System.out.println("学号"+"\t"+"姓名"+"\t"+"数学成绩"); int number; String name; String math; while(result.next()){ number = result.getInt("id"); name = result.getString("name"); math = result.getString("math"); System.out.println(" "+number + "\t" + name + "\t" + math); } sql.close(); con.close(); }catch(java.lang.ClassNotFoundException e){ System.err.println("ClassNotFoundException:" + e.getMessage()); }catch(SQLException ex){ System.err.println("SQLException:" + ex.getMessage()); } } }
其他的
异常
对于任何语言的程设计而言，错误的发生总是不可避免的。为了加强程的健壮性，程设计时，必须充分考虑错误发生的可能性，并ú立相的处理机制 异常（Exception）又称为例外，是指在程运行过程中发生的非正常事件，这些事件的发生会影响程的正常执行。如： 进行数学中“无意义”的运算，例如除数为零、对负数求对数平方根等 对数组进行操作时，超出了数组的最大下标 程所需进行的I/O操作不能正常执行，如所需访问的文件不存在 内存耗尽无法进行类的实例化 JVM崩溃   1、try程序块若是有异常发生时，程序的运行便中断，并抛出“异常类所产生的对象”。 2、抛出的对象如果属于catch()括号内欲捕获的异常类，则catch会捕捉此异常，然后进到catch的块里继续运行。 3、无论try程序块是否有捕捉到异常，或者捕捉到的异常是否与catch()括号里的异常相同，最后一定会运行finally块里的程序代码。 finally的程序代码块运行结束后，程序再回到try-catch-finally块之后继续执行。 由上述的过程可知，异常捕捉的过程中做了两个判断：第一个是try程序块是否有异常产生，第二个是产生的异常是否和catch()括号内欲捕捉的异常相同。 值得一提的是，finally块是可以省略的。如果省略了finally块不写，则在catch()块运行结束后，程序跳到try-cath块之后继续执行。  当try块中的某条代码抛出异常时：首先，自该语句的下一条语句起的所有try块中的剩余语句将被跳过不予执行；其次，程序执行catch子句进行异常捕获，异常捕获的目的是进行异常类型的匹配，并执行与所抛出的异常类型相对应的catch子句中的异常处理代码。 需要注意的是：如果try块中没有任何的异常抛出，则所有的catch子句将会被跳过；如果try块中所抛出的异常对象类型与所有的catch子句中的所声明的异常类型都不匹配，则方法会立即中止 当一个方法的某条语句抛出异常后，该方法剩余的语句将无法继续执行。这种情况下，方法往往无法将其占用的资源进行释放。Java语言的异常处理机制中提供了一个更好的方案－程序员可以使用finally子句来统一进行资源释放之类的工作。  下例说明了类对象e的应用 
线程
jsp、servlet