JavaSE知识点总结
作者：田超凡
版权所有，转载请注明原作者，仿冒侵权必究法律责任
Java技术平台简介
Java是著名的Sun Microsystems于1995年推出的高级编程语言，由Green项目的工程师James Gosling（Java语言之父）带领开发。在计算机软件应用领域中，我们把Java的应用分为两种典型的类型：一种是安装和运行在在本机上的桌面程序；一种是通过浏览器访问的面向Internet的应用程序。
⒈JavaSE
全称是Java Platform Standard Edition，是Java技术的核心，提供基础Java开发工具、执行环境与API，主要用于桌面应用程序的开发。
⒉JavaEE
全称是Java Platform Enterprise Edition，它主要用于网络程序和企业级应用的开发。JavaEE是在JavaSE的基础上扩展的。
⒊JavaME
以往称作J2ME(Java Platform, Micro Edition )是为机顶盒、移动电话和PDA之类嵌入式消费电子设备提供的高度优化的Java语言平台，包括虚拟机和一系列标准化的Java API。目前阶段，Java ME最流行的应用是游戏软件。因为与需要昂贵的专用设备和开发工具的竞争对手相比，Java ME程序可以在PC机上开发和仿真运行，然后很容易地部署到目标机上，从而使其开发、测试和发布的变得容易和廉价。
Sun公司官方主页：http://java.sun.com/。Eclipse官方网站：http://www.eclipse.org/。
开发Java程序步骤
第一步：编写源程序。把要下达的指令用Java语言描述出来，我们称这个文件为源程序或源代码。（以.java作为扩展名）
第二步：编译。使用Sun公司提供的JDK（Java Development Kit）能够实现编译和运行功能。经过它的翻译，输出一个后缀名为.class的文件（字节码文件）。
第三步：运行。在Java平台上运行字节码文件，便可看到运行结果。
使用集成开发环境——有了JDK的支持，我们就可以用记事本编写Java源程序。为使编写更加方便，我们使用集成开发环境（IDE）。IDE是一类软件，它将程序开发环境和程序调试环境集合在一起。用于开发Java的IDE很多，我们选用功能强大的Eclipse。
Java程序框架
第一步：给程序起一个名字，在Java中我们叫它类名。第二步：写出main方法框架。第三步：在main方法中填写代码，也就是我们所要下达的指令集。
示例：
public class Accp { （Accp即类名）
public static void main (String[] args) {
//代码
}
}
★第一个简单的Java程序——向屏幕输出“Hello!”
public class Accp {
public static void main (String[] args) {
System.out.println(“Hello!”);
}
}
下面我们来分析一下程序的各个组成部分：
⒈程序框架
public class Accp { }
这里类名为Accp，它要和程序文件的名称一模一样。类名前面要有public和class修饰，所有属于这个类的代码放在后面的“{ }”中。
⒉main方法框架
public static void main(String[] args) { }
main方法是Java程序的入口，所有Java程序的起始点。一个程序只有一个main方法。
⒊填写的代码
System.out.println(“Hello!”);
这一行的作用就是打印一句话。System.out.println()是Java语言自带的功能，使用它可以向控制台输出信息，我们只有把要输出的语句用英文引号引起来放在println()中就可以了。【System.out.print();也可以实现输出。但是println()语句在打印完引号内的语句后会自动换行。】『System.out.println(“”)和System.out.print(“\n”)可以达到同样的效果，”\n”称为转义字符，将光标移到下一行第一格。另一个转义字符是”\t”，将光标移到下一个制表位置（8个空格）』
Java的注释与编码规范
1、多行注释——以“/*”开头，以“*/”结尾。示例：
/*
*Accp.java
*2007-8-5
*The first Java program
*/
public class Accp {……
……
}
2、单行注释——以“//”开头，“//”后面的内容都被认为是注释。
3、编码规范 示例：
class Accp {
public static void main (String[] args) {
System.out.print(“hello!”);
}
}
class前去掉了public，仍然能够得到相应的结果。可见，不规范的代码并不是错误的代码，但还是应该遵守相应规范：⑴类名必须使用public修饰；⑵一行只写一条语句。
4、常见错误
- 类的命名。public类的名称必须与Java文件同名。
- main方法中的void不可少。（否则Eclipse会给出“缺少方法的返回类型”错误）
- Java区分对大小的识别。（若把System.out.print改成system.out.print就会出错）
- 在Java中，一个完整的语句都要以“;”结束。
- 输出的字符串必须用英文引号引起来。
变量、数据类型和运算符
★Java常用数据类型
| 数据类型 |
说明 |
举例 |
| int |
整型 |
用于存储整数 |
| double |
双精度浮点型 |
用于存储带有小数点数 |
| char |
字符型 |
用于存储单个字符 |
| String |
字符串型 |
用于存储一串字符 |
不同的数据在存储时所需空间不同，如int型的数值要4个字节，而double型数值要8个字节。
变量声明
比如，现在我们要储存考试成绩98.5分和学生姓名“张三”及性别“男”。
步骤1：声明变量。语法：数据类型 变量名;。
double score; //声明双精度浮点型变量score存储分数
String name; //声明字符串型变量name存储学生姓名
char sex; //声明字符型变量sex存储性别
步骤2：赋值。语法：变量名 = 值;。
score = 98.5;
name = “张三”;
sex = “男”;
你也可以将步骤1和步骤2合二为一，在声明的同时给变量赋值。例如：
double score = 98.5;
String name = “张三”;
变量命名规则
| 条件 |
合法变量名 |
非法变量名 |
| 变量名必须以字母、“_”或“$”开头 |
_myCar $myCar score1 graph1_1 |
*myvariable1 variable% 9variable a+b My Variable t1-2 |
| 变量可以包括数字，但不能以数字开头 |
||
| 除了“_”和“$”以外，变量名不能包含任何特殊字符 |
||
| 不能使用Java关键字，如int、class、public等 |
Java对变量名长度没有限制，但区分大小写。
常见错误
⒈变量为赋值先使用
⒉使用非法变量名
⒊变量名重名
运算符
※赋值运算符“=”。将等号右边表达式的结果赋值给等号左边的变量。
注意，a = b;和b = a;并不一样。
※算数运算符 常用的算数运算符
| 运算符 |
说明 |
举例 |
| + |
加法运算符，求操作数的和 |
5 + 3 |
| - |
减法运算符，求操作数的差 |
5 – 3 |
| * |
乘法运算符，求操作数的积 |
5 * 3 |
| / |
除法运算符，求操作数的商 |
5 / 3 |
| % |
取余运算符，求操作数相除的余数 |
5 % 3等于2 |
下面就使用Java提供的运算符来解决一个简单的问题。
问题要求：
已知学员三门课程成绩——
| 课程 |
成绩 |
| STB |
89 |
| Java |
90 |
| SQL |
60 |
编程以实现：⑴Java课程和SQL课程的分数之差；⑵3门课程平均分。
示例代码：
public class Accp {
public static void main (String[] args) {
int stb = 89;
int java = 90;
int sql = 60;
int diffen; //分数差
double avg; //平均分
System.out.println(“-----------------------”);
System.out.println(“STB\tJava\tSQL”);
System.out.println(stb +“\t”+ java +“\t”+ sql);
System.out.println(“-----------------------”);
diffen = java – sql;
System.out.println(“Java和SQL的成绩差：”+ diffen);
avg = (stb + java + sql) / 3;
System.out.println(“3门课的平均分是：”+ avg);
}
}
另外还有两个非常有用而特殊的运算符：自加运算符“++”和自减运算符“--”。这里，“数字1++”等价于“数字1 = 数字1 + 1”，“数字2--”等价于“数字2 = 数字2 – 1”。
数据类型转换
⒈自动数据类型转化
规则1：如果一个操作数为double型，则整个表达式可提升为double型。
规则2：满足自动类型转换的条件。
⑴两种类型要兼容：数值类型（整型和浮点型）互相兼容。
⑵目标类型大于源类型：double类型可以存放int型数据，因为为double型变量分配的空间宽度足够存储int型变量。因此，我们也把int型变量转换成double型变量成为“放大转换”。
⒉强制数据类型转化
语法： （数据类型）表达式
在变量前加上括号，括号中的类型就是你要转换成的类型。比如：
double d = 34.5634;
int b = (int)d;
运行后b的值为34。从示例中可以看出，由于强制类型转换往往是从宽度达的类型转换成宽度小的类型，使数值损失了精度，因此我们称这种转换为“缩小转换”。
运算符和条件结构
boolean类型
| 值 |
说明 |
| true |
真 |
| False |
假 |
问题：
从控制台录入同学1的成绩，与同学2 （80分）比较，输出对“同学1的成绩比同学2的成绩高吗？”的判断结果。
分析：要编程以实现两部分——⑴从键盘录入数据；⑵比较数据，并将比较结果输出。
示例代码：
import java.util.*; 【键入import java.util.Scanner;也可】
public class Accp {
public static void main(String[] args) {
int classmate_2 = 80;
bollean Big;
Scanner input = new Scanner(System.in);
System.out.print(“输入同学1的成绩：”);
int classmate_1 = input.nextInt();
Big = classmate_1 > classmate_2;
System.out.println(“同学1的成绩比同学2高吗？”+ Big);
}
}
关系运算符
关系运算符是用来做比较运算的，其值要么是真（true），要么是假(false)。
| 关系运算符 |
说明 |
| > |
大于 |
| < |
小于 |
| >= |
大于等于 |
| <= |
小于等于 |
| == |
等于 |
| != |
不等于 |
if条件结构
if条件结构是根据条件判断之后再做处理的一种语法结构。语法：
if （条件） {
//要执行的语句
}
问题1：输入一位同学的成绩，高于90分时系统输出：获得奖学金。
示例代码：
import java.util.*;
public class Just {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“输入成绩：”);
int score = input.nextInt(); //从控制台获取学生成绩
if ( score > 90 ) {
System.out.println(“获得奖学金。”);
}
}
}
当问题的判断条件比较多时，我们可以用逻辑运算符将多个条件连接起来。
| 逻辑运算符 |
汉语名称 |
表达式 |
说明 |
| && |
与、并且 |
条件1 && 条件2 |
两个条件同时为真，结果为真 两个条件有一个为假，结果为假 |
| || |
或、或者 |
条件1 || 条件2 |
两个条件有一个为真，结果为真 两个条件同时为假，结果为假 |
| ! |
非 |
!条件 |
条件为真时，结果为假 条件为假时，结果为真 |
◎使用if-else条件结构
我们简单修改一下问题1：输入一位同学的成绩，高于90分时系统输出：获得奖学金；否则输出：继续努力。 示例代码：
import java.util.*;
public class Just {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“输入成绩：”);
int score = input.nextInt(); //从控制台获取学生成绩
if ( score > 90 ) {
System.out.println(“获得奖学金。”);
} else {
System.out.println(“继续努力！”);
}
}
}
◎使用多重if结构
问题2：对学员的成绩进行评测——成绩≥90：优秀；成绩≥80：良好；成绩≥60：中等；成绩＜60：差。 示例代码：
public class Accp {
public static void main(String[] args) {
int score = （学生的成绩）;
if ( score >= 90 ) {
System.out.println(“优秀”);
} else if ( score >= 80 ) {
System.out.println(“良好”);
} else if ( score >= 60 ) {
System.out.println(“中等”);
} else {
System.out.println(“差”);
}
}
}
else if块的顺序是连续的，第一个条件之后的所有条件都是在第一个条件不成立的情况下才出现的，而第二个条件之后的所有条件是在第一、二个条件都不成立的情况下才出现的。可见，else if块的顺序不是乱排的，要么从大到小，要么从小到大。
switch结构
switch结构可以更好地解决等值判断的问题。语法：
switch (表达式) {
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
……
default:
语句n;
break;
}
下面看一个简单的问题：
运动员参加比赛。获得第一名得到金牌；第二名银牌；第三名铜牌。否则一无所获。
示例代码：
public class Match {
public static void main(String[] args) {
int mingci = (获奖名次);
switch (mingci) {
case 1:
System.out.println(“金牌”);
break;
case 2:
System.out.println(“银牌”);
break;
case 3:
System.out.println(“铜牌”);
break;
default:
System.out.println(“一无所获”);
}
}
}
“break”是可以省略的，但会带来一些问题。省略break后，当某个case的值符合条件时，执行该case块的语句，后面的case就不再进行条件判断，而是直接执行后面所有case块中的语句，直到遇到break结束。
每个case后可以有多个语句，且不需要用“{ }”括起来，case和default后都有一个冒号。多重if结构和switch结构很相似，它们都是用来处理多分支条件的结构，但是switch结构只能处理等值条件判断的情况，而且必须是整型或字符型变量，而多重if结构没有这个限制。
循环结构（一）
While循环
语法：
while (循环条件) {
循环操作
}
while后小括号中是循环条件，循环条件是一个布尔表达式。{ }中的语句称为循环操作，又称为循环体。
问题1：
用程序实现——当键入字符“n”时，执行循环体；键入字符“y”时实现输出。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
String answer;
Scanner input = new Scanner(System.in);
System.out.print(“考试成功了吗？（y/n）:”);
answer = input.next();
while (! answer.equals(“y”)) {
System.out.println(“继续努力！”);
System.out.println(“考试成功了吗？（y/n）:”);
answer = input.next();
}
System.out.println(“祝贺你。”);
}
}
比较两个int或double型变量是否相等，我们使用运算符“==”；String型变量是否相等我们通常采用这样的方法：
aString.equals(bString);。
问题2：
根据输入的某个班的成绩计算该班同学的平均成绩。要求输入班级的人数。
示例代码：
import java.util.*:
public class Accp {
public static void main(String[] args) {
String classNo; //班级号
int stuNum; //班级的学生人数
int score; //学生分数
int sum; //学生分数总和
int avg; //学生成绩平均值
System.out.print(“请输入班级号：”);
Scanner input = new Scanner(System.in);
classNo = input.next();
System.out.print(“请输入班级的学生总数：”);
stuNum = input.nextInt();
int i = 1;
while (i <= stuNum) {
System.out.print(“请输入学号” + i + “的成绩：”);
score = input.nextInt();
sum = sum + score;
i++;
}
avg = sum / stuNum;
System.out.println(“该班级的平均成绩：” + avg);
}
}
do-while循环
语法：
do {
循环操作
} while (循环条件);
问题：编写一个连续输入学生姓名的程序，输入完毕后键入“q”，程序停止。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
String name;
Scanner input = new Scanner(System.in);
do {
System.out.print(“请输入学生姓名：”);
name = input.next();
} while (! name.equals(“q”));
System.out.println(“程序已结束。”);
}
}
while循环和do-while循环的区别——⑴语法不同。与while循环相比，do-while循环将while关键字和循环条件放在后面，而且前面多了do关键字，后面多了一个分号。⑵执行次序不同。while循环先判断，再执行；do-while循环先执行，再判断。⑶一开始循环条件就不满足的情况下，while循环一次都不执行，do-while循环则不管什么情况都至少执行一遍。
循环结构（二）
for循环
语法：
for (表达式1;表达式2;表达式3) {
//循环语句
}
| 表达式 |
形式 |
功能 |
| 表达式1 |
赋值语句 |
循环结构的初始部分 |
| 表达式2 |
条件语句 |
循环结构的循环条件 |
| 表达式3 |
赋值语句，通常使用++或--运算符 |
循环结构的迭代部分，通常用来修改循环变量的值 |
问题1：循环输入某同学结业考试的5门成绩，并计算平均分。
示例代码：
import java.util.*;
public class Accp {
public static void main (String[] args) {
int score;
int sum = 0;
int avg;
Scanner input = new Scanner(System.in);
System.out.print(“输入学生姓名：”);
String name = input.next();
for (int i = 0;I <= 5; i++) {
System.out.print(“请输入第”+ i +“门课的成绩：”);
score = input.nextInt();
sum = sum + score;
}
avg = sum / 5;
System.out.print(name +“的平均分是：”+ avg);
}
}
问题2：输入任意一个数，输出这个数的加法表。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
int i, j;
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个值：”);
int val = input.nextInt();
System.out.println(“根据这个值输出一下加法表：”);
for (i = 0; j = val; i<=val; i++, j--) {
System.out.println(i +“+” + j + “=” + (i+j));
}
}
}
break语句的使用
在switch结构中，break语句用于终止switch语句的某个分支，使程序跳到switch语句块以外的下一个语句。
问题：循环输入某同学5门课的成绩的平均分，如果分数录入为负，停止录入并提示录入错误。
示例代码：
import java.util.*;
public class Accp {
public static void main (String[] args) {
int score;
int sum = 0;
int avg;
boolean wrong = true;
Scanner input = new Scanner(Syatem.in);
System.out.print(“输入学生姓名：”);
String name = input.next();
for (int I = 0; I < 5; i++) {
System.out.print(“请输入第”+ i+1 +“门课的成绩：”);
score = input.nextInt();
if (score < 0) {
wrong = false;
break;
}
sum = sum + score;
}
if (wrong) {
avg = sum / 5;
System.out.println(name + “的平均分是：”+ avg);
}else{
System.out.println(“分数录入错误，请重新输入！”);
}
}
}
break语句用于终止某个循环，使程序跳到循环块以外的下一句。在循环语句中位于break后的语句将不再执行。break语句不仅用在for循环中，也可以用在while和do-while循环中。break语句通常与if条件句一起使用。
continue语句的使用
问题：求1～100之间个位数字不是2、3、4、7，并且不能被3整除的整数之和。
示例代码：
public class Accp {
public static void main(String[] args) {
int sum = 0;
for(int I = 1; I <= 100; i++) {
if (i%10==2 || i%10==3 || i%10==4 || i%10==7 || i%3==0) {
continue;
}
sum = sum + i;
}
System.out.println(“1～100之间个位数不是2、3、4、7，且不能被3整除数的和是：”+ sum);
}
}
continue可以用于for循环，也可以用于while和do-while循环。在for循环中，continue使程序先跳转到迭代部分，然后判断循环条件，如果为true，继续下一次循环，否则，终止循环；在while循环中，continue执行完毕后，程序将直接判断循环条件。continue语句只能用在循环结构中。
对象和类
Java的类模板
public class <类名> {
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
……
属性n的类型 属性n;
//定义方法部分
方法1;
方法2;
……
方法n;
}
命名类时不能嵌入任何空格或“.”，以及除“_”、“$”字符之外的特殊字符。不能以数字开头。
问题：编写学生和教师类，输出学生和老师的相关信息。
| 学生类 |
教师类 |
| 属性： 姓名 年龄 参加的教程 兴趣 |
属性： 姓名 专业方向 教授课程 教龄 |
| 方法： 显示个人信息 |
方法： 显示个人信息 |
示例代码：
/*
* 学生类
*/
|
定义类的属性 |
转存失败重新上传取消public class Student {
String name;
int age;
String habby;
|
定义类的方法 |
转存失败重新上传取消 String classNo; //班级
public String toString() {
return name + “\n 年龄：”+ age + “\n 爱好:”+ hobby + “\n 就读于”+ classNo;
}
}
/*
*教师类
*/
public class Teacher {
String name;
String course;
String dep; //专业方向
int teaYear;
public String toString() {
return name + “\n 教授课程：” + course + “\n 主攻方向：” + dep + “\n 教龄：”+ teaYear;
}
}
toString()—— 一个非常特殊的方法。通常我们使用这个方法来显示一个类的相关信息。
return将返回一个自定义的字符串。
public String toString() {
return 自定义字符串;
}
创建和使用对象
一个类定义好了，就可以根据定义的模子创建对象了。由类生成对象称为类的实例化过程。
语法：类名 对象名 = new 类名();
问题：用类的思想输出学校的信息。
|
定义School类的属性 |
public class School {
String schoolName; //学校的名称
|
定义School类的toString()方法 |
转存失败重新上传取消 int classNum; //教室数量
int labNum; //机房数目
public String toString() {
return schoolName + “\n”+ “配备：”+ classNum + “教室”+ labNum + “机”;
}
}
public class InitSchool {
public static void main(String[] args) {
School center = new School(); //创建一个School对象-center
center.schoolName = “（学校的名称）”; //引用schoolName属性
center.classNum = 教室数量; //引用classNum属性
center.labNum = 机房的数目; //引用labNum属性
System.out.println(center);
}
}
语法：对象名.属性 //引用对象的属性
对象名.方法名() //引用对象的方法
例如：center.name = ……; //赋值
center.toString(); //调用类的方法
在System.out.println(center)中，也可以写成center.toString()，toString()方法是一个比较特殊的方法，center等价于center.toString。访问类的方法就是执行类方法中的代码。在没有初始化示例变量时，Java会给它一个默认值。
| 类型 |
默认值 |
| int |
0 |
| double |
0.0 |
| char |
‘\u0000’ |
| boolean |
false |
| String |
null |
数据类型总结
Java中的数据类型主要分为两类：
⑴基本数据类型：整形(int)、双精度浮点型(double)、字符型(char)、布尔型(boolean)。
⑵引用数据类型：字符串(String)、使用class自定义的类型。
数据类型比较
| 类型 |
特征 |
声明举例 |
使用举例 |
| 基本数据类型 |
没有方法 |
int age = …… |
age++; 变量自加1 |
| 引用数据类型 |
有方法 |
Student stu = new Strdent(); String s = new String(“……”);等价于String s = “……” |
stu.age++; 类的成员变量自加1 |
类的方法
如何定义类的方法
类的方法必须包含以下3个部分。
⑴方法的名称
⑵方法返回值的类型
⑶方法的主体
语法：
public 返回值的类型 方法名() {
//方法的主体
}
在方法的主体内，如果方法具有返回类型，则必须使用关键字return返回值。比如：在toString()方法中，返回类型是String类型，因此在方法体中必须用return返回一个字符串（方法至多可以返回一个值，不能返回多个值）。如果方法根本没有返回值，则返回值的类型应该用void，用于说明无返回值。
方法调用
问题：计算班里同学的平均分和3门课的总成绩，编写成绩计算类来实现这些功能。
示例代码：
成绩计算类：
public class ScoreCalc {
int Java; //Java成绩
int c; //C#成绩
int db; //DB成绩
/*计算总成绩*/
public int calcTotalScore() {
int total = java + c + db;
return total;
}
/*显示总成绩*/
public void showTotalScore() {
System.out.println(“总成绩是：”+ calcTotalScore());
}
/*计算平均成绩*/
public int calcAvg() {
int avg = (java + db + c)/3;
return avg;
}
public void showAvg() {
System.out.println(“平均成绩是：”+ calcAvg());
}
}
测试类：
import java.util.*;
public class TestScoreCalc {
public static void main(String[] args) {
ScoreCalc sc = new ScoreCalc();
/*接受成绩*/
Scanner input = new Scanner(System.in);
System.out.print(“请输入Java成绩：”);
sc.java = input.nextInt();
System.out.print(“请输入C#成绩：”);
sc.c = input.nextInt();
System.out.print(“请输入DB成绩：”);
sc.db = input.nextInt();
sc.ShowTotalScore();
sc.ShowAvg();
}
}
方法调用对比
| 调用情况 |
举例 |
| 类Student的方法a()调用Student类的方法b()，直接调用。 |
public void a() { b(); //调用b } |
| 类Student的方法a()调用类Teacher的方法b()，先创建对象，然后使用“.”调用。 |
public void a() { Teacher t = new Teacher(); t.b(); } |
变量作用域及常见错误
在类中定义的变量称为类的成员变量；在方法中定义的变量称为局部变量。在使用时，成员变量和方法的局部变量具有不同的使用权限。
→成员变量：类的方法可以直接使用该类定义的成员变量。如果别的类的方法要访问它，必须首先创建该类的对象，然后才能通过点运算符来引用。
→局部变量：它的作用域仅仅在定义该变量的方法内，因此只有在这个方法中能够使用它。
对比两种变量：⑴作用域不同。⑵初始值不同：对于成员变量，如果在类定义中没有给它赋予初始值，Java会给它一个默认值，但是Java不会给局部变量赋予初始值，因此在使用一个局部变量之前必须给它赋值。
常见错误：
⒈误用局部变量——
public class Test {
int score1 = 88;
int score2 = 98;
public void calcAvg() {
int avg = (score1 + score2)/2;
}
public void showAvg() {
System.out.println(“平均分是：”+ avg);
}
}
如果编写一个main方法来调用Student类的showAvg()方法，编译器会报错“无法解析avg”。为什么呢？因为在showAvg()中使用了在calcAvg中定义的变量avg，这就超出了avg的作用域了。
排错方法：如果要使用在方法calcAvg()中获得的avg结果，可以编写带有返回值的方法，然后从showAvg()中调用这个方法，而不是直接使用在这个方法中定义的变量。
⒉控制流语句块中的局部变量
public class VariableDomain1 {
public static void main(String[] args) {
for(int i = 0, a = 0; i < 4; i++) {
a++;
}
System.out.println(a);
}
}
运行代码，编译器报错“无法解析a”。变量a是在for循环中定义的变量，因此a只能在for循环中使用，一旦退出了循环，就不能再使用a了。另外，在while循环、do-while循环、if块、switch块中定义的变量，作用域也仅仅在这些控制流语句块内。
JavaDoc注释
JavaDoc是Sun公司提供的一个技术，它能够从程序源代码中抽取类、方法、成员等的注释，形成一个和源代码配套的API帮助文档。
→JavaDoc注释以“/**”开头，以“*/”结尾。
→每个注释包含一些描述性的文本及若干个Javadoc标签。
→Javadoc标签一般以“@”为前缀，常用的有：@author，用于表明开发该类模块的作者；@version，用于表明该类模块的版本；@return，用于描述方法的返回值；@param，用于描述方法中的参数。
（Sun公司提供的JavaSE6帮助文档是权威的参考资料，下载地址http://java.sun.com/javase/downloads/index.jsp。
数组
使用数组的步骤
⒈声明数组
语法:
数据类型 数组名[ ]; 或者 数据类型[ ] 数组名;
注意：声明数组时不能漏写[]，另外这样声明数组时不要规定数组的长度。
int score[30] //错误
⒉分配空间
语法：
数组名 = new 数据类型[数组长度];
当然，你也可以在声明数组时就给它分配空间。
语法：
数组类型[ ] 数组名 = new 数据类型[数据长度];
⒊赋值
语法：
数组名[下标值]; （数组下标从0开始）
除此之外，Java中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成。
语法：
数据类型[] 数组名 = {值1,值2,值3,…,值n};
创建数据小结
| 方法 |
说明 |
语法 |
| 仅声明 |
仅声明数组 |
数据类型[] 数组名; |
| 声明和创建 |
使用保留字“new”声明并为数组元素分配内存 |
数据类型[] 数组名 = new 数据类型[数组长度]; |
| 声明、创建和初始化 |
声明数组，为其分配内存并对元素赋初始值 |
数据类型[] 数组名 = {值1,值2,值3,…,值n } 数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,…,值n } |
在Java中定义数组之后，若没有指定初始值，则依据数据类型的不同，会给数组元素赋予一个默认值。
数组元素初始值
| 数据类型 |
初始值 |
| int |
0 |
| double |
0.0 |
| char |
‘\u0000’ |
| boolean |
false |
数组应用
⑴求最大值
问题：从键盘输入5个学生的平均分，求其中的最高分。
示例代码：
import java.util.*;
public class Accp {
public static void main (String[] args) {
int[] score = new int[5];
int max;
System.out.println(“请录入学生成绩：”);
Scanner sc = new Scanner (System.in);
for(int i = 0; i < 5; i++) {
score [i] = sc.nextInt();
}
max = score [0];
for(int index = 1; index < 5; index++) {
if(score[index] > max) {
max = score[index];
}
}
System.out.println(“本次考试的最高平均分是：”+ max);
}
}
⑵排序
使用java.util.Arrays类操作数组。
binarySearch()让你对已经排序的数组进行二元搜索，如果找到指定的值就返回该值所在的位置。
sort()方法，快速排序方法。
对数组进行排序——
对5为同学成绩进行升序排列，并输出排序结果。
示例代码：
import java.util.Arrays;
import java.util.Scanner;
public class Accp {
public static void main(String[] args) {
int[] score = new int[5];
Scanner input = newScanner(System.in);
System.out.println(“输入学生成绩：”);
for(int i = 0; i< 5; i++) {
score[i] = input.nextInt();
}
Arrays.sort(score); //对数组进行升序排列
System.out.println(“学生成绩按升序排列”);
for(int index = 0; index < score.length; index++) {
System.out.println(score[index]);
}
}
}
【Arrays是java.util包中预定义的一个类，要使用Arrays类中的方法应该先创建Arrays的对象然后才能使用。没有创建Arrays的一个实例而直接调用它的sort方法是应为Arrays类将它定义为静态方法，这是一个非常特殊的方法。】
字符串
如何使用字符串
⑴定义并初始化字符串。
⑵使用字符串，对字符串进行一些处理。
String s = “Hello”;
在Java中，字符串被作为String类型的对象来处理。它位于java.lang包中，在使用前要先导入这个包。创建String对象的另外两种方法如下：
String s = new String();
或者
String a = new String(“Hello”);
字符串的长度、比较和连接
length()方法用于返回字符串中的字符数
语法：字符串名.length();
equals()方法用于比较两个字符串是否相同，它逐个地对照组成两个字符串的每个字符是否相同，字符的大小写也在检查范围内。
语法：字符串1.equals(字符串2);
■equalsIgnoreCase()方法比较字符串时忽略字符的大小写。
★toLowerCase()：转换字符串中的英文字符为小写。toUpperCase()：转换字符串中的英文字符为大写。
问题：学生进行入学注册，输入两次密码，如果相同，提示注册成功；如果不相同，提示重新输入。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
System.out.println(“--------欢迎进入注册系统--------”);
Scanner input = new Scanner(System.in);
System.out.println(“请输入您的密码：”);
String psw1 = input.next();
System.out.println(“请确认您的密码：”);
String psw2 = input.next();
if(psw1.equals(psw2)) {
System.out.println(“注册成功。”);
}else{
System.out.println(“密码不一致，请重新注册！”);
}
}
}
连接字符串的方法有两种：
⑴使用“+”运算符。“+”运算符可将多个字符串连接成一个字符串，在使用“+”运算符连接字符串型和int型（或double型）数据时，“+”将int（或double）型数据自动转换成String型。
⑵String类的concat()方法。语法：字符串1.concat(字符串2);
字符串常用的提取和查询方法
常用提取和查询字符串的方法
| 方法 |
说明 |
| public int indexOf(int ch) |
搜索第一个出现的字符ch（或字符串value |
| public int indexOf(String value) |
|
| public int lastIndexOf(int ch) |
搜索最后一个出现的字符ch（或字符串value） |
| public int lastIndexOf(String value) |
|
| public String substring(int index) |
提取从位置索引开始的字符串部分 |
| public String substring(int beginindex,int endindex) |
提取beginindex和endindex之间的字符串部分 |
| public String trim() |
返回一个前后不含任何空格的调用字符串的副本 |
字符串是一个序列，每一个字符都有自己的位置，它的位置是从0开始到（字符串长度-1）结束。特别要注意的是，在substring(int beginindex,int endindxe)方法中，对于开始位置，Java是基于首字符为0处理的，而终止位置是基于首字符为1处理的。如图所示：
| 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
| 青 |
春 |
无 |
悔 |
无 |
悔 |
青 |
春 |
| 1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
问题：学生提交Java作业时，输入java源代码文件名，并输入自己的邮箱，提交前系统检查：⑴是否是合法的Java文件名；⑵邮箱是否为合法邮箱。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
boolean fileCorrect = false; //标识文件名是否正确
boolean emailCorrect = false; //标识E-mail是否正确
System.out.println(“---欢迎进入作业提交系统---”);
Scanner input = new Scanner(System.in);
System.out.println(“请输入Java文件名：”);
String filename = input.next();
System.out.println(“请输入你的邮箱：”);
String email = input.next();
//检查Java文件名
int index = filename.lastIndexOf(“.”); //“.”的位置
if(index != -1 && index != 0 && fileName.substring(index+1,filename.length()).equals(“java”)) {
fileCorrect = ture;
}else{
System.out.println(“文件名无效。”);
}
//检查邮箱格式
if (email.indexOf(‘@’)!=-1 && email.indexOf(‘.’)>email.indexOf(‘@’)) {
emailCorrect = true;
}else{
System.out.println(“E-mail无效。”);
}
//输出检查结果
if (fileCorrect && emailCorrect) {
System.out.println(“作业提交成功。”);
}else{
System.out.println(“作业提交失败！”);
}
}
}
带参数的方法
⒈如何使用带参数的方法
第一步：定义带参数的方法
语法：public 返回值类型 方法名 （参数列表） {
//方法体
}
参数列表的基本形式是
数据类型 参数1，数据类型 参数2，数据类型 参数3……数据类型 参数n
第二步：调用带参数的方法
调用带参数的方法时，必须在调用时传入参数。例如：方法A中定义了两个参数，一个是int型，一个是double型。
public void A(int a, double b) {
//方法体
}
在方法调用时就必须传递两个参数，并且一一对应。调用方法如下：
语法：对象名.A （变量1，变量2）；
⒉带参数的方法应用
问题：输入学期代码，输出该学期的课程信息。
分析：使用数组存储每一个学期的课程信息，使用循环打印输出。
示例代码：
import java.util.*;
public class Accp {
public static void main(String[] args) {
//声明每学期课程信息
String[] s1 = {“进入软件编程世界”,”使用Java语言理解程序逻辑”};
String[] s2 = {“SQL Server数据库设计和高级查询”,”深入.NET平台”};
String[] y2 = {“用JSP开发动态网站”,“前沿技术课”};
System.out.println(“请输入学期代码（1/2/3）：”);
Scanner input = new Scanner(System.in);
int courseCode = input.nextInt();
if(courseCode==1) {
System.out.println(“第1学期的课程是：”);
for(int i = 0; i < s1.length; i++) {
System.out.println(s1[i]);
}
}else if (courseCode== 2) {
System.out.println(“第2学期的课程是：”);
for(int i = 0; i < s2.length; i++) {
System.out.println(s2[i]);
}
}else if(courseCode ==3) {
System.out.println(“第3学期的课程是：”);
for(int i = 0; i < y2.length; i++) {
System.out.println(y2[i]);
}
}else {
System.out.println(“课程代码输入错误。”);
}
}
}
示例定义了3个数组，分别存储各学期的课程信息，然后根据输入的课程代码输出相应学期的课程信息。可是，这样编写程序有很多冗余代码。你可以将数组信息和课程代码作为方法的参数，然后所有的处理都在方法中完成。改进后的代码如下：
AccpSchool类：
public class AccpSchool {
/**
*循环显示指定课程数组中的内容
*/
public void courseInfo(int courseCode, String[] course) {
System.out.println(“第”+courseCode+”学期的课程是：”);
for(int i = 0; i < course.length; i++) {
System.out.println(course[i]);
}
}
}
测试程序：
import java.util.Scanner;
public class Accp {
public static void main(String[] args) {
String[] s1 = {“进入软件编程世界”,”使用Java语言理解程序逻辑”};
String[] s2 = {“SQL Server数据库设计和高级查询”,”深入.NET平台”};
String[] y2 = {“用JSP开发动态网站”,“前沿技术课”};
System.out.println(“请输入学期代码(1/2/3)：”);
Scanner input = new Scanner(System.in);
int courseCode = input.nextInt();
AccpSchool school = new AccpSchool();
if (courseCode == 1) {
school.courseInfo(courseCode, s1);
}else if(couseCode == 2) {
school.courseInfo(courseCode, s2);
}else if(couseCode == 3) {
school.courseInfo(courseCode, y2);
}else{
System.out.println(“课程代码错误。”);
}
}
}
Java语言的特点
作为一种程序设计语言，Java用于许多重要的特性：简单的、面向对象的、网络的、健壮的、安全的、可移植的、高性能的等。
⒈简单易学
⒉丰富且强大的类库
Java常用包
| 包 |
说明 |
| java.util |
提供集合框架，Collection类，日期，实用工具等类 |
| java.lang |
提供利用Java编程语言进行程序设计的基础类 |
| java.io |
提供强大系统输入和输出 |
| java.sql |
提供强大的数据库操作支持 |
⒊提供强大的网络支持
附录
Java基本数据类型（Primitive Type）
| 数据类型 |
大小（位） |
范围 |
默认值 |
| byte（字节） |
8 |
-128～127 |
0 |
| short（短整型） |
16 |
-32768～32767 |
0 |
| int（整型） |
32 |
-2147483648～2147483647 |
0 |
| long（长整型） |
64 |
-9233372036854477808～92233372036854477807 |
0L |
| float（浮点型） |
32 |
-3.40292347E+38～3.40292347E+38 |
0.0f |
| double（双精度） |
64 |
-1.79769313486231570E+308～1.79769313486231570E+308 |
0.0d |
| char（字符型） |
16 |
‘\u0000~u\FFFF’ |
‘\u0000’ |
| boolean（布尔型） |
1 |
true/false |
false |
String类和StringBuffer类的常用方法
String类的常用方法
| 功能 |
方法 |
说明 |
| 字符串的长度 |
int length() |
返回此字符串的长度 |
| 字符串比较 |
boolean equals(Object anObject) |
将此字符串与指定对象比较 |
| boolean equalsIgnoreCase(String s2) |
比较两个字符串，忽略大小写形式 |
|
| int compareTo(String s2) |
按字典顺序比较两个字符串 |
|
| boolean startsWith(String pretix) |
测试此字符串是否以指定的前缀开始 |
|
| bollean endsWith(String suffix) |
测试此字符串是否以指定的后缀结束 |
|
| 搜索字符串 |
int indexOf(int ch) |
返回指定字符在此字符串中第一次出现出的索引 |
| int indexOf(String str) |
返回指定子字符在此字符串中第一次出现出的索引 |
|
| int lastIndexOf(int ch) |
返回指定字符在此字符串中最后一次出现出的索引 |
|
| int lastIndexOf(String str) |
返回指定子字符串在此字符串中最右边出现处的索引 |
|
| 提取字符串 |
char charAt(int index) |
返回指定索引处的char值 |
| String substring(int index) |
提取从位置索引开始的字符串部分 |
|
| String substring(int begin, int end) |
提取begin和end位置之间的字符串部分 |
|
|
|
String trim() |
返回一个前后不含任何空格的调用字符串的副本 |
| 连接字符串 |
String concat(String str) |
将指定字符串连接到此字符串的结尾 |
| 替代字符串 |
String replace (char old Char, char newChar) |
返回一个新的字符串，它是通过用newChar字符替换此字符串中出现的所有oldChar字符得到的 |
| 字符串大小写转换 |
String toUpperCase() |
将字符串中所有字符都转换成大写 |
| String toLowerCase() |
将字符串中所有字符都转换成小写 |
StringBuffer的常用方法
| 功能 |
方法 |
说明 |
| 长度 |
int length() |
返回StringBuffer对象的长度 |
| 类型转换 |
String toString() |
转换为String形式 |
| 替换 |
void setCharAt(int index,char ch) |
将字符串中index位置的字符串替换为ch |
| StringBuffer replace(int start,int end,String s) |
使用一个字符串s替换另一个字符串。将用s从指定位置start开始替换，直到end指定位置结束 |
|
| 追加 |
StringBuffer append(String str) |
将字符串str追加到原有StringBuffer对象结尾 |
| 删除 |
StringBuffer delete(int start,int end) |
删除调用对象中从start指定的位置开始直到end指定的位置结束 |
| StringBuffer deleteCharAt(int index) |
删除索引index位置处的字符 |
|
| 插入 |
StringBuffer insert(int offset,String s) |
在指定位置插入一个字符串s |
| 排序 |
StringBuffer reverse() |
StringBuffer对象中的字符串序列倒排序 |
