Java讲授要点(1)-基础.docx

一、Java基础
1.1特点
* 面向对象、平台无关性、分布式、可靠和安全、多线程。
* Java是一种跨平台的语言，同时也是既编译又解释的语言。Java可以运行在网络不同的计算机上，但运行的计算机上必须装有相应的Java解释器。这种解释器被称为JVM（Java 虚拟机）。

1.2 Java运行流程
(1)先应该创建源程序，Java源程序一般用java作为扩展名，是一个文本文件，用Java语言写成，可以用任何文本编辑器创建与编辑；(2)源程序完成后，就可以进行编译，需要使用Java编译器“javac”，读取源程序并翻译成Java虚拟机能够明白的指令集合，且以字节码的形式保存在文件中。通常，字节码文件以class作为扩展名；(3)Java解释器即“java”，读取字节码，取出指令并且翻译成计算机能执行的代码，完成运行过程；该字节码运行的平台是Java虚拟机。只要计算机上装有Java虚拟机，无论采用那种操作系统，硬件配置情况如何，运行的结果都是一样的

1.3 JVM
Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。
1.4 下载和安装JDK
* Java不仅是编程语言，还是一个开发平台，Java技术给程序员提供了许多工具：编译器、解释器、文档生成器和文件打包工具等等。
* SUN公司网站，或者百度“JDK 下载”，很容易下载到安装文件(1.6和1.7均可)。
* 运行jdk-…….exe文件，即可安装。
* java环境变量配置：
以WIN7 为例
右键单击计算机，然后选择属性，然后->高级系统设置>环境变量
（a）设置系统变量JAVA_HOME　
系统变量->新建->变量名：JAVA_HOME 变量值：C:\Program Files\Java\jdk1.6.0
注意：填写的是JDK的安装路径，最好复制粘贴。如果安装时选择的默认设置，JDK的安装路径很可能是C:\Program Files (x86)\java\jdk1.6.0_10，此时JAVA_HOME 变量值为C:\Program Files (x86)\java\jdk1.6.0_10

（b）设置系统变量Path　
找到系统变量Path，双击鼠标左键进入编辑状态，在变量值的最后面加上;%JAVA_HOME%\bin
（c）设置系统变量ClassPath
若原来已经有系统变量ClassPath，则直接编辑变量值，在变量值得最后面加上 ;%JAVA_HOME%\lib
若原来没有系统变量ClassPath，则选择新建系统变量，变量名为ClassPath，变量值为.;%JAVA_HOME%\lib（注意：不要少了分号前面的一点 .）

1.5 Java application和Java applet
Java语言可以编写两种类型程序，一种是Java application应用程序，一种是Java applet小应用程序（只能在www浏览器环境下运行，因此还必须建立一个HTML文件来调用Applet程序）。
一个Java application由一个或者多个class文件组成。其中有一个class定义了main()方法，该类被称为主类，即该类可以独立运行。
1.6 一个简单的java程序实例

public class Hello
{
public static void main(String [] args)
{
System.out.println("欢迎学习Java");
}
}

* 可以使用记事本来编辑，也可以使用开发工具软件，如Eclipse、JBuilder等。
* 程序以类(class)的形式存在；一个类要能被解释器直接启动运行，必须有main方法；通常把含有main方法的类称为主类。
* 源文件的名称一定要和主类的名称保持一致；
* 源文件的扩展名为java;
* Java语言区分大小写；
* 运行：（1）在MS-DOS界面下，首先进入保存了文件Hello.java的目录（比如，Hello.java文件保存在e:\java文件夹中，则在进入MS-DOS状态后，先键入e: 后回车，然后再键入cd\java后回车；（2）javac Hello.java；(3) java Hello
*System.out.println( ) 与System.out.print( )的区别。

1.7 注释
为了使编写的程序便于阅读，常常在代码中插入注释。
* 文档注释，对整个程序的功能等进行说明 /**开头，*/结束，可以跨行
* 单行注释 //
* 多行注释 /*开头，*/结束，可以跨行
例: 在上面的Hello.java程序代码中插入如下的注释，运行结果不变。

/**
* 2008 itzcn
* 版权所有
*/
public class Hello //对类进行声明
{
public static void main(String [] args)
/*下面是方法的内容，注意花括号和分号的使用*/
{
System.out.println"欢迎学习Java");
System.out.println("这是我的第一个Java程序");
}
}

注意：如果使用System.out.print，则在屏幕输出时不换行。
System.out.println("欢迎学习Java")等效于System.out.print("欢迎学习Java\n");

二、语法基础
2.1 标识符与关键字
2.1.1标识符
标识符就是一个名字。规则如下：
（1）可以是字母、下划线、美元符号或数字，长度没有限制；
（2）第一个字符不能是数字；
（3）不能是true、false、 null和被赋予特殊意义或用途的关键字（详见教材P17）。

2.1.2 关键字
特殊用途、特殊含义的50个单词

2.1.3 Unicode字符集
各种字符的编码，最多可以识别65536个字符
2.2数据类型
数据包括常量和变量。变量只有定义之后才能使用！

2.2.1 基本数据类型
Java可将数据类型分为两类，一种是面向对象的类型，而另一种则是非面向对象的基本数据类型（共8种）。在本节将详细介绍Java的基本数据类型和类型转换。
类型
关键字
占用内存
取值范围
字节型
byte
一个字节
-128 ~ 127
短整型
short
两个字节
-32768 ~ 32767
整型

int
四个字节
-2147483648 ~ 2147483647
长整型
long
八个字节
-9223372036854775808L ~ 9223372036854775807L
单精度浮点型
float
四个字节
1.4E-45 ~ 3.4028235E38
双精度浮点型
double
八个字节
4.9E-324 ~ 1.7975931348623157E308
字符型
char
两个字节
0 ~ 65535或\u0000到\uFFFF
布尔型
boolean
一个字节
true或false

（注意有4种整型，2种浮点型）

public class Type01
{
public static void main(String[] args)
{
char a='A'; /* 字符型，用单引号括起来的一个字符，Unicode集；用双引号把字符串括起来，则为string类，但已经不属于基本数据类型，而是面向对象的数据类型*/
byte b=044; //8进制
short c=0x44; //16进制
long d=0x100ffL; //长整型，后面要加L
float e=1.01f/0.3f; //含小数的数，后面加f为float型
double f=1.0/3.0; //含小数的数，默认为double型；若把0取消呢？
boolean g=true;
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
System.out.println("e="+e);
System.out.println("f="+f);
System.out.println("g="+g);
}
}
2.2.2 类型转换
用常量、变量或表达式给另一个变量赋值时，两者的数据类型必须一致，即所赋值的类型必须是能被变量接受的数据类型。如果不一致，则需要进行类型转换，即从一种数据类型转换到另一种数据类型。类型转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。

* 隐式转换：不同类型的数据混合运算时，自动按照低级类型数据转换成高级类型数据的规则进行。byte__short__int__long__float__double；char__int
例如：在double a=3.14*5中，Java会自动把5转换为double型的数据，然后和double型数据3.14进行运算；如果把3.14*5的结果保存为int型，即int a=3.14*5，则会出现损失精度的问题，这种情况下需要用到强制转换。

* 强制转换：
public class Type02
{
public static void main(String[] args)
{
int a=(int)3.14*5; //用括号加数据类型来实现强制转换
System.out.println("a="+a);
}
}

char型数据可以和65536以内的整数之间相互转化，详见教材P19例Example2_1.java

2.3变量和常量
* 变量：用字母命名（一般第一个单词的首字母为小写，第二个单词的首字母大写），必须定义之后才能使用；可以则定义的同时赋初值。如：
inta,b=3,c=4;
double d=3.14;

变量的命名规则
*常量：若要将字母或者单词（一般全部用大写字母）定义为常量，需用final来声明。

例：从键盘输入r的值，然后以此为半径的圆的面积和球的体积。

import java.util.Scanner; //导入Scanner类
class DemoCircle
{
public static void main(String[] args)
{
final double PAI=3.14159;
double r,mj,tj;
System.out.println("请从键盘上输入圆的半径：");
Scanner sc=new Scanner(System.in); //定义一个名叫sc的对象
r=sc.nextDouble(); //使用对象的方法
mj=PAI*r*r;tj=4*PAI*r*r*r/3;
System.out.println("圆的面积为："+mj);
System.out.println("圆的体积为："+tj);
}
}

*关于输入和输出，见教材P22和P23
*关于转义符，见教材P19，只要求掌握 \n ，\b和\t.
如System.out.println("欢迎学习\tJava");的输入结果是Java之前空若干格。

2.4运算符
2.4.1 算术运算符
* 自加++和自减--，特别注意运算符号在数的前面和后面的区别。

public class Ys01
{
public static void main(String args[])
{
int x=1;
int a=++x; //x先增加1，然后赋值给a
int b=x++; //x先赋值给b，然后再增加1
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("x="+x);
}
}
2.4.2关系运算符
* 返回true或false
* 等于符号是==，不等于是!=
2.4.3逻辑运算符
! && ||

例如，(3==4)||(3<4) 的结果是true
2.4.4条件运算符（了解，不作要求）
int a=10,b=23
int max=(a>b)?a:b; //满足条件为a，不满足条件为b

2.4.5 位运算符
整数型数据在计算机内存中以二进制的形式来表示。针对数据二进制表示时的位进行的运算。
位与：a&b，都是1，则结果为1，否则为0.
位或：a|b，都是0，则结果为1，否则为0.
位异或：a^b，相同，则结果为0，否则为1.

例：教材P37
public class Ys02 {
public static void main(String args[]) {
char a1='十',a2='点',a3='进',a4='攻';
char secret='A';
a1=(char)(a1^secret);
a2=(char)(a2^secret);
a3=(char)(a3^secret);
a4=(char)(a4^secret)
System.out.println("密文:"+a1+a2+a3+a4);
a1=(char)(a1^secret);
a2=(char)(a2^secret);
a3=(char)(a3^secret);
a4=(char)(a4^secret);
System.out.println("原文:"+a1+a2+a3+a4);
}
}

三、控制语句
程序控制语句分为三类：（1）条件语句(分支语句)，包括if语句和switch语句；（2）迭代语句（循环语句），包括for循环语句、while循环语句和do-while循环语句；（3）跳转语句，包括break语句、continue语句和return语句。
3.1条件语句
3.1.1 单向分支（if）
import java.util.Scanner;
public class Tj01
{
public static void main(String[] args) {
System.out.println("输入一个学生成绩：");
Scanner sc=new Scanner(System.in); //构造一个名为sc的对象，也可使用其他对象名
intiScore=sc.nextInt(); //使用对象sc的方法
if(iScore<0 || iScore>100) { System.out.print("你的输入有错误！");}
System.out.print("该学生得分为："+iScore+"谢谢使用!");
}
}

3.1.2 双向分支(if-else)
import java.util.Scanner;
public class DemoIfTj02
{
public static void main(String[] args)
{
System.out.println("输入一个学生成绩：");
Scanner sc=new Scanner(System.in);
intiScore=sc.nextInt();
if(iScore<60) {System.out.print("该学生得分为："+iScore+"不及格!");}
else {System.out.print("该学生得分为："+iScore+"及格了!");}
}
}

3.1.3嵌套
import java.util.Scanner;
public class Tj03
{
public static void main(String[] args)
{
System.out.println("输入一个学生成绩：");
Scanner sc=new Scanner(System.in);
intiScore=sc.nextInt();
if(iScore<60) {System.out.print("该学生得分为："+iScore+"不及格!");}
else{
if(iScore<75) {System.out.print("该学生得分为："+iScore+"及格!");}
else {
if(iScore<90) {System.out.print("该学生得分为："+iScore+"良好!");}
else {System.out.print("该学生得分为："+iScore+"优秀!");}
}}
}}

注意：嵌套语句写起来和读起来都比较麻烦，如果条件清楚，初学的时候可以使用组合条件。比如上例可以写为：
import java.util.Scanner;
public class Tj03
{
public static void main(String[] args)
{
System.out.println("输入一个学生成绩：");
Scanner sc=new Scanner(System.in);

int iScore=sc.nextInt();
if(iScore>=0 && iScore<60) {System.out.print("该学生得分为："+iScore+"不及格!");}
if(iScore>=60 && iScore<75) {System.out.print("该学生得分为："+iScore+"及格!");}
if(iScore>=75 && iScore<90) {System.out.print("该学生得分为："+iScore+"良好!");}
if(iScore>=90 && iScore<=100){Systemout.print("该学生得分为："+iScore+"优秀!");}
if(iScore<0 || iScore>100) {System.out.print("输入有误！");}
}}

3.1.4开关语句（switch）
详见教材P42-43
例：从键盘任意输入一个正整数，判断是否中奖（9、131、12为三等奖，209、596、27为二等奖，875、316、59为一等奖，其余整数没有奖）
import java.util.Scanner;
public class Tj04{
public static void main(String args[]) {
int number=0;
System.out.println("输入正整数(回车确定)");
Scanner reader=new Scanner(System.in);
number = reader.nextInt();
switch(number) {
case 9 :
case 131 :
case 12 : System.out.println(number+"是三等奖");
break;
case 209 :
case 596 :
case 27 : System.out.println(number+"是二等奖");
break;
case 875 :
case 316 :
case 59 : System.out.println(number+"是一等奖");
break;
default: System.out.println(number+"未中奖");
} }}

*switch( )括号中的参数常用int型和char型的，不能使用long型数据；注意break语句的作用。
* 思考：输入一个百分制的成绩，如何分级（优秀、良好、及格和不及格）？（提示：将成绩除以一个适当的数，可以缩小分支数量）
3.2 循环语句
3.2.1 for循环

例：输入一个正整数，计算出它的所有因子

import java.util.*; //调入util包中的所有类，包括了scanner类
public class Xh01
{
public static void main(String[] args)
{
System.out.println("输入一个数:");
Scanner scan=new Scanner(System.in);
int a=scan.nextInt();
System.out.print(a+"的所有因子是："); //注意print和println的区别
/*下面是循环体*/
for (inti=1;iring[] args){
int n=0,sum=0;
Scanner sc=new Scanner(System.in);
System.out.print("请输入一个自然数:");
int number=sc.nextInt();
while (n<=number) { sum=sum+n;n=n+1; }
System.out.println("sum="+sum);
}}

*注意在循环体中加入改变条件的语句，否则会造成死循环（如果出现，要终止使用ctrl+c）.
3.3跳转语句
* break :跳出所在的块，并从紧跟该块的第一条语句处执行（在开关语句中已经应用）。
* continue: 跳过循环体中尚未执行的语句，接着进行终止条件的判断，决定是否继续循环。
* return: 从当前方法中退出，返回调用该方法的语句处，通常用在方法体的最后（具体应用见后面的面向对象部分）。

教材P46例
public class E3_7 {
public static void main(String args[]) {
int sum=0,i,j;
for( i=1;i<=10;i++) {
if(i%2==0) { //计算1+3+5+7+9
continue;
}
sum=sum+i;
}
System.out.println("sum="+sum);
for(j=2;j<=50;j++) { //求50以内的素数
for( i=2;i<=j/2;i++) {
if(j%i==0)
break;
}
if(i>j/2) {
System.out.println(""+j+"是素数");
}
} }}

3.4 编程举例
* 对于财经类专业的同学而言，应该扎实地掌握三种结构的程序设计（顺序、分支和循环），以便在以后的能够编写简单的程序来处理工作中的问题（例如数据的处理和计算）。

例1：求一元二次方程的根。
import java.util.Scanner;
import java.lang.Math.*; //调入Math类，求平方根用sqrt()方法。
public class L1
{public static void main(String[] args)
{float a=0,b=0,c=0,d=0 x1=0, x2=0;
System.out.println("请输入一元二次方程的三个系数，数与数之间用空格分隔。");
Scanner scanner=new Scanner(System.in);
a=scanner.nextFloat();b=scanner.nextFloat();c=scanner.nextFloat();
d=b*b-4*a*c;
if (d>0)
{x1=(float)(-b+Math.sqrt(d))/(2*a);x2=(float)(-b-Math.sqrt(d))/(2*a);
System.out.println("x1=["+x1+"] x2=["+x2+"]");}
else
{if (d==0)
{x1=(float)(-b)/(2*a);
System.out.println("x1=x2="+x1);}
else
{System.out.println("此方程在实数范围内无解！");}}}}

例2：输出九九乘法表

public class L2
{
public static void main(String[] args)
{
for(int first=1;first<10;first++)
{
for(int second=1;second<=first;second++)
{System.out.print(first+"x"+second+"="+(first*second)+"\t");}
System.out.println();
}
}
}
解释：（1）使用到了双重循环（即循环中又套了一个循环）；（2）System.out.print("\t")的作用相当于键入一个Tab键，在屏幕上输出连续的空格（见教材P13表2-2）；（3）最后一条语句System.out.println的作用是产生换行，也可以使用System.out.print("\n")。

例3：解任意方程。
柯布—道格拉斯生产函数是经济学中使用最广泛的一种生产函数形式。

其中Q为产出，L为劳动力投入，K为资本投入，α 是劳动力产出的弹性系数，β是资本产出的弹性系数。如果α=0.4，β=0.6，L=100，计算Q=200时所需的资本投入。即要求解方程。
求解：根据数学常识，K值应该大于零，于是可以编程求解。
import java.lang.Math.*; //可以省略，因为lang包会被自动调入
public class L3
{
public static void main(String[] args)
{
double a=0.4,b=0.6,l=100,k=0,q=0; //让k的初值为零，然后在后面的循环中逐渐增加
while (Math.abs(q-200)>=0.01) //Math.abs ()为求绝对值，后面的0.01为设置的精度
{
q=Math.pow(l,a)*Math.pow(k,b); //Math.pow ()为求幂函数值
k=k+0.01;
}
System.out.println("k="+k);
}
}
注意：（1）本例中求解方程的根时没有考虑更高效的算法，而是在整个可能的取值范围内逐一搜寻；如果要考虑求解的效率，则可以使用共轭法等算法；（2）将弹性系数和L变为从键盘输入，则可以将该例变为更通用的程序，当然还得改变搜寻范围（即改变循环的起始值和终止值）。

例4. 输入任意整数，求1/1！+1/2！+1/3！+......+1/n!数列的前n项之和。

importjava.util.Scanner;
classL4{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
double sum=0.0;
for (inti=1;i<=n;i++){
doublejc=1.0;
for (int j=1;j<=i;j++){jc=jc*j;}
sum=sum+1/jc;
}
System.out.println("sum="+sum);
} }

例5.质数问题
（1）任意输入一个正整数，然后输出该整数的所有因子；
（2）任意输入一个正整数，然后判断其是否是质数。

（1）
importjava.util.Scanner;
public class Zs01 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入任意一个整数:");
int n=sc.nextInt();
System.out.println(n+"的所有因子是：");
for (inti=1;i<=n;i++){
if(n%i==0){System.out.print(i+" ");}
}
}}
（2）
importjava.util.Scanner;
public class Zs02 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个正整数：");
int a=sc.nextInt();

int k=0;
for (int j=1;jmain(String[] args) {
inti,j;
for(i=1;i<=6;i++){
for(j=1;j<=i;j++){System.out.print("*");}
System.out.println(); }

}}

3.5数组
1. 一维数组的创建和初始化
（1）在创建的同时初始化
例int a[]={3,6,4};
即定义了a[0]=3,a[1]=6,a[2]=4
注意：数组标号从0开始。
（2）在创建之后初始化
如：double a[]=new double[3]; //声明一个数组变量并且申请内存空间,a和[]可交换顺序
a[0]=3.1;a[1]=5.2;a[2]=2.7; //数组的初始化

例1：
public class DemoArray1 {
public static void main(String[] args) {
int[] a=new int[10];
for (inti=0; iil.Scanner;
public class DemoArray2 {
public static void main(String[] args) {
int[] a=new int[10];
Scanner sc=new Scanner(System.in);
for (inti=1; i<=10; i++)
{
System.out.print("请输入第"+i+"个整数:");
int j=i-1;
a[j]=sc.nextInt();
System.out.println();//输出空白的一行，仅仅是为了让屏幕输出美观一些
}
int max=a[0];
for (int k=0; kmax)
{max=a[k];}
}
System.out.println();
System.out.println("max="+max);
System.out.println();}}

思考：要将这10个数从大到小进行排序呢？
3.6字符串（String类）
教材：P176
char类型只能表示单个字符，不能满足需要。在处理字符串时，可以使用String 类。
1. 创建String对象
如创建一个值为abc的字符串对象s，代码为：
String s=new String("abc");
也可以简单地写为
String s="abc";
2. 字符串对象的常用方法（教材P177）
length()、equals()、indexOf()、substring()
注意：使用String类时，不必像Scanner类那样要定义对象实例，可直接使用。
例1：public class Zfc01{
public static void main(String [] args){
int index=-1,length=0,n=0;
String str="我喜欢西南财经大学的校园";
i