JAVA语言程序设计资料张渐.docx
《JAVA语言程序设计资料张渐.docx》由会员分享，可在线阅读，更多相关《JAVA语言程序设计资料张渐.docx（21页珍藏版）》请在冰豆网上搜索。
JAVA语言程序设计资料张渐
JAVA语言程序设计资料张渐
Java语言是一种面向对象的语言，因此它具有面向对象程序设计的三个特点：
封装，继承，多态性。
此外，Java还有一个最大的特点就是它的跨平台特征。
Java的源程序可以不加修改就运行在不同的操作系统中（如windows和linux）
Java语言程序的运行过程。
Java程序从产生，到运行经过几个环节：
编辑源程序（输入），得到源程序必须以.java为扩展名的文档。
编译源程序（翻译），得到扩展名为.class的二进制代码文件。
（伪编译）
解释并运行程序。
说明：
java语言是一种解释型语言。
不同于编译型语言，编译型语言翻译后产生.exe文件，它本身就可以运行。
Java源程序编译后的成果是.class，它本身不能运行，必须由java的解释器去解释并运行程序。
在正确安装了java的机器上的j2sdk/bin中，可以看到常用的两个程序：
Javac：
它就是java程序的翻译器,（javacompile）
Java：
它是java的解释器，用它运行程序。
Java源程序中每个类class都会编译成一个.class文件。
Java程序分成两种类型：
应用程序与小应用程序，两类程序在运行方法上和程序结构上都不同。
运行方法：
编辑源程序-------编译-----------java命令解释执行（应用程序）
A.java.class|
---------浏览器执行（小应用程序）
最简单的java程序。
classA{}
最简的可运行的java程序.
classA{
publicstaticvoidmain（String[]arg）
{}}
可见，一个可运行的java程序的条件是必须有一个main函数。
在各种程序语言中，空格与换行的设置不影响程序。
简单的带输出信息的java程序：
classA{
publicstaticvoidmain（String[]arg）
{System.out.println（“Hello,Java！
！
！
”）;
}}
注意程序中的所有标点符号都应该是半角英文符号。
以上程序都是应用程序，以下只给出一个小应用程序的例子：
importjava.awt.*;
importjava.applet.*;
publicclassAextendsApplet
{
publicvoidpaint（Graphicsg）
{g.drawString（“HelloJava!
!
!
”，50，100）；
}
}
小应用程序是由浏览器运行的，所以必须借助一个网页文档运行小应用程序，内容如下：
Java源程序的命名规则:
若源程序中有（且仅有）一个公有（publicclass）类，源程序的名字只能是这个类的名字加扩展名java
若源程序中没有公有类，源程序的名字可以任意，但一般是选某一类名为文件名,扩展名java
应用程序中可以没有公有类，但一个小应用程序的主类一定是公有的。
关系运算：
>>=<<===!
=
判断两个相同的量之前的大小关系，结果是逻辑值,true/false
数学中，100>x>60式应如何表示？
也就是如何判断x是在100至60之间。
If（100>x>60）这是错误的。
If（x<100&&x>60）
此式在C中免强可以通过语法检查，但并不能达到判断目的。
正确的方法是：
if（x<100｜｜x>60）如果x<100“并且”x>60
所以两个以上的判断组合作用，需要用到逻辑运算。
逻辑运算有三种：
&&逻辑与，表达现实中的“并且”含义。
｜｜逻辑或，表达现实中的“或者”含义。
！
逻辑非，表达现实中的“否定”含义。
，结果是逻辑值,true/false
求闰年：
当年号能被4整除，且不能被100整除，
或者年号能被400整除。
Year表公元年号
if（（year%4＝＝0&&year%100!
=0）||year%400==0）是闰年
Else不是闰年。
importjava.util.Scanner;
classRen_Year
{
publicstaticvoidmain（String[]s）
{intyear;
Scannerscan=newScanner（System.in）;
year=scan.nextInt（）;
if（（year%4==0&&year%100!
=0）||year%400==0）
System.out.println（year+"年是闰年。
"）;
else
System.out.println（year+"年不是闰年。
"）;
}
}
循环结构：
程序中的循环结构用三种语句表达：
whiledo-whilefor
while循环：
写法：
while（条件）
循环体
条件，就是上述关系或逻辑表达式，也就是说凡是能得到true/false结果的式子。
循环体，就是需要反复执行的一条（一段语句，这时需要{}括起来）
例。
0+1+2+3+4+.。
。
。
。
。
+100
inti=1，sum=0;
while（i<=100）
{sum=sum+i;
i++;//i=i+1;
}
可见，while循环判断条件，成立时，执行循环体，若不成立，结束循环。
do-while循环：
do
循环体
while（条件）；
先执行循环体，然后判断条件决定是否继续循环。
是，再执行循环体，否则，停止循环。
while与do-while两种结构的循环的区别：
while是先判断条件，后执行循环体；do-while是先执行循环体，后判断条件。
也就是说，do-while循环的循环体是至少要被执行一次，而while循环则不一定。
当循环体会被执行多次时，两个方法相同。
for循环：
写法：
for（初始化部分；条件判断；循环变化量）循环体
初始化部分：
循环开始之前执行，且只执行一次。
条件判断：
每次循环之前执行，条件真时执行循环体，条件假时，停止循环。
循环变化量：
每次执行循环体之后执行的。
例如，控制循环体执行100次：
inti=1，sum=0;
while（i<=100）
{sum=sum+i;
i++;
}
for（inti=0，sum=0；i<=100；i++）sum=sum+i;
三种循环语句，都可以实现循环，三种循环可相互化。
不存在某个问题必须用某循环。
当然，一般来说，for循环适合于循环次数已知的情况，而while与do-while适合循环次数未知的情况。
例：
求若干个正整数之和。
importjava.util.Scanner;
classRen_Year
{
publicstaticvoidmain（String[]s）
{inti,sum=0;
Scannersc=newScanner（System.in）;
i=sc.nextInt（）;//读第一个数
while（i>0）
{sum=sum+i;
i=sc.nextInt（）;//读下一个数
}
System.out.println（sum）;
}
}
长江中的鱼每年以0.13%的速度减少，问多少年后减少到不足今天的一半。
doubletoday=1.0,nextyear;
intyear=0;
nextyear=today;
while（nextyear{nextyear=nextyear*（1-0.0013）;
year++;}
System.out.println（year）;
x
函数程序设计：
函数是具有一定功能的，独立的程序段。
将程序设计为函数模块的好处：
可以将一个需要用程序解决的复杂的问题，分解为若干相对简单的问题，而这些简单的问题容易把握。
在Java中，所有的函数都应该设计在类的内部，称为成员函数，或称方法。
程序中的函数分为两类：
1.系统函数：
由某语言本身已经提供的函数，在程序中直接调用（使用），只要了解如下三部分问题，就可以正确使用系统函数：
函数来自何包？
参数如何给出？
函数值（结果）是何类型？
如sin函数，定义在Math类中，参数是实数（以弧度为单位），值是实数。
如是，求正弦30度的方法：
Math.sin（30*Math.PI/180）;
2.自定义函数：
必须由程序员自己设计的函数。
设计完成之后，调用方法与系统函数一致。
为什么要设计函数？
原因之一是系统函数不可能穷尽所有的应用问题，有些问题必须由程序员通过一定的算法求解。
原因之二是函数可以将一个较复杂的庞大的问题分解为较小的，较简单容易解决的问题。
第二原因是重点。
函数是程序中功能相对独立的程序段。
函数程序的设计分两部分：
函数的定义，函数的调用。
函数的定义：
说明函数做何事，如何做。
程序中解决4个问题：
函数名，参数，函数值类型，函数体。
函数值类型函数名（参数表）
{
函数体
}
函数值类型函数名（参数表）―――原型。
原型是由任务本身决定。
如：
在两整数中求较大值。
intgetMax（intx,inty）
任意给定一个数，判定该数是否质数。
什么是质数？
只能被1和自身整除的数。
给定任何整数x，可以用2－x-1中的各数对x做除法，若它们都不能整除x，则x是质数，否则，只要有至少一个数整除了x，x非质数。
intx=537,i;
for（i=2;iif（x%i==0）不是
是
求出3-1000之间的质数。
publicclassJudgePrime{
publicstaticvoidmain（String[]args）
{
for（intx=3;x<=1000;x++）
{
if（isPrime（x））System.out.println（x+"是质数"）;
}
}
staticbooleanisPrime（intx）
{
for（inti=2;iif（x%i==0）returnfalse;
returntrue;
}
}
如何设计函数。
函数由两部分构成，
首部（声明部分）,说明函数的名字，参数，返回值。
函数可以比喻为加工厂，有名字，需要原料（参数）,产品（返回值）。
而这部分该如何设计，不仅仅是语法的问题，更重要决于问题本身。
返回值类型名字（参数表）
如：
在两个整数中求较大者。
intgetMax（inta,intb）
又如：
判断一个整数是否为质数。
booleanisPrime（inta）
例三：
将一个实数开方
doublemySqrt（doublex）
例四：
输出类成员变量的值。
voidprint（）
函数体
voidprint（）{函数体}
函数体是一个函数的主体，主要是解决如何将参数加工为返回值。
在函数体中，可以认为函数的参数是已知的。
除了返回值类型是void一种情况之外，其他情况下都要用return将结果返回。
如：
在两个整数中求较大者。
intgetMax（inta,intb）
{if（a>b）returna;
elsereturnb;
}
函数设计完成后，就可以对函数进行调用，也就是使用函数。
函数名（实际参数表）
实际参数表要给出实际的数据，对函数的调用时，要注意与函数的首部对应：
名称相同，形式参数与实际参数个数相等且类型一致，返回值正确使用。
对函数的使用时否正确，考察函数的返回值类型。
intgetMax（inta,intb）返回值是整数，那么可以将对该函数的调用式子理解为一个整数。
Intz=getMax（x,y）；
Z=getMax（x,y）
Z=23+getMax（x,y）;
System.out.println（getMax（x,y））;
Z=getMax（getMax（a,b）,getMax（c,d））;
返回值为void的函数，只能作为一条语句存在。
voidprint（）{……………}
只能print（）;
不能intz=print（）;
doublez=print（）;
但：
intgetMax（inta,intb）
使用getMax（x,y）;语法上也正确，但可能没意义。
类的设计：
语法上，类的设计应该遵守如下格式：
[public]class类名
{
Stringname;
intage;
voidfun（）{}
intgetAge（）{returnage;}
}
类体所描述的是类的内容。
类（型）的作用是一类事物的抽象描述。
类中可以定义两大部分内容：
变量与函数。
在类中（各函数之外）声明的变量称为类的成员变量（区别于定义在函数中的局部变量）,局部变量只在定义它的函数内起作用，而类的成员变量，可以在类中的各函数中起作用。
类中声明的函数叫做类的成员函数。
实际上，任何函数都必须声明在类内部。
类是对事物的描述，类中的成员变量部分描述事物的属性（数据），成员函数部分描述事物的行为（动作）。
classPerson
{
//成员变量定义
StringID;//身份证号
Stringname;
intage;
//成员函数
publicvoidshowMe（）
{System.out.println（“我叫”+name+”,今年”+age+“岁.”）;}
publicvoidsetData（Stringid,Stringna,inta）
{ID=id;name=na;age=a;
}
}
如何使用类。
存取类的成员变量
调用类的成员函数
又分成两种不同的情况：
在类内部使用
在其他类使用
在其他类中使用已经定义好的类。
可以用已定义好的类创建对象。
类――类型（框架）
正于int是整数类型，它本身并不能存放整数，必须用它创建一个变量，只有变量才有空间，才能存放数据。
intage;
age=90;
显然int＝90是错误的。
我们设计好的类，如Person，正是如int一样的类型。
Person本身并不能表示一个人，必须用它创建对象后，这个对象才能表示一个人。
用类所创建的变量，叫对象。
对象的使用分两步：
对象声明，对象的创建
inta;
a=30;
Personzhangsan;
以上语句声明了一个对象，而创建对象必须用下面的语句：
对象名＝new类名（）;
如：
zhangsan=newPerson（）;
强调：
通过对象使用类与简单变不同
比较：
简单变量：
声明：
inta;
使用:
a=45;
类：
声明Personp1;
创建p1=newPerson（）;
使用p1.showMe（）;
通过对象使用类：
在类外部调用对象的成员函数：
对象名.函数名（参数）
对比，在类内部调用类的成员函数。
函数名（参数）
如果我们用直接赋值方式或调用类的普通函数为对象提供数据，可能有两种错误的行为：
未提供数据，这时对象中的数据未被提供
多次提供数据，对象代表的数据重定义
如何强制地要求对一个对象提供值，且又仅仅提供一次？
在面向对象的程序设计中，为类提供了一种叫构造函数的机制。
构造函数是类中一组特殊的成员函数，它与普通的成员函数的区别是：
与类同名
不得有任何返回值定义
构造函数的作用：
它是在对象被创建（new）时，由机器自动调用（不是在程序中用语句调用，从而避免了“未提供数据，这时对象中的数据未被提供”），同时在对象的生存周期中，只被调用一次（避免了“多次提供数据，对象代表的数据重定义”）。
构造函数可以重载，也就是说类中可以有多个同名构造函数，只要这些函数在参数的个数上，或类型上能足以区各函数即可。
类的其他函数也可以重载。
类成员访问权限：
指类的成员可以被哪些程序访问的一种限定。
常用的权限有三种：
目前，在程序中相对某个成员而言，访问它的类有两种，一是它所属的类，其他类。
public：
公有，指这类成员可以被任何程序访问
private：
私有，这类成员只能被类自身访问，不允许其他类访问。
缺省权限：
当类成员未显式设置任何访问权限时，便是缺省权限，又称为友好权限。
两类若属于同一包时，它们可以互访对方的友好权限。
否则不可。
什么是同一包？
同一文件夹，若两个类写在同一个程序中，肯定是同一包。
为何需要设置类成员的访问权限？
数据封装是面向对象程序设计的优越性之一。
通常的做法是，将类的成员定义为私有，不被外部访问，达到保护类中的数据的目的。
但一个成员如果绝对地不被外部访问也就失去定义的意义。
所以为了访问私有成员，可以针对它们定义一些公有函数，以被外部间接访问。
静态成员（static）与非静态成员
静态成员又叫类成员，用static修饰
非静态成员又叫实例成员，未用static修饰。
这里所说的成员包括成员变量和成员函数。
所以：
类成员变量：
用static修饰的变量
实例成员变量：
未用static修饰
类成员函数：
用static修饰的函数
实例成员函数：
未用static修饰
静态成员与非静态成员行为上有区别：
首先谈变量：
静态变量，可以直接用类名访问
静态变量是各类共用
然后谈函数：
静态函数，可以直接用类名访问
它所访问的类成员也必须是静态的。
静态成员的引入意味着即使不创建类的对象，也有可能访问类成员。
Java中的数组
若干同名变量的集合。
intx1,x2,x3;100个变量怎么办？
intx1,x2,………….x100;这样肯定是不现实的。
引入数组工具：
引入数组需要三步：
声明：
inta[];/int[]a;说明a是一个数组，数组中的元素是int数据。
创建：
a=newint[100];为a数组创建100个变量
只有完成以上两步，这个数组才可以使用。
以上两步也可以合并成一步：
同时声明并创建数组：
int[]a=newint[100];
使用数组：
对数组元素，不能整体使用它，只能使用其中的各元素。
a[下标]
可以表示一个变量。
a[0]表示第0个变量（最开始的）
a[9]表示第9个变量。
a[x]表示第x个变量。
一个数组最开始的变量，下标是0
int[]a=newint[30];
声明的是a[0],a[1]…..a[99]
数组的访问不能超界。
如a[100]=1
就是错误的。
a．length可以得到数组长度
遍访数组的各元素，常常需要用循环。
数组初始化：
在声明和创建数组时，给数组元素赋以初值。
整型变量初始化inta=9;
数组初始化：
int[]a={7,9,3,-1,0,4,2};
初始化语句同时完成了三项工作：
声明，创建数组，为数组元素提供了值。
这里，数组的长度是初始化数据的个数。
Java异常处理机制
异常：
Java程序中的运行错误称为异常。
也就是说，java程序在语法上正确，但运行时出现运行错误（而不是说结果不正确）
Exception例外，又称为异常。
importjava.util.Scanner;
publicclassExample{
publicstaticvoidmain（String[]args）{
intx,y;
Scannerscan=newScanner（System.in）;
x=scan.nextInt（）;y=scan.nextInt（）;
System.out.println（x+"/"+y+"="+x/y）;
}
}
在Java中，尤其是在jdk1.5版之前，从键盘上入数据，是较困难。
从jdk1.5版之后，增加了一个类Scanner（扫描器）用于从键盘上输入数据。
Scanner是一个类，所以先创建对象：
Scannerscan=newScanner（System.in）;
System.in表示标准输入设备（键盘）
Scanner类中提供各种类型数据的输入函数。
如果输入整数可用：
nextInt（）
Scanner是个类，但它来自于哪里？
类的出处必须在程序中说明，用import（导入，引入）
importjava.util.Scanner;
任何类只有正确地引入后才可以使用，但经常使用，使用频率最高的类System.String这样的类，声明在java.lang包中，而这个包在任何java程序中都是缺省导入。
容错。
java中对于异常可以采用异常机制，对异常捕捉并处理。
用：
try{被监视的代码}
catch（）
{异常处理。
}
这时，运行这段程序可能有两种结果。
一是“被监视的代码”执行无没异常，程序正常输出结果。
仿佛catch（）{}没写一样。
二是“被监视的代码”执行产生的了异常，就会被catch去执行”异常处理”代码。
异常处理程序编写要求程序员要有预见性、针对性。
Java中的异常，实际上是类的对象。
每个类针对一种异常。
各种异常类之前有派生关系。
所有的异常类的父类（基类）是Exception,用它可以捕捉任何异常。
可视化程序设计：
可视化程序设计，也就是图形用户界面。
窗口设计。
Java提供了一个窗口类JFrame,它是一个容器，其中可以容纳各种如菜单，按钮这样的组件.这样，一个JFrame对象，或其派生类的对象，就是一个窗口。
importjavax.swing.JFrame;
classMyFrame
{
publicstaticvoidmain（String[]arg）
{
JFrameframe=newJFrame（）;
frame.setVisible（true）;
frame.setBounds（200,200,400,200）;
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）;
}
}
这个程序中，我们创建的是JFrame对象，而JFrame是Java的类。
所以我们无法向JFrame中添加变量和函数。
所以有很多局限。
想象JFrame应该有至少两个构造函数
JFrame（）;
JFrame（Stringtitle）;
所以通常程序中采用第二种方法，那就是派生JFrame类的子类，再创建其对象。
importjavax.swing.JFrame;
classMyFrameextendsJFrame
{
MyFrame（）
{super（"这是一个窗口演示程序"）;
//sumper（）
升级会员 