第一篇：Java程序设计报告
楚雄师范学院
2015年春季期末Java程序设计报告
项目名称：基于Java平台开发的五子棋程序设计
学 院： 物理与电子科学学院
专 业：电子信息科学与技术
班 级：2 0 1 3 级 电 信 一 班
组员姓名：杨邦桂 许勇 董俊宏 课程教师： 程 满
目录
引言...........................................................................................................................................4 第一章 设计目的和要求.........................................................................................................4 第二章JAVA语言概述.........................................................................................................4 2.1 JAVA简介........................................................................................................................4 2.1.1 JAVA的基本特点.....................................................................................................4 2.2 JAVA工具
JDK............................................................................................................5 第三章 程序的设计思路和算法.............................................................................................5 3.1 人机博弈的要点............................................................................................................5 3.2 五子棋特点及规则......................................................................................................5 3.3 设计思路......................................................................................................................6 3.3.1...................................................................................................................................6 第四章 测试及运行效果.........................................................................................................6 4.1棋盘系统主界面.............................................................................................................6 4.2下期博弈过程界面.........................................................................................................7 4.3黑方赢的结果.................................................................................................................7 4.4白方赢的结果.................................................................................................................8 第五章 设计体会与总结.........................................................................................................9 附录.........................................................................................................................................10 源程序代码及简要说明：.................................................................................................10
引言
随着计算机技术的不断发展，网络技术的普及范围越来越广，网络能够提供的服务多样、便捷，已经成为人们生产生活中不可缺少的重要组成部分。如今网络休闲游戏发展迅速，它凭借健康、方便、互动性强、益智等诸多优点，成为大部分现代人休闲娱乐的首选。
网络五子棋游戏是使用Java语言开发的一款游戏。它使用SOCKET建立连接，多线程处理数据，以及可嵌入网络浏览器的APPLET作为客户端，这些特点使这款游戏无论是服务器还是客户端的实现都相对容易。通过对该软件的编写，还可以巩固学生对以上各种知识的掌握和理解。
第一章 设计目的和要求
1.1 实现一个简单的五子棋游戏程序，包括如下两个界面:（1）对弈及角色（黑方先落棋）。
（2）在游戏界面，有游戏栏（开局、悔棋、退出），帮助栏； 显示区；棋盘区。1.2在实际系统中使用、实现人工智能的相关算法
1.3进一步加深对人工智能算法的理解
第二章JAVA语言概述
2.1 JAVA简介
JAVA是Sun Microsystem公司开发的编程语言，是一个简单，面向对象，分布式，解释性，强壮，安全，与系统无关，可移植，高性能，多线程和动态的语言。
2.1.1 JAVA的基本特点
(1)简单性
Java与C++语言非常相近，但Java比C++简单，它抛弃了C++中的一些不是绝对必要的功能，如头文件、预处理文件、指针、结构、运算符重载、多重继承以及自动强迫同型。Java实现了自动的垃圾收集，简化了内存管理的工作。
(2)面向对象
Java提供了简单的类机制和动态的构架模型。对象中封装了它的状态变量和方法，很好地实现了模块化和信息隐藏；而类则提供了一类对象的原型，通过继承和重载机制，子类可以使用或重新定义父类或超类所提供的方法，从而既实现了代码的复用，又提供了一种动态的解决方案。
(3)多线程
多线程使应用程序可以同时进行不同的操作，处理不同的事件。在多线程机制中，不同的线程处理不同的任务，他们之间互不干涉，不会由于一处等待影响其他部分，这样容易实现网络上的实时交互操作。
(4)分布性
Java是面向网络的语言。通过它提供的类库可以处理TCP/IP协议，用户可以通过URL地址在网络上很方便的访问其他对象。（5）体系结构中立
Java是一种网络语言，为使Java程序能在网络的任何地方运行，Java解释器生成与体系结构无关的字节码结构的文件格式。为了使Java的应用程序能不依赖于具体的系统，Java语言环境还提供了用于访问底层操作系统功能的类组成的包，当程序使用这些包时，可以确保它能运行在各种支持Java的平台上。
(6)安全性
用于网络、分布环境下的Java必须要防止病毒的入侵，Java不支持指针，一切对内存的访问都必须通过对象的实例变量来实现，这样就防止了程序员使用欺骗手段访问对象的私有成员，同时也避免了指针操作中容易产生的错误。
2.2 JAVA工具
JDK
（1）Java编译器
Java编译器将Java源代码文件编译成可执行的Java字节码。Java源代码文件的扩展名为.java，Java编译器把这种扩展名的文件编译成扩展名为.class的文件。源文件中的每个类在编译后都将产生一个class文件，这意味一个Java源代码文件可能编译生成多个class文件。
（2）Java解释器
Java解释器对编译生成的字节码格式的可执行程序的运行提供支持，它是运行非图形Java程序的命令行工具。
第三章 程序的设计思路和算法
3.1 人机博弈的要点
人机对弈的程序，至少应具备以下5个部分：
(1)某种在机器中表示棋局的方法，能够让程序知道博弈的状态。(2)产生合法走法的规则，以使博弈公正地进行，并可判断人类对手是否乱走。(3)从所有合法的走法中选择最佳的走法技术。(4)一种评估局面优劣的方法，用以同上面的技术配合做出智能的选择。(5)一个界面，有了他，这个程序才能用。
3.2 五子棋特点及规则
五子棋的娱乐性强、规则简单、易学、流行性广。普通人不需长时间专门训练即可自如行棋。因此极受大众欢迎。五子棋的规则为：
(1)棋盘
采用像围棋盘一样的15路或19路线的棋盘，在此采用19路的棋盘。
(2)下法
两人分别执黑白两色棋子。轮流在棋盘上选择一个无子的交叉点落子，无子的交叉点又被称为空点。
(3)输赢判断
黑、白双方有一方的五个棋子在横、竖或斜方向上连接成一线即为该方赢。
(4)特殊规定
职业五子棋虽然对黑棋采取了种种限制，但黑子先行的优势依然很大。因此，在高段位的职业比赛中，又出现了三种特殊的规定。
a.指定打法：是指比赛双方按照约定好的开局进行对弈，由白棋先行。
b.三手可交换：是指黑棋下盘面第3手棋后，白方在下第四手之前，如感觉黑方棋形不利于己方，可提出交换，即执白棋一方变为执黑棋一方，而黑方不可以不换。
c.五手两打法：是指黑棋在下盘面上关键的第5手棋时，必须下两步棋，让白棋在这两步棋中拿掉一粒棋子，然后再继续对弈。一般说来，白棋肯定拿掉对白方不利的一点，而保留对黑方较为不利的那点让黑方行棋。3.3 设计思路
3.3.1开始——下棋——判断输赢——结束游戏或重新再来——退出。
1.建立一个棋盘类，绘制棋盘的样式，在棋盘面板上添加各种按钮及相应胡触发事件。同时注意面板的设计，使面板设计的尽量胡的合理美观。2.编写一个功能判断落子的位置及画出相应的黑白棋子。3.判断胜负
第四章 测试及运行效果
4.1棋盘系统主界面
图4-1初始化棋盘效果，玩家为黑棋 4.2下棋博弈过程界面
图4-2黑白棋博弈
4.3黑方赢的结果
图4-3黑方胜利界面
4.4白方赢的结果
图4-4白方胜利界面
第五章 设计体会与总结
Java编程最强大的地方不是它是容易学，或者难学，而是它拥有一个强大的库。JAVA是一个完全面向对象的语言，JAVA的命名规则是很容易让人接受的。而且容易被编程人员记住。经过实践训练，对JAVA的综合应用能力有了较大的提高，另外对JAVA的特点有了更深层次的认识。这次实践中使用的代码虽然不长，但类与类之间也有很强的逻辑关系，这就是面向对象语言的最大优势，这样可使我们更轻松的运用JAVA。
经过努力，查阅相关资料，终于完成该课题，虽然效果不是很好，但亲手做过之后还是很有成就感的。
通过此次课程设计，将我本学期所学的JAVA知识得到巩固和应用，在设计的过程中我遇到了很到问题，不过在老师和同学们的帮助和自己的思考下还是很好的完成了。这此课程设计还让我懂得了写程序不能闭门造车，要努力拓宽知识面，开阔视野，拓展思维。它还让我学会了在网上查阅那些无限的资料。通过对此课题的开发，使我对用Eclipse开发平台有了一个比较清楚的认识，体会到理论和实践的重要性。由于自己的分析设计和程序经验不足，该系统设计和实现过程中，还有许多没有完善的地方，比如用户界面设计不够美观，异常出错处理比较差等多方面问题，这些都有待进一步完善和提高。
附录
源程序代码及简要说明：
import java.awt.*;import java.awt.event.*;import javax.swing.*;import java.util.Timer;import java.util.TimerTask;import java.lang.Thread;public class WZQ_2008 extends Frame implements ActionListener { Timer t=new Timer(true);//Thread mt=new MyThread(this);MenuBar mb=new MenuBar();Menu myx=new Menu(“游戏”);Menu mbz=new Menu(“帮助”);MenuItem mikj=new MenuItem(“开局”);MenuItem mihq=new MenuItem(“悔棋”);MenuItem mitc=new MenuItem(“退出”);MenuItem migy=new MenuItem(“关于”);int x=0;int y=0;String stb=“五子棋游戏
请黑方落子”;String stw=“五子棋游戏
请白方落子”;boolean isBlack=true;String str=“Game Over”;boolean over=false;int count=0;int jj=30;int r=25;String str1;int [][]date=new int[15][15];
int i=0;public WZQ_2008(){
this.setMenuBar(mb);
mb.add(myx);
mb.add(mbz);
myx.add(mikj);mikj.addActionListener(this);mikj.setEnabled(false);myx.add(mihq);mihq.setEnabled(false);mihq.addActionListener(this);myx.add(mitc);mitc.addActionListener(this);mbz.add(migy);migy.addActionListener(this);this.setTitle(stb);this.setBounds(100,100,485,500);this.setBackground(new Color(206,148,49));this.setResizable(false);this.addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){
System.exit(0);} });this.addMouseListener(new MouseAdapter(){ public void mousePressed(MouseEvent e){
if(over)
{
return;
}
x=(e.getX()-30+jj/2)/jj;
y=(e.getY()-60+jj/2)/jj;
if(x<0||x>14||y<0||y>14)
{
return;
}
if(date[x][y]!=0)
{
return;
}
if(isBlack)
{
setTitle(stw);
date[x][y]=1;
}
else
{
setTitle(stb);
date[x][y]=2;
}
mikj.setEnabled(true);
mihq.setEnabled(true);
isBlack=!isBlack;
pd();
repaint();
} });this.setVisible(true);
} public void pd(){ int xq=0,xz=14;int yq=0,yz=14;if(x-4>0){
xq=x-4;} if(x+4<14){
xz=x+4;} if(y-4>0){
yq=y-4;} if(y+4<14){
yz=y+4;} pdh(xq,xz);count =0;pds(yq,yz);count=0;pdfx(xq,xz);count=0;pdzx(xq,xz);} public void pdzx(int xq,int xz){ for(int i=xq;i<=xz;i++){
if(y+x-i<0)
{
break;
}
if(y+x-i>14)
{
continue;
}
if(date[i][y+x-i]==date[x][y])
{
count++;
isOver();
}
else
{
count=0;
} } } public void pdfx(int xq,int xz){ for(int i=xq;i<=xz;i++){
if(y-x+i<0)
{
continue;
}
if(y-x+i>14)
{
break;
}
if(date[i][y-x+i]==date[x][y])
{
count++;
isOver();
}
else
{
count=0;
} }
} public void pds(int yq,int yz){ for(int i=yq;i<=yz;i++){
if(date[x][i]==date[x][y])
{
count++;
isOver();
}
else
{
count=0;
} } } public void pdh(int xq,int xz){ for(int i=xq;i<=xz;i++){
if(date[i][y]==date[x][y])
{
count++;
isOver();
}
else
{
count=0;
} } } public void isOver(){ if(count==5){
over=true;
if(date[x][y]==1)
{
str1=“黑方胜利”;
}
else if(date[x][y]==2)
{
str1=“白方胜利”;
}
//mt.start();
//for(int i=0)
t.schedule(new MyTimer(this),100,500);
this.repaint();} } public void actionPerformed(ActionEvent e){ if(e.getSource()==mikj){
mikj.setEnabled(false);
mihq.setEnabled(false);
for(int i=0;i { for(int j=0;j { date[i][j]=0; } } isBlack=true; this.setTitle(stb); over=false; this.repaint();} if(e.getSource()==mihq){ mihq.setEnabled(false); date[x][y]=0; if(isBlack) { this.setTitle(stw); } else { this.setTitle(stb); } isBlack=!isBlack; this.repaint();} if(e.getSource()==mitc){ this.dispose();} if(e.getSource()==migy){ new MyAbout(this);} } public void update(Graphics g){ paint(g);} public void paint(Graphics g){ Image ii=this.createImage(485,500);Graphics gg=ii.getGraphics();paintBuffer(gg);g.drawImage(ii,0,0,this);} public void paintBuffer(Graphics g){ for(int i=0;i<15;i++){ g.drawLine(30,60+i*jj,30+14*jj,60+i*jj); g.drawLine(30+i*jj,60,30+i*jj,60+14*jj);} for(int i=0;i for(int j=0;j { if(date[i][j]==1) { g.setColor(Color.BLACK); } else if(date[i][j]==2) { g.setColor(Color.WHITE); } else { continue; } //抗锯齿,使绘画出来的图形更圆滑 Graphics2D g2d=(Graphics2D)g; g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING，RenderingHints.VALUE_ANTIALIAS_ON); g.fillOval(30-jj/2+i*jj,60-jj/2+j*jj,r,r); } } if(over) { g.setColor(Color.GRAY); g.setFont(new Font(“楷体”,3,70)); g.drawString(str,45,250); g.drawString(str1,48,350); g.setColor(Color.RED); g.setFont(new Font(“楷体”,3,70)); g.drawString(str,50,253); g.drawString(str1,60,353); mihq.setEnabled(false); } } public static void main(String[]args){ new WZQ_2008(); } } class MyAbout extends Dialog { Button bok=new Button(“确定”);public MyAbout(WZQ_2008 wzq){ super(wzq,“百纳科技五子棋”,true); this.add(bok); bok.setBounds(180,250,60,20); this.setLayout(null); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); } }); bok.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { dispose(); } }); this.setBounds(100,100,400,300); this.setResizable(false); this.setVisible(true);} public void paint(Graphics g){ Image ii=new ImageIcon(“about.jpg”).getImage(); g.drawImage(ii,0,0,this);} } class MyTimer extends TimerTask { WZQ_2008 wzq;boolean b=true;public MyTimer(WZQ_2008 wzq){ this.wzq=wzq;} public void run(){ if(!wzq.over) { return; } if(b) { wzq.str=“Game Over”; } else { wzq.str=“"; } b=!b; wzq.repaint(); wzq.i++; if(wzq.i==11) { cancel(); wzq.i=0; } System.out.println(wzq.i);} } /*class MyThread extends Thread { WZQ_2008 wzq;boolean b=true;public MyThread(WZQ_2008 wzq){ this.wzq=wzq;} public void run(){ if(!wzq.over) { return; } if(b) { wzq.str=”Game Over“; } else { wzq.str=”"; } b=!b; wzq.repaint();} }*/ 中原工学院信息商务学院 《Java程序设计》 实习报 告 中原工学院信息商务学院 经济管理系 2010年6月20号 中原工学院信息商务学院 目录 一、实习题目...............................................................................................2 二、实习目的...............................................................................................2 1、社会需求.............................................................................................................2 2、专业需求.............................................................................................................2 三、开发环境...............................................................................................2 四、实习内容...............................................................................................3 1、系统功能需求..................................................................................................3 2、数据库需求........................................................................................................4 五、设计过程...............................................................................................4 1、总体设计.............................................................................................................4 2、详细设计.............................................................................................................5 六、调试过程...............................................................................................5 七、实习小结...............................................................................................5 八、参考资料...............................................................................................6 中原工学院信息商务学院 一、实习题目 学生信息管理系统的设计与开发 二、实习目的 1、社会需求 一直以来学生的成绩管理是学校工作中的一项重要内容，随着办学规模的扩大和招生人数的增加，学校工作繁杂、资料重多，普通的成绩管理已不能适应时代的发展，它浪费了许多的人力和物力。在当今信息时代这种传统的管理方法必然被以计算机为基础的信息管理系统所代替。虽然管理信息系统已进入高校，但还未普及而且对于学生成绩管理来说，还没有一套完整的、统一的系统，建立一个成绩维护系统是非常必要的。建立学生成绩管理系统，采用计算机对学生成绩进行管理，能进一步提高办学效益和现代化水平。帮助广大教师提高工作效率，实现学生成绩维护工作流程的系统化、规范化和自动化。 2、专业需求 《Java程序设计》课程是电子商务专业的一门专业必修课程，通过java实习不仅可以提升本专业我们对此课程中的理论知识的综合应用能力而且可以提高我们的逻辑思维能力、软件开发能力。我们通过Java技术在Windows平台下开发学生信息管理系统。能够切实提高我们的程序设计水平，在实践中掌握面向对象程序设计的开发思想。 三、开发环境 操作系统；Windows XP 编程环境：MyEclipse 6.0 中原工学院信息商务学院 主要技术：Java Swing实现窗体界面 JDBC实现数据库操作 系统架构：三层架构（MVC）+DAO设计模式 数据库：MySQL5.0 四、实习内容 1、系统功能需求 学生信息管理系统主要对在校学生的个人基本信息以及成绩信息进行管理，对教师用户提供查询信息、增添信息、删除信息等操作功能；对学生用户提供成绩查询功能。我们的目标就是为该系统提供前台用户界面设计以及后台连接数据库程序设计，系统程序界面采用Java Swing组件实现，数据库操作采用JDBC实现。 学生信息管理系统要面对教师和学生用户。对于教师，需要查询全部学生的基本信息和成绩信息，并且可以对其进行修改。对于学生，不需要查询自己的基本信息，只需要查询成绩。为了保护学生成绩隐私，每位学生登录系统后只能查询自己的成绩，而无法看到别人的成绩。 教师方面：教师通过自己的用户名和密码登录后，进入教师主界面，在这个主界面里，可以选择要操作的类别，即查询功能还是修改功能。在查询功能里面，可以选择是查询学生基本信息，还是查询学生成绩信息。在查询学生基本信息时，可以从依据不同字段，即学生信息表的不同属性进行查找。在查找学生成绩信息时，只能依据学生姓名和学号进行查找。在修改功能里面，包括对学生基本信息表和学生成绩表进行增加和删除记录。 学生方面：学生通过自己的用户名和密码登录此系统后，可以查询自己本学期的各科成绩信息。 中原工学院信息商务学院 2、数据库需求 依据功能需求，学生信息管理系统主要有三个表：student表、teacher表和score表 （1）student（学生信息表） 此表有六个属性，分别为：id(主键，自动递增),num（学号），sname（姓名），sex（性别），age（年龄），dept（系别）。（2）teacher（教师登录表） 此表有三个属性列，分别为：id(主键，自动递增),tname（教师账户），password（登录密码）。（3）score（教师登录表） 此表有六个属性列：分别为：id(主键，自动递增),num（学号），sname（学生姓名），course（课程名称），score（考试成绩），credit（学分）。 五、设计过程(包括总体设计和详细设计)； 1、总体设计 这次java实习设计的学生信息管理系统，是对学生的个人信息，课程信息，成绩信息以信息化的方式进行管理，最大限度地减少各个环节可能出现的错误，有效减少因人力资源局限性导致的存储信息量大，信息存储错误，混淆等问题，合理进行信息存储，使学校能够合理录入学生的个人资料，学期成绩情况，以及课程安排，为学校师生的工作提供后方面。根据需求我们设计的学生信息管理系统教师可以查询、增添、删除学生信息，学生可以查询成绩信息。 中原工学院信息商务学院 2、详细设计 这次Java实习，首先，我们在机房装上了MyEclipse 6.0、navicat、MySQL等程序。其次，我们敲程序代码。源于程序的运行过程是进入提供用户输入机会的“视图层”，进而进入控制用户输入的“控制层”，最后到达“数据操作层”。我们新建工程，建立connection、dao、model、ui包，在connection包中建DBConnection类，在dao包中建ScoreDao、StudentDao、TeacherDao类，在model包中建Score、Student类，在包ui中建LoginUI、ScoreAddUI、ScoreDeleteUI、ScoreQueryUI、StudentAddUI、StudentDeleteUI、StudentQueryUI、StudentScoreUI、TeacherMainUI类。最后链接数据库。出现了主界面、教师登录、学生登录界面。 六、调试过程 在程序设计过程中出现了许多问题，现对我的经历做出以下论述： 1、编写程序时单词拼写错误，程序无法运行。 2、导入包时导错以至于下面的程序一直有错，最后只能重新导入包 3、出现了一些意外情况像只把工程剪切而没有剪切.metadata文件等导致文件无法再次打开导致重新做 4、链接数据库时曾出现驱动失败、链接失败的问题。驱动不成功原因是，第一次导入程序出错。第二次，导入程序时路径中含有中文字符。链接失败源于connection，主要是IP地址出错 七、实习小结(在整个课程设计过程中的总结和体会)； 这次的java实习，我把所学的知识综合运用到开发过程中，使我获得了许多在课本中学不到的知识。当然，在实习中也遇到了许多的困难，在老师、同学的帮助下，问题终于被解决了。通过编写、调试程序我明白了许多。第一，不应该被未知的困难吓到，一切事情只要勇于一步步去做就会成功，想想当初害怕 中原工学院信息商务学院 的要命自己就觉得好笑。第二，态度要端正，摆正自己的心态，不要以为什么东西上网搜搜就可以了，一定要有自己的东西。只有自己付出过，当程序运行成功时的那种喜悦才会令自己有一种莫名的自豪感。态度决定一切！第三，要细心，在对程序的过程中我锻炼了自己的耐力和毅力。 八、参考资料 1、邵丽萍，java语言程序设计。 2、李君芳,赵艳杰.电脑知识与技术马朝晖等.Java教程.(第4版)[M].北京：人民邮电出版社。 3、王毅.Internet与Java[J].电子与电脑。 4、谷庆华等.基于java语言实现数据库访问[J].计算机技术与发展。 XX学院 JAVA语言程序实训报告 专业： 信息管理与信息系统 班级： 姓名： 学号： 指导老师： 前 言 面向对象程序设计是软件编程技术中的一项非常关键的技术。面向对象程序设计中的继承，封装，多态等很接近于人的语言和思维，更容易让人理解和使用。并且，面向对象程序设计更加符合现代软件大规模开发的需求，有利于软件使用。 Java的诞生是对传统计算机模式的挑战，对计算机软件开发和软件产业都产生了深远的影响，Java语言是面向对象程序设计语言中的代表，发展迅速。随着Internet的飞速发展，Web的广泛应用，而Java语言在Web应用方面所表现出来的强大特征，使得Java语言成为Web开发的主流技术。 Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaEE, JavaME, JavaSE）的总称。Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。 本次实训是配合Java程序设计课程，帮助我们深入学习掌握Java语言，熟练运用这个工具来编写的。通过课程设计各个项目的综合训练，不仅培养学生实际分析问题、编程和动手能力，而且还提高了学生的综合素质。 如今，我们所面临的问题有：不能全面系统的、深入的掌握某种技术，也就是会的挺多，但都是皮毛，不能满足就业的需要，没有任何实际的开发经验，完全是想象中学习，考试还行，一到实际开发和应用就歇菜了。解决的方法就是通过实训和练习，对所学知识进行深化，然后通过项目来获取实际开发的经验，从而弥补这些不足。我们应该明白软件是做出来的，而不是听出来或者看出来的，企业需要能实际开发的人员，而不是只听过、看过但不能做的人。所以Java非常强调：项目一定要让学生动手写出来。 希望同学们在老师的带领下，能够将理论与实践联系起来，把我们课本上所学到的知识运用到实践中，在实践中检验真知。 2014年6月10日 目 录 一．实训目的.....................................................................................二．功能分析.....................................................................................三．系统设计.....................................................................................四．测试数据及运行结果..................................................................五．主要源程序.................................................................................六．实训总结与心得体会..................................................................一．实训目的 1.掌握Java语言的面向对象特征，包括Java语言中类、对象、继承、多态、接口和内部类，图形绘制等重要概念及应用实践。 2.掌握Java语言编程基础，包括数据类型、变量、运算符、字符串、数组、控制结构、访问权限修饰符，基本数据类型的转换，类的定义，对象的创建，通过类的对象调用类中的方法等内容。 3.掌握如何使用Java语言编写图形用户界面，利用Java丰富的图形组件创建交互性较好的用户界面。 掌握面对不同的事件处理进行不同事务处理，及每种事务处理的过程。 4.掌握如何使用不同的布局管理器，方便地设计出各种控件组织方式的界面。 掌握如何创建图形的界面，如何进行图形的绘制，怎样对图像进行处理。5.进一步了解java开发的相关知识，掌握java开发的基本技术，丰富java开发的实战 经验。学习有用的相关技术，提高自己的学习效率和工作效率。6.巩固Java课程所学基本知识，提高分析、判断和处理实际问题的能力，锻炼自己的实际动手能力，增强自己的团队协作意识，了解软件开发的思考角度和主要流程。为毕业之后能够更快地进入工作状态并且能够更好的工作，打好一定的基础。 7.经过这个学期的学习后，能不能把学习的知识综合串联起来,java的实训项目的制作可以有效的检验这一点。进行综合项目实训可以练习java软件开发的环境和配置，能够把java的面向对象技术、数据结构、图形界面、小应用程序等知识运用到实践中去，从而更好地理解java的各项知识，达到能够应用自如的地步。进行实训的同时还需要查阅大量的文档，可以锻炼同学的自学能力。 二．功能分析 该黑白棋游戏主要可以实现黑白棋的对弈，要求有黑白两色棋子，保存所有已下的棋子，包括在棋盘上的所有棋子和被踢掉的棋子，若落子没有造成踢子，包括所有被这个棋子踢掉的棋子及这个棋子本身。如果踢子，则保存所有被踢的棋子，在游戏的过程中也可以显示对战双方的当前的棋子个数，提醒对战双方的时限。同时，该游戏还具有悔棋的功能。 三．系统设计 1.棋盘界面设计：基于Panel类定义一个面板子类，在其中利用Graphics类的drawLine（）方法绘制棋盘格线，利用fillOval（）方法绘制棋盘四角的星位。为面板创建监听器，为一个按钮注册ActionEvent事件监听器，实现单击鼠标布子、单机一个重新开局等操作。 2.棋盘功能设计：控制面板类，包含标签、手数、悔棋按钮、重新开始按钮。 3.棋盘界面的实现方法：通过Chesspoint类获得实际棋子的位置。3.棋盘功能的实现方法：利用JFrame将棋子显示出来，Chess对围棋界面外观进行初始化之后即可创建围棋对象。 四．测试数据及运行结果 1．围棋图形用户界面，如图5.1所示： 图5.1 用户界面 2.黑白棋对弈，如图5.2所示： e.界面左边的对话框提示可选择棋盘大小功能，如图5.3所示： 图5.3 棋盘大小选择界面 五．主要源程序 1.Chess类是此程序的主类之一，用来初始化棋盘的外观： import java.awt.*;import javax.swing.JFrame; public class Chess extends JFrame { Chessboard qipan = new Chessboard();; // 初始化外观 public Chess(){ this.setTitle(“围棋程序”); this.setLayout(new BorderLayout()); this.setSize(qipan.getSize()); public int getWidth(){ return size + controlPanel.getWidth()+ 35;} public int getHeight(){ return size;} //绘制棋盘外观 public Chessboard(){„} public void addNotify(){ super.addNotify(); offscreen = createImage(size, size); offg = offscreen.getGraphics();} „„ } 3.Chesspoint类用来通过x和y取得黑白棋子的位置： public class Chesspoint { public static int black=0,white=1;int x,y;int color;public Chesspoint(int i,int j,int c){ x=i; y=j; color=c;} public String toString(){ String c=(color==black?“black”:“white”); return “[”+x+“,”+y+“]:”+c;} 六．实训总结与心得体会 通过这次的实训，我学到了很多：首先，对JAVA识比以前有了更深的了解。在这之前由于种种原因我JAVA学的很不太好。但经过这次的实训，我对JAVA的理解，虽然还有很多都不懂，但我会在今后的实训和学习中加以学习了解，力求弄懂，增强自己对JAVA的理解。其次，在这次的实训中我的动手操作能力有了一点的提高，刚开始的时候JDK的配置，JAVA开发工具的不熟悉，所以开始的时候进程很慢，但付出定有回报，成功的配置了JDK，熟悉了JAVA开发工具，总的说来，自己还是有一定的收获的。因为自己的动手操纵能力得到了提高。最 《Java程序设计》 授 课 人：授课班级：电子商务专业 授 课 教 案 第一章 Java语言简介 教学目的要求 了解Java的基本特点和用途 掌握如何下载Java SDK软件包 了解设置Java程序的开发环境SDK 如何运行Java程序 了解Java的概貌 主要内容 Java语言的发展历程； Java语言的特点； Java语言的开发工具； Java应用程序和小程序； Java程序的注释方法； 写Java程序的风格规范。 重点内容 Java语言的特点； Java语言的开发工具； Java应用程序和小程序； 难点内容 无 课时分配 1课时 教学方法 讲授法、演示法、对比法 讲授内容提要 1.1 Java语言的发展简介 1991年Sun Mircosystem 公司成立了一个Green项目开发小组，Jame Gosling 为组长； 设计Java 采用虚拟机代码（Virtual Machine Code），即.class文件，它通过解释器运行 ； 1995年5月Sun Mircosystem 公司对外正式发布Java1.0； Java2 用途：适用于各种应用开发，尤其是网络应用，网络服务和嵌入式系统。1.2 Java语言的特点 1．简单性 2．面向对象 3．网络适用性 4．健壮性 5．安全性 6．平台无关性 7．可移植性 8．解释型 9．高性能 10．多线程 11．动态性 12．丰富的类库 13．嵌入浏览器运行 1.3 Java类库的概念 1.4 网络浏览器 1.5 Java开发工具 NetBeans： 这个集成环境可以方便地进行程序的编辑、编译、生成和运行。J2sdk : http:// java.sun.com免费下载;Visual J++ 6.0 / 8.0： VJ++还吸收了VB集成开发环境IDE的特征，是一个强有力的Java程序开发工具。Jcreator Eclipse(MyEclipse)等 1.6 Java程序的分类 基于控制台的应用程序； 基于浏览器运行的小程序applet。 小程序与应用程序的区别是：小程序必须依赖一个HTML文件和支持Java的网络浏览器。老师演示小程序和applet程序 应用程序举例(程序1-1)： public class hello { public static void main(String args[ ]){ System.out.println(“Hello Java!”); } } 小程序举例(程序1-2)： import java.awt.Graphics; // 注意该行的含义 import java.applet.Applet;public class sayhello extends Applet { public void paint(Graphics g){ g.drawString(“Hello Java!”,35,30); } } 小程序对应的HTML文件： 1.7 1.8 对Java程序的解释 编写Java程序的风格要求 课堂练习： 请编写一个应用程序输出你自己的学号和姓名 课外练习（作业）： 下载并安装J2SDK； 设置系统环境变量 下载并安装MyEclipse 熟悉MyEclipse的开发环境 第2章 数据类型、运算符和表达式 教学目的要求 掌握字符常量和符号表示的常量的概念和应用 掌握整形、浮点型、字符型和布尔型变量的概念和应用 掌握数据的概念 理解参数传递方式 学会逻辑运算符、算术运算符和位运算符的使用方法 主要内容 常量：包括字面常量和符号表示的常量； 变量：整形、浮点型、字符型和布尔型； 数组：Java的数组属于类类型； 参数传递方式； 运算符：包括逻辑运算符、算术运算符和位运算符等； 重点内容 整形、浮点型、字符型和布尔型变量的概念和应用； 符常量和符号表示的常量的概念和应用 难点内容 参数传递方式 课时分配 2课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 2.1 常量 整形常量：采用八进制、十进制、十六进制表示，但不能采用二进制表示，和C/C++中的一样。 浮点常量：采用十进制或科学记数法表示。在缺省情况下一个浮点数是double型。布尔常量：true和false，它们不是数，不能进行算术运算。字符常量：与C/C++中的表示类似 。字符串常量：Java中字符串常量是对象。 2.2 变量 变量的命名原则是：以字母（’a’„’z’和 ’A’„’Z’）、下划线（‘_’）和‘$’符号开头的，由字母、数字（’0’„’9’）、下划线和‘$’构成的一个符号序列。 例如，a，_a，NameOfStudent，$10均是合法变量名，而-a和9a是非法变量名。关键字不能用作变量名(见表2-1)注意：Java对变量是区分大小写.2.2.1 整形类型的变量 字节（byte）型，8个位。 短整形(short)，占16个位。整形(int)，占32个位。 长整形(long int)，占64个位。 Java中的整形最值均有符号。例如程序2-1测试最值： public class Test_Int { // 程序2-1 测试整形变量的最值 public static void main(String [ ] args){ System.out.println(Byte.MAX_VALUE); System.out.println(Byte.MIN_VALUE); System.out.println(Short.MAX_VALUE);System.out.println(Short.MIN_VALUE); System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); System.out.println(Long.MAX_VALUE); System.out.println(Long.MIN_VALUE); } } 注意： byte、short、int、long是原子类型，而Byte、Short、Integer和Long分别是四种原子类型对应的类类型。 2.2.2 字符类型变量 Java字符量的长度为16个位，表示范围是从‘u0000’ 到 ‘uffff’ 即从0 到 65535； Character是char类型对应的类类型 ； 最大值 Character.MAX_VALUE ； 最小值 Character.MIN_VALUE ； 2.2.3 浮点类型变量 分类：float和double。 Float、Double 是对应的类类型 ； Float.MAX_VALUE、Float.MIN_VALUE是最值。Float.POSITIVE_INFINITY 和 Float.NEGATIVE_INFINITY是正/负无限大。2.2.4 布尔类型变量 boolean变量取值：true和false ； true和false不能转换成任何数值表示，true不是1，false也不是0。 2.2.5 原子类型变量的生存空间 一个变量的生存空间是由两个大括号决定的 范围。下列写法在C/C++中是正确的，但在Java中是错误的(注意)。{ int x=1;{ int x=0;// 错误 } } 2.3 变量赋值问题 如果类中定义的原子类型变量，未给出初值，那么它们将有缺省值 ：byte、short、int 和long变量的缺省值是0；char、float、double和boolean变量的缺省值分别是’u0’、0.0f、0.0d和false。 方法内定义的局部变量，应当对其赋值，否则无法通过编译。例如： // 程序2-4 class Test { // 定义一个类 int Value;// 类中的变量未赋值，缺省就是0 } public class Test_Var{ public static void main(String [ ] args){ int x=100; // 必须赋值，否则无法通过编译 Test obj=new Test();// 对象赋值 System.out.println(obj.Value +“ ”+x); } } 2.4 数组 Java数组是系统定义类Array 的子类； 数组的分类同C/C++：一维和多维。 2.4.1 一维数组 定义数组的格式 ：int a[ ] ； 或 int[ ] a ；其值是null ； 在定义数组时不能指定大小。a仅是一个引用，代表一个数组名，但没有对应的空间。产生数组空间的方法有两种 ： 在定义时直接赋值：int a[ ]={1,2,3}; 通过new分配空间： int a[ ]=new int[10];public class Test_Array{ public static void main(String [ ] args){ int a[ ]={1,2,3}, b[ ]; b= a; for(int i=0;i<3;i++)b[ i ]++; for(int i=0;i<3;i++)System.out.println(a[i]); } } public class Test_Array{ public static void main(String [ ] args){ int a[ ]={1,2,3}, b[ ]; b = new int[6]; System.out.println(“b数组长度 = ” + b.length); for(int i=0;i System.out.print(b[i]+“ ”); } } 注意：(1)获得数组元素的个数：数组名.length； (2)一个整形数组若仅仅采用new分配空间，而没有对其赋值，那么每个元素的值是0 注意：Java数组名是一个引用，当将一个数组名赋值给另一个数组时，实际上是名字的复制 2.5 Java中的参数传递方式 Java的参数传递的形式有两种：基本类型按值传递，对象类型按引用传递； 通过return语句从方法中返回时，基本类型总是以值的方式返回，而对象总是以引用方式返回。例如程序2-8 ： class test{ int x;} public class Test_Paras { static test fun(test o,int y){ o.x=20; } } y=1; return o;public static void main(String [ ] args){ test obj1 , obj2;int Val = 3;obj1=new test();obj1.x=100; obj2=fun(obj1,Val); System.out.println(obj1.x+“ ”+ obj2.x+“ ”+Val); } 2.6 Java的运算符 主要包括： 算术运算符、关系运算符、逻辑运算符、位运算符和三元条件运算符。2.6.1 算术运算符 算术运算符：+、-、*、/、%、++和--，与C/C++基本相同。 %运算符不但可以对整形数据运算，而且可以对浮点型数据运算。例如：3.14 % 2.5的值约等于0.64 ； 隠式数据类型转换： 当整型与浮点型数据进行混合运算时，表达式中的数据类型会进行相应的自动转换，规则为：byte->short->int->long->float->double。 这种转换规则也适应于赋值语句，当赋值符左右两侧变量类型不一致时，只要转换过程中不丢失数据，便进行自动转换。 class number { int x;} public class relationalOperator{ public static void main(String args[ ]){ } number n1,n2; n1=new number(); n2=new number();n1.x=1; n2.x=1;if(n1.x==n2.x) System.out.println(“对象的数据成员x相等！”); if(n1==n2) System.out.println(“n1和n2是一个对象！”);else System.out.println(“n1和n2不是一个对象！”);} 2.6.2 关系运算符 关系运算符不能同其它类型的变量一同 参与运算，例如假设a,b,c是三个整形的变量，那么 a=b==c 是 正确 OR 错误？ ； 关系运算符用于对象时，是判别两个引用是否代表同一个对象。而不是判断两个引用所指向的对象是否同属一个类。 2.6.3 逻辑运算符 逻辑运算符有&&、|| 和!，分别是与、或和非。运算结果是true或false； 逻辑运算有求值“短路”现象，例如程序2-11 ： public class shortCut { static boolean testOne(int x){ System.out.println(x+“ < ”+1+“ ” +(x<1));return x < 1;} static boolean testTwo(int x){ System.out.println(x+“ < ”+1+“ ” +(x<2));return x < 2; } public static void main(String [ ] args){ } if(testOne(6)&& testTwo(1))System.out.println(“表达式为真”);else System.out.println(“表达式为假”); } 2.6.4 位运算符 位运算符：&、|、^、~、<<、>>，分别称为位与、或、异或、左移、右移； Java引入一个专门用于逻辑右移运算符>>>，它采用了所谓的零扩展技术，不论原值是正或负，一律在高位补0。例如： int a=-2 , b; b=a>>>30;2.6.5 三元条件运算符 语法格式：（exp）?(exp1)：(exp2)； Java要求：(exp1)与(exp2)必须同类型。2.6.6 “+”运算符 Java对“+”进行了重载，可以将任何类型的对象（包含原子类型）转化为String类型。例如： int x=1;char ch='A';double d=9.8;System.out.println(“Result: ”+x+ch+9.8);课堂练习： 课外练习（作业）： P32 3、4、6题。 第3章 控制语句 教学目的要求 了解Java程序的结构，学习使用各种语句结构来控制程序的流程，完成程序的功能任务。 主要内容 Java的分支语句； 循环控制语句； break和continue语句； 带标号的break和continue语句。 重点内容 Java的分支语句； 循环控制语句； break和continue语句； 难点内容 循环控制语句； break和continue语句； 课时分配 3课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 3.1 分支语句 if-else语句； switch-case语句。 3.1.1 if 语句 if语句的语法格式 同C/C++； 条件表达式必须是布尔类型，例如： 下面的写法在C/C++中是合法的，但在Java中却是非法的 ： int i=10;if(i) ...程序3-1描述了用applet从文本框获取数据，然后将比较的结果显示出来。 // 程序 3-1 import java.awt.*;import java.applet.*; public class compareNumbers extends Applet{ Label lab1,lab2;TextField input1,input2; int num1,num2;public void init(){ lab1=new Label(“输入第1个整数”); input1=new TextField(10); lab2=new Label(“输入第2个整数”);input2=new TextField(10); add(lab1); add(input1);add(lab2);add(input2);} public boolean action(Event e , Object o){ } if(e.target==input1 || e.target==input2){ num1=Integer.parseInt(input1.getText()); num2=Integer.parseInt(input2.getText()); if(num1 switch 语句 switch语句的语法结构 同C/C++； switch后面的表达式类型必须是字符类型或整形 ； case后面的常量不能重复 ； 程序3-3采用小程序实现将学生的百分制成绩转换为优、良，中、及格和不通过五个等级： // 程序3-3 import java.awt.*;import java.applet.*; public class scoreConvert extends Applet{ Label prompt; TextField input;int Excellent,Good,Middle,Pass,Failure;public void init(){ prompt=new Label(“输入成绩”); } public void paint(Graphics g){ g.drawString(“各等级的人数:”,25,40);g.drawString(“优秀 : ”+Excellent,25,55);g.drawString(“良好 : ”+Good,25,70);g.drawString(“中等 : ”+Middle,25,85);g.drawString(“及格 : ”+Pass,25,100);g.drawString(“不通过: ”+Failure,25,115);input=new TextField(2);add(prompt);add(input);} public boolean action(Event e , Object o){ int score=Integer.parseInt(input.getText()); showStatus(“"); input.setText(”“); switch(score/10){ case 10: case 9: Excellent++; break;case 8: Good++; break;case 7: Middle++; break;case 6: Pass++; break;case 5: case 4: case 3: case 2: case 1: case 0: Failure++; break;default: showStatus(”输入有误，重新输入!“); } repaint(); return true;} } 程序3-3需要注意的地方 在action（）方法中调用的repaint()方法，是一个系统方法，它具有自动调用paint()方法的能力，从而实现对网页的刷新。3.2 循环控制语句 Java中的循环控制语句有三种，分别是：while，do-while和for语句;循环体内的语句会反复执行，直到控制布尔表达式的值变为false为止。3.2.1 while语句 while语句格式： while(Boolean-Expression) StatementS 程序示例3-4 略 3.2.2 do-while语句 do-while语句的语法格式如下： do{ Statement }while(Boolean-Expression); 程序3-5 如下： // 产生一个大于0.9的随机数为止 public class GenerateDoubleNumbers { public static void main(String args[ ]){ } double d;do{ d=Math.random();System.out.println(d); }while(d<0.9);} 3.2.3 for语句 for语句语法格式如下： for(ForInitopt;Boolean-Expression;ForUpdateopt) Statement // 程序3-6输出一个*三角形 public class printGraphics extends Applet{ public void paint(Graphics g){ int xpos,ypos=0; for(int row=6;row>=1;row--){ xpos=25;ypos+=15; } for(int column=1;column<=row;column++){ } g.drawString(”*“,xpos,ypos);xpos+=7; } } 3.3 break语句和continue语句 3.3.1 不带标号的break语句和continue语句 break语句可以跳出包含它的最内层的循环，不再执行剩余的语句； continue语句停止执行当前的循环，回到循环处，开始执行下一轮的循环。这些特性和C/C++的功能一样。for(int i=1;i<10;i++) { if(i%3==0) continue; else System.out.println(”i = “+i); } for(int i=1;i<10;i++) { if(i%3==0) break; else System.out.println(”i = “+i); } 课堂练习： 1、仔细分析下面程序，写出程序的最终运行结果。public class s_switch { public static void main(String args[]) { int ch=8; int r=10; switch(ch-1){ case 7: r=r+3; case 8: r=r+5; case 9: r=r+6;break; default:; } System.out.println(”r=“+r); } } 2、随机产生26个英文字母a~z，直到大于u为止。用while和for语句实现。 课外练习（作业）： P44 1—4 第4章 Java的类 教学目的要求 理解面向对象编程的基本概念 了解类的封装方法 如何创建类和对象 了解成员变量和成员方法的特性 学习使用OOP方式进行程序设计 深刻理解类的继承性和多态性 主要内容 类的定义和使用； 方法的定义和使用； 实例变量和局部变量； 构造方法； 方法的覆盖和重载； 关键字this的用法； 继承的概念和应用； 组合与继承； 抽象方法和抽象类； 对象类型转换； 访问权限限制符：public、private、protected。 重点内容 类的定义和使用； 方法的定义和使用； 构造方法； 方法的覆盖和重载； 关键字this的用法； 继承的概念和应用； 组合与继承； 抽象方法和抽象类； 对象类型转换； 难点内容 构造方法； 方法的覆盖和重载； 继承的概念和应用； 组合与继承； 抽象方法和抽象类 课时分配 8课时 教学方法 讲授法、演示法、对比法、实验验证法、学生讨论法 讲授内容提要 4.1 类与对象 在Java程序中，除原子类型的变量以外都是对象，连Java程序本身也不例外。 类是面向对象程序设计的基础，OO始终是围绕着对象的封装性、继承性和多态性展开讨论的。 4.1.1 类与对象的区别 类是一个抽象的概念，对象是一个具体的概念。 类是在一组对象的基础上，通过抽象和概括获得的一个概念。 对象是由数据和方法紧密结合的一个封装体，具有信息隐藏的能力。 对象可以通过方法（函数）与其它对象进行通信，但并不知道这些方法的实现细节。4.1.2 Java和C编程思想的区别 C是结构化的编程语言，以函数为编程单元，程序员把注意力集中在编写函数上。Java是面向对象的编程语言，以类为编程单元，程序员的精力集中在对类的设计上。 对象将实例变量（instance variable）和对数据的操作（即方法）约束在一起，类似一个独立的程序，易于扩充，易于维护，代码可复用。 4.1.3 如何定义类 类是对象的模板，它定义了对象的结构和操作数据的方法。public class Sayhello extends Applet { public void paint(Graphics g){ int xPos=35; int yPos=30; g.drawString(”Hello Java!“,xPos,yPos); } } 定义类的通用格式如下： class className extends superClassName{ type instance-vairbale1;return-type methodName1(parameter-list){ method-body;} } public class Hello { public static void main(String args[ ]){ System.out.println(”Hello Java!“); } } 系统类Object是整个类层次结构中的根。 如果我们要定义Object的子类，可以不指明extends Object，默认情况下一个类就是Object类的子类。 类内定义的变量称为实例变量，函数称为方法； Java将类的定义和类的实现放在一起，便于系统维护。例如： class point { // Object类的子类 int x , y; void init(int a, int b){ int i=0; x=a; y=b; } } 4.1.4 对象和引用 对象是客观存在的变量，对象的引用就是对象的名字，例如：Point p1;创建对象：p1=new Point(); 一个对象可以有多个别名; p2=p1;将一个变量设置为null，表明该变量不代表任何对象 : p1 = null; 每个对象都有自己的变量，改变一个对象的实例变量并不影响到另外一个对象。例如： class Point { // 程序4-1 int x , y; void init(int a, int b){ x=a; y=b; } } public class TwoPoint{ public static void main(String [ ]args){ Point p1= new Point(), p2= new Point(); p1.x=10;p2.x=30;p1.y=20;p2.y=40;System.out.println(”x = “+ p1.x +” y= “+p1.y);System.out.println(”x = “+ p2.x +” y= “+p2.y); } } 4.2 方法 方法是一个功能模块，类似C中的函数； 方法和实例变量都必须定义在类内，方法是类的功能接口 ； 定义方法的原则：方法应当只执行单一的任务，并且方法名能有效地表达该任务； 方法的返回值类型、方法名和参数表共同称之为方法的特征。调用方法的格式：引用.方法名(参数表);例如： Point p1=new point()，p2=new point();Point p3=p2;p1.init(10,20);//仅对p1对象的x和y进行赋值 p2.init(30,40);//仅对p2对象的x和y进行赋值 对象是客观存在的变量，对象的引用就是对象的名字，例如：point p1;创建对象：p1=new point(); 一个对象可以有多个别名; p2=p1;将一个变量设置为null，表明该变量不代表任何对象 : p1 = null; 每个对象都有自己的变量，改变一个对象的实例变量并不影响到另外一个对象。 4.3 实例变量和局部变量 class Loc { // 程序4-2 int x=1;// 实例变量 void printLocVar(){ int x=25;// 局部变量 } System.out.println(”n x is :“+x); ++x; System.out.println(” x is :“+x); void printInstanceVar(){ System.out.println(”n x is :“+x); x*=10; System.out.println(x is :”+x);} } public class TestInstanceVar { // 程序的主类 public static void main(String args[ ]){ System.out.println(“ x is :”+x); obj.printLocVar(); obj.printInstanceVar(); System.out.println(“ x is :”+x); loc obj=new Loc(); int x=5; // 局部变量 x } } 4.3 实例变量和局部变量 Java中的变量分为两种：类内定义的实例变量，方法中定义的局部变量。 在同一个作用域内，不允许定义两个同名的局部变量。 局部变量可以掩盖实例变量。 实例变量属于对象，它描述了对象的属性，随着对象的存在而存在； 局部变量是随着方法的调用而存在，一旦方法调用结束，局部变量也就消亡了。4.4 构造方法 构造方法的功能是在创建对象时初始化对象的实例变量； 讨论：构造方法的特点： 无返回值，无void 方法名与类名相同 仅在创建对象时调用 class point { // 程序4-3 } public class createPoint { public static void main(String args[ ]){ point p= new point(10,20); System.out.println(p.x +“ ”+p.y);} int x, y;point(int a, int b){ } x=a;y=b; } 如果类中没有定义构造方法，编译器会自动创建一个缺省的、不带参数的构造方法。构造方法是在对象创建之后，new操作完成前被调用的。 4.5 方法重载 方法重载是在一个类中定义二个或多个同名的方法，但方法的参数个数或类型不完全相同；例如： class point { int x, y;point(int a, int b){ x=a;y=b;} point(){ x=-1;y=-1;} point(double a, int b){ x=(double)a;y=b;} } 方法重载的一个误区：是靠返回值区别重载，即定义多个方法，它们的名称和形参类型完全相同，但返回值不同，这是不允许的； 4.6 关键字this this指代对象，是对当前对象的一个引用。例如： class IntVector { // 程序4-6 int v[ ]; boolean equals(IntVector other){ if(this == other)return true; return false;} } class testIntVector { public static void main(String args[ ]){ IntVector t1=new IntVector()，t3=new IntVector()，t2=t1; System.out.println(t1.equals(t2)); System.out.println(t3.equals(t2)); } } Java中的级连调用，仍是指代当前对象的this。例如：// 程序4-7 import java.awt.*;import java.applet.*; class time{ private int hour, min, sec; time(){ setHour(0);setMin(0); setSec(0);} time setHour(int h){ hour=((h>=0 && h<24)? h: 0);return this;} time setMin(int m){ min=((m>=0 && m<60)? m: 0); return this;} time setSec(int s){ sec=((s>=0 && s<60)? s: 0); return this;} String tostring(){ return hour+“:”+min+“:”+sec;} public class timeToString extends Applet{ private time t; public void init(){ } t=new time();} public void paint(Graphics g){ t.setHour(18).setMin(30).setSec(20); } g.drawString(“ time:”+t.tostring(),25,45);} 在构造方法内部使用this，它用于指代另外一个构造方法，但不能指代非构造方法。例如： class point { } 4.7 继承 继承是软件重用的一种形式，可以提高系统的性能； 继承语法： class className extends superClassName{ 各实例变量和方法的定义 } 例如： class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} point(){ this.x=0; this.y=0;} } class circle extends point{ int radius; circle(int r, int x, int y){ radius=r; this.x=x; this.y=y; } } Java不支持多继承，但支持多接口； 子类的对象也是其超类的对象，反之未必； 继承具有传递性： B继承于A，C又继承于B，则C也继承了A中的实例变量和方法。 关键字super 构造方法是一种特殊的方法，子类不能继承超类的构造方法，但子类构造方法可以通过super调用超类的构造方法。int x, y;point(){ this(-1,-1);} point(int a, int b){ x=a;y=b;} 当创建子类对象时，首先执行超类构造方法，然后执行子类的构造方法。例如： class point{ // 程序4-8 int x, y; point(int x, int y){ } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; System.out.println(“子类构造函数被调用！”); this.x=x;this.y=y; System.out.println(“父类构造函数被调用！”); } } public class testInherence { public static void main(String args[ ]){ circle c1; c1=new circle(1,1,1); } } 再次讨论构造方法 若父类没有定义构造方法，那么对父类数据的初始化将采用系统缺省的构造方法；例如： class point{ int x, y; } class circle extends point{ int radius; circle(int r, int x, int y){ this.x=x; this.y=y; radius=r; } } 若父类定义有缺省构造方法，那么子类可根据自己的需要设置自己的构造方法。例如： class point{ int x, y; point(){ this(0,0); } point(int x, int y){ this.x=x;this.y=y; } } class circle extends point{ // 注意子类的构造函数 int radius; circle(int r, int x, int y){ radius=r;} } 若父类定义的构造方法都是有参的，那么子类构造方法必须通过super调用父类构造方法，class point{ private int x, y; point(int x, int y){ this.x=x; this.y=y; } } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r; } } 4.8 方法的覆盖 方法的覆盖发生在父类和子类之间，若子类中定义的某个方法的特征，与父类中定义的某个方法的特征完全一样，那么就说子类中的这个方法覆盖了父类对应的那个方法。 4.8.1 覆盖与重载的区别 重载可以出现在一个类中，也可以出现在父类与子类的继承关系中，并且重载方法的特征一定不完全相同。 覆盖特点：子类中的方法特征与父类定义的对应方法的特征完全一样。例如： // 程序4-9 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){super(x, y); radius=r; } double area(){ return Math.PI*radius*radius;} } public class testOverWrite { public static void main(String args[ ]){ } circle c1; c1=new circle(1,1,1); System.out.println(c1.area());} 4.8.2 方法的动态调用 Java的所有对象运行时都有一个类型标识(RTTI：Run-Time Type Identification)，该标识记录了每个对象所属于的类。Java用此标识在运行时选择正确的方法。例如： // 程序4-11 class point{ int x, y; point(){ this(0,0);} point(int x, int y){ this.x=x;this.y=y; } double area(){ return 0;} } class circle extends point{ int radius; circle(int r, int x, int y){ super(x, y); radius=r;} double area(){ // 覆盖了父类的area方法 return Math.PI*radius*radius; } } public class dynamicalCall { public static void main(String args[ ]){ point p[ ]={new point(2,2), new circle(1,1,1)}; for(int i=0;i System.out.print(“类名： ”+ } p[i].getClass().getName());System.out.print(“父类：”+ p[i].getClass().getSuperclass());System.out.println(“ 面积： ”+ } p[i].area());} 子类对象调用方法时: (1)子类检查是否具有同名和同参数类型的方法，若有则调用该方法，否则继续执行。 (2)到父类中寻找同名和同参数类型的方法，若有则调用该方法。若找不到，将产生编译错误。 对象决定自己到底该调用哪个方法，取决于该对象在继承链中的位置。 4.9 多态性不适合继承链中的实例变量 引用.方法：根据多态性调用； 引用.实例变量：根据引用的类型调用。即：多态性仅仅适用于方法的调用，而不适合实例变量。例如： class Base{ // 程序4-12 int x=1;void print(){ System.out.println(“当前类为 ”+ } this.getClass().getName());System.out.println(“对象的x= ”+this.x); } class Derived extends Base{ } int x=2;void print(){ System.out.println(“当前类为 ”+ } this.getClass().getName());System.out.println(“对象的x= ”+this.x); public class confusions{ public static void main(String [ ] args){ Base obj=new Derived(); } } obj.print();System.out.println(“对象的x= ”+obj.x); 4.10 finalize Java的垃圾回收器具有自动回收垃圾的能力。 垃圾回收器是一个优先级比较低的线程，在系统空闲时运行。 在对象被回收之前，有时需要执行一些特殊的操作，例如保存文件、清除屏幕等，这时就要用Java的finalize方法。例如： class point{ // 程序4-13 int x, y; point(int a, int b){ } x=a;y=b;System.out.println(“point constructor:”+getString()); public void finalize(){ // 注意该方法 System.out.println(“point finalizer:”+getString()); } String getString(){ return “x=”+x+“ y=”+y; } } class circle extends point{ int radius; circle(int r, int a, int b){ super(a,b);radius=r;System.out.println(“circle constructor:”+getString()); } public void finalize(){ System.out.println(“circle finalizer:”+getString()); } String getString(){ return super.getString()+“ radius=”+radius; } } public class testFinalize { public static void main(String args[ ]){ point c1,c2;c1=new circle(1,1,1);c2=new circle(2,2,2);c1=null;c2=null;System.gc(); } } 4.11 static static修饰变量（与C中的不同）； static修饰方法（与C中的不同）； 4.11.1 static变量 static变量是指这样的成员变量：不管在程序运行中生成多少个该类的对象，它们都共享该变量。 即使没有创建对象，该变量仍然存在。因此，static变量又称为类变量。定义格式为：static type variableName; static变量和一般的实例变量不同，在构造方法中不能对它进行初始化。例如： class point{ // 程序4-14 static int count;int x, y;static{ // 静态初始化块 } } count=0;System.out.println(“static variable is initialized!”); point(int a, int b){ count++;x=a; y=b; System.out.println(“Call point constructor!”);} public class testStaticVariable { public static void main(String args[ ]){ point c1=new point(0,0); System.out.println(“There are ”+ } 4.11.2 static方法 (可举例说明Math类的PI和sqrt等，为什么要用静态变量。)static方法是类中的成员方法，它属于整个类，即使不创建任何对象，也可使用静态方法。调用静态方法格式：类名.方法名（参数）； 在子类中不能覆盖父类中定义的静态方法。 静态方法中只能出现静态变量和其它静态方法。并且还不能使用this和super。例如： class point{ // 程序4-15 static int count; int x, y; static{ count=0;System.out.println(“static variable is initialized!”); // 定义静态变量 } point.count +“ points”); } point(int a, int b){ count++;x=a;y=b; System.out.println(“Call point constructor!”); } static int getCount(){ // 静态方法 return count; } } public class testStaticMethod { public static void main(String args[ ]){ } point c1=new point(0,0);point c2=new point(1,1); System.out.println(“There are ”+ point.getCount()+“ points”);} 4.12 关键字final 在实例变量、局部变量和方法的形参定义之前加上final，那么这个变量值只能被引用，而不能修改。 final修饰的局部变量和实例变量必须给出初值，因为它修饰的变量代表一个常量。例如： class Base{ // 程序4-16 final int x=1; // 形式1：修饰实例变量 } public class finalVariables{ public static void main(String [ ] args){ final int var=100;// 形式3：修饰局部变量 } Base obj=new Base(); obj.print(var);void print(final int y){ // 形式2：修饰参数 // y=0; // 错误 } System.out.println(x+y); } 在方法定义前加上final，该方法就不能被子类覆盖，成为终极方法 ； 包含终极方法的类仍然可以被子类继承，子类虽然不能覆盖父类中的终极方法，但可以重载该方法。例如： class Base{ final int x=1; } class Derived extends Base { void print(){ // 重载了父类中的print方法 } System.out.println(x);final void print(int y){ } // 父类中的final方法 System.out.println(x+y);} 4.12.3 final类 在一个类定义前加上final，意味着这个类就不能被其它类继承，成为终极类。 系统类基本上都是final类，如String类。 将class定义为final是为了杜绝继承，类中的方法自然都变成了终极方法。例如： final class Base{ // 声明为final类 final int x=1; void print(final int y){ System.out.println(x+y); } } // 错误：不能继承final 修饰的Base类 class Derived extends Base { } 4.13 组合与继承 面向对象中的软件重用表现为两种形式：继承和对象组合。 设计这类程序的关键是构造方法：子类构造方法调用父类构造、成员对象的初始化。class date{ // 程序4-17 int year, mon,day; date(int y, int m, int d){ year=y; mon=(m>0 && m<13)?m:1;day=checkday(d); } int checkday(int d){ int daydisp[ ]={0,31,28,31,30,31,30,31,31,30,31,30,31}; if(d>0 && d<=daydisp[mon]) return d; if(mon==2 && d==29 &&(year%400==0 || year%4==0&& year%100!=0)) return d;return 1; } String tostring(){ return year+“/”+mon+“/”+day;} } class employee{ // 雇员类 long id;date birthday; 例如： employee(long no, int year, int mon, int day){ id=no; // 设置组合对象 } String tostring(){ return id+“ , ”+birthday.tostring();} birthday=new date(year,mon,day);} class manager extends employee { // 经理类 double basePay; String tostring(){ return basePay+“ , ”+super.tostring();} } public class compositionAndInherence { } public static void main(String [ ] args){ manager boss; } boss=new manager(1001,1971,11,5);System.out.println(boss.tostring()); manager(long no, int y, int m, int d){ super(no,y,m,d); // 调用父类构造函数 } basePay=1000; 4.14 抽象类和抽象方法 抽象方法：仅有方法特征，但没有代码； 抽象类：包含抽象方法的类。 抽象类的作用：提供一种适当的超类，子类通过继承实现父类中的抽象方法。 抽象类不能用final修饰。 抽象类体现了多态性，通过继承可以从抽象类派生出具有相似操作的子类。例如： abstract instrument abstract void play()继承 wind void play()继承 继承 stringed void play()percussion void play()继承 继承 woodwind void play()brass void play() // 程序4-18 abstract class instrument{ abstract void play();} // wind不是抽象类 class wind extends instrument{ void play(){ System.out.println(“wind play!”);} } // percussion也不是抽象类 class percussion extends instrument{ void play(){ System.out.println(“percussion play!”);} } // stringed也不是抽象类 class stringed extends instrument{ void play(){ System.out.println(“stringed play!”);} } class woodWind extends wind{ // 覆盖父类中的play方法 void play(){System.out.println(“woodWind play!”);} } class brass extends wind{ // 覆盖了父类中的play方法 void play(){ System.out.println(“brass play!”);} } public class music { static void tuneAll(instrument e[ ]){ } for(int i=0;i e[i].play(); // 抽象方法 public static void main(String [ ] args){ instrument orchestra[ ] = new instrument[5];int i=0; orchestra[i++]=new wind();orchestra[i++]=new percussion();orchestra[i++]=new stringed();orchestra[i++]=new woodWind();orchestra[i++]=new brass();tuneAll(orchestra); } } 程序运行结果： wind play!percussion play!stringed play!woodWind play!brass play! 4.15 对象的类型转换 4.15.1 向上类型转换 从子类向父类转换，在继承图中是向上移动，通常称为向上类型转换。 类型向上转换是安全的，因为这是从特殊类型到通用类型的转换。 进行向上类型转换时，出现的唯一问题是可能丢失子类中定义的方法和变量。例如： // 程序4-19 class point{ int x, y; point(int x, int y){ this.x=x;this.y=y;} int getX(){ return x;} } class circle extends point{ int radius;circle(int r, int x, int y){ super(x, y);radius=r;} double area(){ return Math.PI*radius*radius; } } public class testUpCasting { } public static void main(String [ ] args){ circle c=new circle(1,1,1);point p=c;// 注意：p和c的类型不同 } System.out.println(p.getX());4.15.2 向下类型转换 从父类向子类转换，在继承图中是向下移动，称为向下类型转换。 类型向下转换是不安全的，因为这是从一般类型到特殊类型的转换。例如： public static void main(String [ ] args){ } 4.16 访问权限限制 Java提供的访问权限修饰符有四个，即public、private、protected和友元； 修饰符要置于每个类成员（实例变量和成员方法）的定义之前，且仅能控制它所修饰的那个成员。 4.16.1 友员 缺省修饰符的情况就是友员。友员修饰符意味着同一个目录（包）中的所有类都可以访问这种类型的成员。 friendly不属于Java关键字，是C++的一个关键字。 例如： public class Base{ // 该类位于Base.java文件中 int friend_data=1;// 友员数据成员 } // 该类位于Derived.java文件中 public class Derived extends Base{ Base p=new Base(); // 访问Base类中的friend_data } 4.16.2 public 成员 不管两个类是否位于同一个目录中，一个类总可以访问另一个类的public成员。 public还可以用于修饰主类，文件名必须与主类名一致。除此之外，其它3个修饰符都不能用于修饰类，只能修饰成员。例如： public class Base{ public int friend_data=1;// public成员 } void dataUse(){ System.out.println(“data=”+p.friend_data); } point p=new point(1,1);circle c;c=p; //注意：此处编译时出错 c=(circle)p;//注意：此处运行时出错 System.out.println(c.area()); public class Derived extends Base{ public Base p=new Base(); public void dataUse(){ } 4.16.3 private成员 private成员的特性：除了其所在类能够访问该成员以外，其它类都不能访问它。 在多人合作开发一个系统的过程中，private可以让你自由使用自己定义的成员，无须担心与其他人写的类相冲突。例如： // 程序4-20 class Base{ private Base(){ } public class testPrivate { public static void main(String args[ ]){ // Base p=new Base(); // 编译有错 } } Base p = Base.makeBase();} // 注意 } System.out.println(“data=”+p.friend_data);} static Base makeBase(){ return new Base(); 4.16.4 protected成员 protected与继承有关，这种类型的成员可以被子类访问。 同一个包内的非子类，也可以访问这种类型的成员。即：protected天生就具有友元权限，例如： // 程序4-21 class Base{ // 该类位于Base.java文件中 int friend_data=1; // 友元成员 public int public_data=2; // public成员 private int private_data=3;// private成员 protected int protected_data=4;// protected成员 } class Derived extends Base{ // Derived.java文件 Base a=new Base();void dataUse(){ } System.out.println(a.friend_data);System.out.println(a.public_data);// System.out.println(a.private_data);System.out.println(a.protected_data);} // 将主类存放在testData.java文件中 public class testData { public static void main(String args[ ]){ } Derived d=new Derived();d.dataUse(); } 访问权限总结 课堂练习： 1、定义一个Student类： 该类的功能有：可以保存、修改和获取学生的姓名、学号等。可以设置学生的英语成绩、数学成绩、Java成绩，并能计算平均分、最高分和最低分。 2、以下代码定义了一个类，请指出其中三条不合法的代码行（行号参见注释）。 class Test22{ //1 //7 } static float fac1(boolean f){ return f?u:v;} //8 float fac2(boolean f){ return f?u:v;} //9 float u; //2 static float v; //3 static void setUV(boolean f){ //4 u=fac1(f); //5 v=fac2(!f); //6 } 课外练习（作业）： P87 1、3、4、6 第5章 接口和包 教学目的要求 掌握接口的定义和使用 了解接口与抽象类的异同点 掌握包的定义和使用 主要内容 接口的定义和使用 包的定义和使用 重点内容 接口的定义和使用 包的定义和使用 难点内容 无 1课时 课时分配 教学方法 讲授法、演示法 讲授内容提要 5.1 接口 引入接口的原因：在程序设计中经常遇到这样一个问题：有些类互不相关，但却具有相似的方法。并且这些方法在各个类中的实现互不相同。我们不能为这些类定义一个共同的父类，但又希望在程序中体现出它们共同的接口。 5.1.1 接口的定义和应用 接口是一系列常量和空方法的集合，它提供了多个类共同的方法，但不限制每个类如何实现这些方法。 Java允许一个类同时实现多个接口，相当于实现多继承的功能。声明一个接口的语法格式： [public] interface interfaceName [extends super-interface-List]{ type ConstantName=value; type MethodName(Parameter lists);} 例如： interface Sortable{ // 定义一个接口 int Compare(Sortable s);} 接口中不能声明任何变量和构造方法。 如果一个类实现多个接口，应该在接口名之间用逗号隔开。 当一个类实现接口时，必须实现接口中给出的空方法，若实现接口的类是一个抽象类，可以把实现接口的任务交给子类去实现。例如： // 程序5-1 interface Sortable{ // 定义一个接口 int Compare(Sortable s);} class Sort{ // 定义一个排序类，仅有一个静态的方法 public static void SelectSort(Sortable a[ ]){ int i, j, k;Sortable temp; for(i=0;i // 选择排序 k=i; for(j=i+1;j if(a[k].Compare(a[j])<0)k=j; temp=a[i];a[i]=a[k];a[k]=temp;} } } class Student implements Sortable{ // 定义一个学生类 private int score; Student(int x){score=x;} // 实现接口Sortable中的方法 public int Compare(Sortable s){ Student st=(Student)s; // 类型强制转换 return score-st.score;} public String toString(){ return “score=”+score;} } class Rectangle implements Sortable{ // 矩形类也实现了接口 } public class interfaceTest { public static void main(String args[ ]){ Student stud[ ]=new Student[20];int i;private int length,width; Rectangle(int x,int y){ length=x;width=y;} int area(){return length*width;} public int Compare(Sortable s){ // 实现接口 } public String toString(){ return “area=”+area();} Rectangle rec=(Rectangle)s; // 类型强制转换 return area()-rec.area(); for(i=0;i stud[i]=new Student（(int)(Math.random()*100));Sort.SelectSort(stud); // 排序 for(i=0;i System.out.println(stud[i].toString());Rectangle R[ ]=new Rectangle[10];for(i=0;i R[i]=newRectangle（(int)(Math.random()*10)，(int)(Math.random()*10));Sort.SelectSort(R); // 排序 for(i=0;i System.out.println(R[i].toString()); } } 接口中定义的变量实际上是常量，必须给出它们的初始值，实现接口的类可以自由引用这些常量。例如： // 程序5-2的部分 interface constant { int int int int EXCELLENT=5; GOOD=4; PASS=3; FAIL=2;} 在类中实现接口中方法时，方法的特征必须和接口中声明的方法特征保持一致； 实现方法时必须在方法前加上public； 若一个类没有对接口中的方法具体实现，那么必须将该类声明为abstract类。例如： interface inter { // 接口 } void methodA(); abstract class Derived1 implements inter { // 此处不需要写出methodA()的原型 } class Derived2 extends Derived1{ public void methodA(){ // 实现方法 } } System.out.println(“Hi,methodA”);5.1.2 接口和抽象类的异同点 接口和抽象类的相同点： (1)都有空的方法，都必须在子类中实现这些方法。 (2)都不能用new关键字来创建这两种类型的对象。 (3)都可以具有继承关系。 (4)接口和类一样可以具有public属性。接口和抽象类的不同点： (1)在抽象类中，空的方法必须加abstract关键字，而在接口中不需要。 (2)在抽象类中，除空的方法外，可以定义实例变量和非空的方法，而在接口中，只能定义常量和空的方法。 (3)接口允许多继承，类仅支持单继承。 5.2 包 在Java中可以将自己写的类，按一定的方法归属于不同的子目录中（包）。 在缺省情况下，Java将所有的类归属一个缺省包中。在不同的包中可以有同名的类存在。 Java中的包与C++中的名字空间相似。 5.2.1 package语句 package语句告诉编译器当前类属于哪个包。如果没有package语句，类就存放在无名的缺省包中（即当前目录中）。 引进包的概念主要是为了名字冲突。 格式: package pkgl[．pkg2[．pkg3]]； 5.2.2 import语句 import语句位于package语句之后，类的定义之前;格式：import package1[.package2].(class-name | *)； 采用*号不影响程序的运行性能，但会影响编译速度。指明具体类比引入整个包更为合理。5.2.3 包应用举例 package Base; // 将该类存放在d:myjavaBase包中 public class Base { int friend_data=1;// 友元成员 public int public_data=2;// public成员 private int private_data=3;// private成员 protected int protected_data=4;// protected成员 } package Derived; // 将Base类存放在Derived包中 import Base.*; // 需要使用Base包中的类 public class Derived extends Base{ Base a=new Base(); // 为了让testData类能调用该方法，修改为public // 不能访问 public void dataUse(){ // System.out.println(a.friend_data); System.out.println(a.public_data); // System.out.println(a.private_data); // 不能访问 // System.out.println(a.protected_data);// 不能访问 } } // testData.java文件的内容如下： import Derived.*; //需要使用Derived包中的类 // 该类位于工作目录，不需要package语句 public class testData { public static void main(String args[ ]){ } } Derived d=new Derived(); d.dataUse(); 课堂练习： 课外练习（作业）： P108 3~6 第6章 字符串处理 教学目的要求 掌握字符串的分类； 掌握内容不可改变的字符串类String； 掌握字符串常量； 掌握内容可以改变的字符串类StringBuffer； 掌握字符串应用。 主要内容 字符串的分类； 内容不可改变的字符串类String； 字符串常量； 内容可以改变的字符串类StringBuffer； 字符串应用。 重点内容 掌握内容不可改变的字符串类String； 掌握内容可以改变的字符串类StringBuffer； 掌握字符串应用。 难点内容 String和StringBuffer的区别和联系 课时分配 2课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 6.1 字符串的分类 java.lang包中定义了 String和StringBuffer两个类； 在运行中值不会改变的字符串，用String类存储；值会改变的字符串用StringBuffer类来存储。 两个类都有final修饰，这样可以优化字符串的操作。 6.2 String类 String类的定义原型 ： public final class java.lang.String extends java.lang.Object { … } 6.2.1 字符串常量 字符串常量属于String类型;相同的字符串常量属于同一个对象，占用同一块空间，例如: // 程序6-1 public class TestConstString{ public static void main(String args[ ]){ } } String str1=“Hello”, str2=“Hello”; System.out.println(str1==str2);System.out.println(“Java”==“Java”);6.2.2 创建String类对象 用new运算符，并调用构造函数创建这种类型的对象，常见构造函数如下： 1.public String()采用该构造函数创建一个不含字符的空对象。例如： String str =new String(); 2.public String(char value[ ]) 将字符数组的内容转换为字符串，并赋予新建的对象。例如： char a[ ]={'J','a','v','a'};String str=new String(a);3.public String(char value[ ], int offset, int count) 例如：char a[ ]={'J','a','v','a'}; String str=new String(a,1,2); // 字符串str的内容是“av” 4.public String(String value) 采用value对象的值构造一个新的string对象。 例如： String str1=“Java”;String str2=new String(“Java”); System.out.println(str2); System.out.println(str1==str2); 5.public String(StringBuffer Buffer)注意采用字符串常量初始化一个String引用的问题。例如： String str = “abc”;相当于： char data[ ] = {'a', 'b', 'c'};String str = new String(data);应用举例，注意程序6-2的输出结果： public class TestString{ // 程序6-2 public static void main(String args[ ]){ String s1=“Java”, s2=“Java”;String s3=new String(s1); System.out.println(“ s1==s2 is ”+(s1==s2));System.out.println(“ s1==s3 is ”+(s1==s3));s1=“ABC”;s2=“DEFG”;System.out.println(“ s1==s2 is ”+(s1==s2));s1=s2; System.out.println(“ s1==s2 is ”+(s1==s2));} } 6.2.3 String类常用方法 1.public int length(): 求串长。例如： String str=“Java” ； System.out.println(str.length());2.public char charAt(int index) 提取指定位置上的字符。 3.public int compareTo(String anotherString) 对字符串内容按字典序进行大小比较。例如： public class SortStringArrary{ // 程序6-3 public static void main(String args[ ]){ String str,s[ ]={“Computer”,“CHINA”,“world”,“U.S.A”}; int i,j,k; System.out.print(“排序之前：”);for(i=0;i System.out.print(“t”+s[i]);for(i=0;i for(k=i,j=i+1;j if(s[k].compareTo(s[j])>0) k=j; str=s[i]; s[i]=s[k]; s[k]=str;// 注意该行的含义 } System.out.print(“n排序之后：”);for(i=0;i System.out.print(“t”+s[i]); } } 4.char[ ] toCharArray() 将String对象转换到一个字符数组中，例如： String s=“Hello,Java!”; char a[ ]; a=s.toCharArray(); for(int i=6;i System.out.print(a[i]);5.public boolean equals(String anString) 比较两个字符串对象的内容是否相等。 6.public boolean equalsIgnoreCase(String anotherString) 以忽略大小写方式，比较两个字符串对象的内容是否相等。 注意：equals()方法与“==” 之间的区别。例如： public class ConfuseQuestion{ // 程序6-5 public static void main(String args[ ]){ String s1=“java”; String s2=new String(s1); String s3=s2; } } System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s2==s3);System.out.println(s2.equals(s3));7.public int indexOf(int ch / String str) 在字符串中搜索字符或子串，返回字符或子串在String对象中从左边起首次出现的位置。如果没有出现，返回-1。 8.public String substring(int begin, int end) 提取string对象中从begin开始，到end-1结束的子串，返回提取的子串。 9.public String concat(String str)将str对象接到调用对象的后面，返回新串。例如： String s1=“Hello ” , s2=“Java” , s3;s3=s1.concat(s2); System.out.println(s3);注意：如果参数str为空（null），则concat方法不创建新串，而仅仅返回当前串，10.public String replace(char oldChar, char newChar) 将String对象中所有的oldChar字符替换为newChar，返回替换后的新串。例如： String path=“d:/myjava/documents”; System.out.println(path.replace('/' , '')); public String toString() 返回当前字符串对象本身。 12.public static String valueOf(各种类型 f) 将各种数据类型转换成一个相应的字符串表示，该方法是一个static方法。 程序6-6演示了valueOf()方法的应用。 程序6-7自学。 public class TestValueOf{ // 程序6-6 public static void main(String args[ ]){ char a[ ]={'A','B','C','D','E','F'}; int i=123456;float f=3.14159f;boolean b=true;Object o=null;System.out.println(String.valueOf(a));System.out.println(String.valueOf(a,2,3));System.out.println(String.valueOf(i));System.out.println(String.valueOf(f));System.out.println(String.valueOf(b)); System.out.println(String.valueOf(o));} } 6.2.4 Java应用程序的命令行参数 应用程序可以通过main方法的String数组，访问由解释器传递的命令行参数。例如： public class ShowMainArguments{ //程序6-8 public static void main(String args[ ]){ for(int i = 0;i < args.length;i++) System.out.println(args[ i ]); } } 6.3 StringBuffer类 StringBuffer类对象是一个内容可以改变的字符串。可以减少由于少量字符的插人而引起的空间分配问题。 StringBuffer类的原型： public final class java.lang.StringBuffer extends java.lang.Object { … } StringBuffer类对象有一块缓冲区，字符串被存放在缓冲区中，缓冲区的大小可以随程序的需要进行调整。缓冲区的大小称为对象的容量。 当修改对象的内容时，只要StringBuffer对象包含的字符个数没有超出容量，就不会分配新的空间，而直接在原空间内进行修改。若字符的个数超出了容量，该对象会自动调整其容量，从而适应新的存储。 6.3.1 创建StringBuffer类对象 StringBuffer类的构造函数有三种方式： 1.public StringBuffer()创建一个内容为空的StringBuffer对象，容量为16。 例如：StringBuffer s=new StringBuffer();2.public StringBuffer(int length)初始内容为空，容量为length指定的大小。注意：length应大于等于0，不能为负数，否则会产生异常。例如： StringBuffer s2=new StringBuffer(2);3.public StringBuffer(String str) 初始内容和参数str的内容相同，容量为参数str的长度加上16。例如： String s1=“Java”; StringBuffer s2=new StringBuffer(s1);则s2的容量是20，内容是“Java”。 6.3.2 StringBuffer类常用方法 1.public int length() 返回字符串的长度 2.public int capacity() 返回缓冲区大小 3.public void setLength(int newLength) 指定对象的长度，将对象的内容进行裁减。如果参数小于对象的长度，则将对象截断；如果参数大于等于对象的长度，则填充空字符('u0')扩充新增加的部分。 4.public void ensureCapacity(int NewCapacity) 设定对象的缓冲区的大小，若参数 小于对象的容量，则新的设置将不起作用，也就是说容量只能扩大而不能缩小。 程序6-9演示了这几个方法的具体应用。 public class TestCapacity{ // 程序6-9 public static void main(String args[ ]){ String s=“Java”; StringBuffer str=new StringBuffer(s);System.out.println(“Length=”+str.length());System.out.println(“Capacity=”+str.capacity());str.setLength(8); // 设置长度为8 str.ensureCapacity(80);// 设置容量为80 System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); str.setLength(3); str.ensureCapacity(20);System.out.println(“nstr= ”+str);System.out.println(“Length = ”+str.length());System.out.println(“capacity = ”+str.capacity()); } } 5.public void setCharAt(int index, char ch) 将参数index指定位置上的字符，设置成参数ch 指定的字符。例如： StringBuffer str=new StringBuffer(“Hello,Java”); str.setCharAt(3,'L'); 则str的内容变成了“HelLo,Java” 6.public StringBuffer append(多种数据类型) 将其它类型的数据添加到StringBuffer对象的尾部，返回修改后的StringBuffer对象。 例如：StringBuffer s1,s2=new StringBuffer(); s1=s2;// s1和s2代表同一个对象 s2.append(3.14).append(' ').append(“Java”); System.out.println(s1==s2); // 输出true System.out.println(s1); // 输出3.14 Java 7.public String toString() 该方法把StringBuffer对象的内容复制到一个新的String类对象中，返回这个新的String类对象。例如程序6-10。 public class BufferToString{ // 程序6-10 public static void main(String args[ ]){ String s1;StringBuffer s2=new StringBuffer(“Hello ”);s1=s2.append(“Java!”).toString();System.out.println(“s1=”+s1+“"+”s2=“+s2); } } 8.public StringBuffer insert(int offset, 多种类型 b)该方法是将一个其它类型的对象b插入到offset指定的位置。例如： StringBuffer str=new StringBuffer(” Java!“); // 将字符串”Hello“插入到下标为0的位置 str.insert(0,”Hello“); System.out.println(”str= “+str);输出结果为： str= Hello Java! 6.4 略 应用举例 课堂练习： 无 课外练习（作业）： P119 2、3、4 第7章 异常处理 教学目的要求 了解异常的层次结构； 掌握异常处理语句； 了解自定义异常； 了解异常处理中常用的调试方法。主要内容 异常的层次结构； 异常处理语句； 自定义异常； 异常处理中常用的调试方法。 重点内容 异常处理语句； 难点内容 无 课时分配 1课时 教学方法 讲授法、演示法、对比法、实验验证法 讲授内容提要 7.1 异常的层次结构 Throwable是异常类的根节点，定义在java.lang包，它的子类也定义在该包中； Error代表系统错误类，由系统直接处理； Exception类及其子类是在程序中可捕捉到的异常。见图7.1 Throwable Error achineError … AW TError LinkageError VirtualM RuntimeException ArithmeticException ArrayIndexO utO fBoundsException … Interrupted Exception AWTException IOException Exception FileNotFoundException… EOFException 1.java.lang.ArithmeticException 0作除数（包括模），将产生这类异常。例如：int x=0 , y; y=100/x; 2.java.lang.ArrayIndexOutOfBoundsException 例如：int a[ ]=new int[10]; a[10]=0; 3.java.lang.ArrayStoreException 例如：int a[ ]=new int[10]; boolean b[ ]=new boolean[10]; System.arraycopy(a,0,b,3,6);//有异常 4.java.lang.ClassCastException 例如： Object obj=new Object(); int a[ ]=(int[ ])(obj); 5.java.lang.IndexOutOfBoundsException 例如：char ch=”ABC“.charAt(99); 注意: 2 是5的子类。 6.java.lang.NegativeArraySizeException 例如： int a[ ]=new int[-10]; 7.java.lang.NullPointerException 例如：int a[ ]=null; System.out.print(a.length);7.2 异常处理语句 缺省的异常处理的情况，例如： public class DefaultException{ // 程序7-1 public static void main(String args[ ]){ int a,b=0; a=2/b; // 此处有异常 System.out.println(“a=”+a);// 不运行此行 } } 异常处理语句有try、catch、finally、throw和throws。异常处理的形式为： try{ 程序执行体 }catch(异常类型1 异常对象1){ 异常处理程序体1 }catch(异常类型2 异常对象2){ 异常处理程序体2 }finally { 异常处理结束前的执行程序体 } 7.2.1 try和catch语句 try语句指明可能产生异常的代码段;catch语句在try语句之后，用于捕捉异常，一个try语句可以有多个catch语句与之匹配。异常处理以后，程序从try语句代码段后继续执行。例如：程序7-2。public class TryCatchTest{ // 程序7-2 public static void main(String args[ ]){ int a=99,b=0,c; try{ System.out.println(”产生异常之前“);c=a/b; // 该行有异常 System.out.println(”产生异常之后“);}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”处理下标越界异常“);}catch(ArithmeticException e){ System.out.println(”处理算术异常“);} System.out.println(”异常处理结束“); } } 注意：用catch语句捕捉异常时，若找不到相匹配的catch语句，将执行缺省的异常处理。例如： int a=99,b=0,c; try{ c=a/b;//产生的异常和捕捉的异常类型不一致 }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”处理异常“); } 注意：当有多个catch语句时，系统依照先后顺序逐个检查。例如： try{ c=a/b; }catch(ArithmeticException e){ System.out.println(”Divided by zero“);}catch(RuntimeException e){ System.out.println(”Divided by zero“);} 7.2.2 finally语句 无论是否产生异常，finally语句指明的代码一定被执行。例如： public class testFinally{ // 程序7-3 public static void main(String args[ ]){ int a,b=0; for(int i=0;i<=3;i++){ System.out.println(”Test No: “+(i+1));try{ switch(i){ } case 0: a=3/b; break;case 1: int c[ ]=new int[10]; c[10]=0; break;case 2: char ch=”ABC“.charAt(99); break;case 3: return;}catch(ArithmeticException e){ System.out.println(“零作除数！”); }catch(ArrayIndexOutOfBoundsException e){ System.out.println(”数组下标越界！“);}catch(IndexOutOfBoundsException e){ System.out.println(”下标越界！“);}finally{ System.out.println(”在finally块中！“); } } 7.2.3 throw语句 throw语句用于指出当前行有异常，当程序执行到throw语句时，流程就转到相匹配的异常处理语句，所在的方法也不再返回值。 throw语句可以将异常对象提交给调用者，以进行再次处理。例如：程序7-4。public class ThrowException{ // 程序7-4 public static void Test(){ try{ int c[ ]=new int[10];c[10]=0;}catch(ArrayIndexOutOfBoundsException e){ System.out.println(”t 数组下标越界！“); } } throw e; // 异常抛出点 //System.out.println(“t产生异常后!”); 该行无法通过编译 } } public static void main(String args[ ]){ try{ Test();}catch(IndexOutOfBoundsException e){ System.out.println(”t 下标越界！“);}finally{ System.out.println(”t 在finally块中！“);} } } 7.2.4 throws语句 throws语句指明方法中可能要产生的异常类型，由调用者进行异常处理。例如： import java.io.*; // 程序7-6 public class testThrows { public static String readString()throws IOException{ int ch;String r=”“;boolean done=false; while(!done){ ch=System.in.read(); } if(ch<0 || ch==0xd) done=true;else r = r +(char)ch; return r; } public static void main(String args[ ]){ String str; try{ str=readString();}catch(IOException e){ System.out.println(”产生了输出/输出异常“); return;} System.out.println(”整数是："+Integer.parseInt(str)); } } 建议：在多人合作写程序时，一个方法中产生的异常，最好在该方法中进行处理，不要将异常传播给其他人处理。 7.3 自定义异常类 通过继承Exception类或它的子类，实现自定义异常类； 对于自定义异常，必须采用throw语句抛出异常，这种类型的异常不会自行产生。总体上分为两步： 第1步：定义异常类。例如： class userException extends Exception{ int n=0; // 计数器 Java程序设计 第一讲 绪论 一、安装netbean系统 二、hello world 典型程序结构中各部分的说明： /* * To change this template, choose Tools | Templates * and open the template in the editor.*/ package test1; //@author Jie public class Test1 { public static void main(String[] args){ System.out.println(“Hello World!”); } } 1、注释语句 2、类定义的包：package 3、public class Test1，定义类，类名称是Test1，属性为public 4、public static void main(String[] args)，main函数 5、main函数的函数体{ System.out.println(“Hello World!”); } 三、Java程序设计语言的基本内容： 数据类型 运算符&表达式 3 程序控制语句 4 数组 5 类 6 对象 7 继承 8 接口 9 包 APPLET 11 异常处理 12 线程 13 字符串 14 GUI 15 输入输出系统 我们的课堂教学内容：时间17周，包括17次课堂教学，17次实验室上机。 四、几个案例： 1、计算根号2； 2、显示1-100 3、从1加到100 4、打印一个“*”组成的10*10的矩形 5、求N!，递归算法 6、GUI的例子，在GUI界面下输入和显示（this.jLabel1.setText(this.jTextField1.getText());） 7、演示几个复杂一点例子 五、Java语言中保留的关键字： Java语言一共使用了48个保留关键字，他们主要可以 分为如下几类。 1.访问控制 private , protected , public.2.类、方法和变量修饰符 abstract , class , extends , final , implements , interface, native（用于与其他语言的接口）, new , static strictfp：java 语言采用固定的位数来存储浮点型数据，但是有些处理器使用更高位的浮点寄存器，这些寄存器增加了中间过程的计算精度。例如double类型数据jvm采用64为存储，二有些处理器使用80位的浮点寄存器来保存中间数据。例如：double w = x*y/z;很多处理器计算x*y后将中间结果存储在80位的寄存器中，再除以z并将结果截断为64位；但是这个结果可能会与始终在64位机器上计算的结果不一致，如果将所有的中间结果都截断，可能会导致溢出，而截断操作同样需要时间，计算速度比较慢。 因此JVM默认允许中间结果精度扩展。但是在使用关键字strictfp标记的方法，必须使用严格的浮点计算。使用strictfp标记的类中所有的方法都必须严格按照浮点计算。 synchronized：多线程同步访问控制 transient：transient 关键字表示在Serializable 的时候不保存该值 volatile：Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 3.程序控制语句 break, continue, return, do, while, if, else, for, instanceof, switch, case,default, 4.错误处理 catch 捕获, finally 最后, throw 投试, throws 投试, try 尝试 5.包相关 import 输入, package 包.6.基本类型 boolean 布尔型, byte 字节型, char 字符型, double 双精度, float 浮点, int 整型, long 长整型, short 短整型 7.变量引用 super 特殊, this 这个, void 无值 除了这48个关键字以外,还有3个语法保留字： null 空, true 真, false 假.六、如何学习一门程序设计语言 1、理解什么是程序设计语言 2、练习、练习、再练习 第二讲 数据类型、运算符与表达式 一、Java语言中的数据类型 数据类型 大小 范围 默认值 byte(字节) -12832768 0 int(整型) -2147483648-2147483648 0 long(长整型) -***7808-***7808 0 float(浮点型) 32-3.40292347E+38-3.40292347E+38 0.0f double(双精度) -1.797693***E+308-1.797693***E+308 0.0d char(字符型) „ u0000-+=!~ +(一元)-(一元) 左右 * / % 右左 +(二元)-(二元) 右左 << >> >>> 右左 < > <= >= instanceof 右左 = =!= 右左 & 右左 ^ 右左 | 右左 && 右左 || 右左 ?： 左右 = *= /= %= += －= <<= >>= >>>= &= ^= |= 左右 三、实验课任务 1、熟悉netbeans的工作环境，自己编写HELLO WORLD程序 2、输入并运行测试，至少10个不同运算符号组合的算术表达式 3、输入并运行测试，至少5个不同运算符号组合的逻辑表达式 4、联系字符串对象的基本用法：声明赋值对象，显示对象，两个字符串连接，截取子串等 第三讲 输入输出 一、介绍数据流的概念 1、流的基本概念 2、字节流 字节是8比特，等价于0-255范围的十进制数。字节是计算机中最基本的编码单位。如字符型是2个字节，浮点型是4个字节。 字符流的顶层包括inputstream和outputstream两个抽象类。可以通过fileinoutstream和fileoutputstream两个子类对文件进行输入和输出。通过datainputstream和dataoutputstream两个子类处理整数、浮点数等数据。 3、字符流 字符流是特殊的字节流，专门用于处理字符数据，目前的字符集通常是unicode，16比特，一个字符是两个字节。 顶层有两个抽象类：reader和writer，有两个最主要的方法：read()，write() 4、预定义流 标准输入流：in 标准输出流：out 出错流：err 举例： 输出一串字符，在显示器上显示出来 二、文件字节流 1、文件字节流的输入输出 常用方法： read()，write(ch)案例1：在显示器上显示文本文件的内容。案例2：复制文件 2、文件字节流的随机访问 常用方法： 1、读数据方法：readInt()readBoolean()readLine() 2、写数据方法：wirteChar()writerDouble() 3、指针控制方法： long getFilePointer();void seek(long pos);int skipBytes(int n)案例：建立一个可读写随机访问文件，写入10个浮点数，然后关闭该文件。再次以读写方式打开该文件，修改其中第3个数据，然后关闭该文件。再次以只读方式打开盖文件，显示文件内容，然后关闭该文件。 三、过滤流 过滤流是对输入输出流提供了一种包装。我们主要介绍一组： DataInputStream DataOutputStream 案例：从键盘输入一些同学的信息，将信息保存到文件中。 四、字符流 五、File类 六、对象的串行化 第四讲 程序控制语句 第五讲 综合练习第六讲 数组 第七讲 函数、函数调用、递归函数 第八讲 综合练习第九讲 类和对象 第十讲 继承、接口和包与异常处理 第十一讲 综合练习第十二讲APPLET、GUI 第十三讲 线程 第十四讲 综合练习 第十五讲 字符串及信息处理的应用 第十七讲 综合练习第二篇：java程序设计实习报告
第三篇：Java程序设计实训报告
第四篇：java程序设计教案
第五篇：Java程序设计教案
点击咨询 