JAVA语言程序设计资料张渐Word文档格式.docx
- 文档编号:19002368
- 上传时间:2023-01-02
- 格式:DOCX
- 页数:21
- 大小:25.62KB
JAVA语言程序设计资料张渐Word文档格式.docx
《JAVA语言程序设计资料张渐Word文档格式.docx》由会员分享,可在线阅读,更多相关《JAVA语言程序设计资料张渐Word文档格式.docx(21页珍藏版)》请在冰豆网上搜索。
”,50,100);
}
小应用程序是由浏览器运行的,所以必须借助一个网页文档运行小应用程序,内容如下:
<
appletcode=A.classwidth=300height=200>
/applet>
Java源程序的命名规则:
若源程序中有(且仅有)一个公有(publicclass)类,源程序的名字只能是这个类的名字加扩展名java
若源程序中没有公有类,源程序的名字可以任意,但一般是选某一类名为文件名,扩展名java
应用程序中可以没有公有类,但一个小应用程序的主类一定是公有的。
关系运算:
>
=<
<
===!
=
判断两个相同的量之前的大小关系,结果是逻辑值,true/false
数学中,100>
x>
60式应如何表示?
也就是如何判断x是在100至60之间。
If(100>
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&
=0)||year%400==0)
System.out.println(year+"
年是闰年。
"
);
else
年不是闰年。
}
循环结构:
程序中的循环结构用三种语句表达:
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;
for(inti=0,sum=0;
i<
=100;
i++)sum=sum+i;
三种循环语句,都可以实现循环,三种循环可相互化。
不存在某个问题必须用某循环。
当然,一般来说,for循环适合于循环次数已知的情况,而while与do-while适合循环次数未知的情况。
例:
求若干个正整数之和。
{inti,sum=0;
Scannersc=newScanner(System.in);
i=sc.nextInt();
//读第一个数
while(i>
0)
{sum=sum+i;
//读下一个数
System.out.println(sum);
长江中的鱼每年以0.13%的速度减少,问多少年后减少到不足今天的一半。
doubletoday=1.0,nextyear;
intyear=0;
nextyear=today;
while(nextyear<
today*0.5)
{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;
x;
i++)
if(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;
if(x%i==0)returnfalse;
returntrue;
如何设计函数。
函数由两部分构成,
首部(声明部分),说明函数的名字,参数,返回值。
函数可以比喻为加工厂,有名字,需要原料(参数),产品(返回值)。
而这部分该如何设计,不仅仅是语法的问题,更重要决于问题本身。
返回值类型名字(参数表)
如:
在两个整数中求较大者。
intgetMax(inta,intb)
又如:
判断一个整数是否为质数。
booleanisPrime(inta)
例三:
将一个实数开方
doublemySqrt(doublex)
例四:
输出类成员变量的值。
voidprint()
函数体
voidprint(){函数体}
函数体是一个函数的主体,主要是解决如何将参数加工为返回值。
在函数体中,可以认为函数的参数是已知的。
除了返回值类型是void一种情况之外,其他情况下都要用return将结果返回。
{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是整数类型,它本身并不能存放整数,必须用它创建一个变量,只有变量才有空间,才能存放数据。
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修饰的函数
实例成员函数:
静态成员与非静态成员行为上有区别:
首先谈变量:
静态变量,可以直接用类名访问
静态变量是各类共用
然后谈函数:
静态函数,可以直接用类名访问
它所访问的类成员也必须是静态的。
静态成员的引入意味着即使不创建类的对象,也有可能访问类成员。
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例外,又称为异常。
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(导入,引入)
任何类只有正确地引入后才可以使用,但经常使用,使用频率最高的类System.String这样的类,声明在java.lang包中,而这个包在任何java程序中都是缺省导入。
容错。
java中对于异常可以采用异常机制,对异常捕捉并处理。
用:
try{被监视的代码}
catch()
{异常处理。
这时,运行这段程序可能有两种结果。
一是“被监视的代码”执行无没异常,程序正常输出结果。
仿佛catch(){}没写一样。
二是“被监视的代码”执行产生的了异常,就会被catch去执行”异常处理”代码。
异常处理程序编写要求程序员要有预见性、针对性。
Java中的异常,实际上是类的对象。
每个类针对一种异常。
各种异常类之前有派生关系。
所有的异常类的父类(基类)是Exception,用它可以捕捉任何异常。
可视化程序设计:
可视化程序设计,也就是图形用户界面。
窗口设计。
Java提供了一个窗口类JFrame,它是一个容器,其中可以容纳各种如菜单,按钮这样的组件.这样,一个JFrame对象,或其派生类的对象,就是一个窗口。
importjavax.swing.JFrame;
classMyFrame
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类的子类,再创建其对象。
classMyFrameextendsJFrame
MyFrame()
{super("
这是一个窗口演示程序"
//sumper()
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- JAVA语言程序设计资料 张渐 JAVA 语言程序设计 资料