JAVA期末复习资料2
一、判断题
1、在Java程序中发生异常时，JVM会找到每个符合条件的catch都执行一次。（F）
2、在Java程序中异常分为运行时异常和非运行时异常,非运行异常必须进行处理（F）
3、异常处理的try-catch块后必须有finally块。（ F ）
4、异常处理器的排列次序影响处理异常的方法。（T）
5、用catch(Exception exception)语句可以捕获所有异常和错误。（ F ）
6、启动多线程必须调用start()方法, 如果调用run()方法则没有启动新的线程（T）
7、run()方法是运行线程的主体,若run方法运行结束，线程就消亡了。
（T）
8、线程可以用yield()方法使同优先级的线程运行。( T )
9、一个线程创建并启动后，它将执行自己的run()方法。（T）
10、线程可以用yield()方法使较低优先级的线程运行。（F）
11、每个Java线程的优先级都设置在常数1~12之间，默认的优先级设置为常数6。（F ）1~10,默认5
12、JFrame，JPanel，JApplet和JButton四种组件都属于容器组件。
( F )
13、BorderLayout是面板（JPanel）的缺省布局管理器。( F )
14、BorderLayout最多可以使用5个组件。( T )
15、一个面板（JPanel）不能被加入另一个面板（JPanel）中。( F )
16、菜单需要一个JMenuBar对象，以使他们能被添加到JFrame。( T )
17、标签（JLabel）可以在屏幕上显示一个字符或一幅图片。（T）
18、BorderLayout是容器javax.swing.JFrame默认的布局管理器。（T）
19、JTextArea可以用来接收多行文本的输入。（T）
20、在Java坐标系统中，X值从左向右增加。（T）
21、BorderLayout布局管理器把组件排列在北、南、东、西和中间区域。（T）
22、边界布局管理器（BorderLayout）把容器分成5个区域，每个区域只能放一个组件。( T )
23、一个组件可以注册一个或多个事件监听器。( T )
24、通过类https://www.wendangku.net/doc/2c17865112.html,.URL中的成员方法可获得网络资源定位器的相关信息（T）
25、Socket的实例对象调用其成员方法getInputStream来获得该Socket所对应的输入流。（T ）
26、数据报（DatagramPacket）传输是不可靠的，无法保证包按顺序到达。（T）
27、当Socket连接上面的传输结束后，服务器执行Socket的shutdown方法来关闭连接。（F ）
二、选择题
1、下说法中错误的一项是（A ）。
A、线程一旦创建，则立即自动进行
B、线程创建后需要调用start()方法，将线程置于可运行状态
C、调用线程的start()方法后，线程也不一定能立即执行
D、线程处于可运行状态，意味着它可以被调度
2、下列说法中不正确的一项是( A )。
A、Thread类中没有定义run()方法
B、可通过继承Thread类来创建线程
C、Runnable 接口中定义了run()方法
D、可以通过实现Runnable接口来创建线程
3、下列说法中，正确的一项是( C )
A、线程可以不运行于程序中
B、一个程序中只能有一个线程
C、线程必须运行于程序中
D、线程本身就是程序
4、线程开始运行时，是从下列哪一个方法开始执行的( B )
A、main()
B、start()
C、run()
D、init()
5、Runnable接口中定义的方法是( C )
A、start()
B、init()
C、run()
D、Runnable()
6、下列说法中不正确的一项是( B )。
A、多线程并发执行时，各个线程中语句的执行顺序是确定的
B、多线程并发执行时，线程之间的相对执行顺序是确定的
C、线程执行顺序的不确定性会导致执行结果的不确定性
D、线程执行顺序的不确定性会破坏共享数据的一致性
7、下列是继承Thread类后得到的子类，请选择正确的一项。( C )
A、class A4 extends Thread
B、class A4 implements Thread
{ {
void run( ) public void run()
{ {
//….. //…..
} }
} }
C、class A4 extends Thread
D、class A4 extends Thread { {
public void run( ) run( )
{ {
//… //…
} }
} }
8、下面那一个函数是线程的入口函数？ ( B )
A）private void run() B）public void run()
C）public void start() D）public void begin()
9、下列方法中可以用来创建一个新线程的是__C__。
A）实现https://www.wendangku.net/doc/2c17865112.html,ng.Runnable 接口并重写 start()方法
B）实现https://www.wendangku.net/doc/2c17865112.html,ng.Runnable 接口并重写 run()方法
C）继承https://www.wendangku.net/doc/2c17865112.html,ng.Thread 类并重写 run()方法
D）实现https://www.wendangku.net/doc/2c17865112.html,ng.Thread 类并实现 start()方法
10、Thread类中能运行线程体的方法是(D)
A）start() B）resume()
C）init() D）run()
11、在java程序中，下列关于线程的说法错误的是( D )
A、线程启动调用start方法
B、线程的主体是run方法
C、线程运行中调用sleep方法可以进入阻塞状态
D、在java中，优先级的数值为1的线程可以抢占优先级为5的线程的资源
12、若编译和运行下列代码，出现的结果将是 ( A ) public class MyAdd extends Thread{
static int total = 10;
int n;
public MyAdd(int n)
{ this.n=n; }
public void run() {
try{
sleep(n);
total=total+n;
System.out.println(total);
}
catch(Exception e){
System.out.println(“EXCEPTION!”);
}
}
public static void main(String[] args) {
MyAdd t1 = new MyAdd(3000);
MyAdd t2 = new MyAdd(1000);
t1.start();
t2.start();
}
}
A、1010, 4010
B、3010, 4010
C、1010, 3010
D、3010, 1010
13、若编译和运行下列代码，出现的结果将是___D_____
public class MyThread implements Runnable {
String myString = "Yes ";
public void run() {
this.myString = "No ";
}
public static void main(String[] args) {
MyThread t = new MyThread();
new Thread(t).start();
for (int i=0; i < 10; i++)
System.out.print(t.myString);
}
}
A、打印 yes yes yes yes yes yesyes yes yes yes
B、打印 no no no no no no no no nono
C、打印 yes no yes no yes no yes no yes no
D、打印结果无法确定
14、下面关于Java中线程的说法不正确的是( C )?
A)调用join()方法可能抛出异常InterruptedException。
B)sleep()方法是Thread类的静态方法。
C)调用Thread类的sleep()方法可终止一个线程对象。
D)线程启动后执行的代码放在其run方法中。
15、下列关于try和catch子句的描述中，错误的一项是( A )。
A、不同的catch代码段是不同的作用域，但是可以访问相互之间定义的局部变量
B、如果没有异常产生，则所有的catch代码段都被略过不执行
C、try代码段后跟有一个或多个catch代码段
D、异常总是由距离产生异常最近的匹配catch代码段处理
16、下列关于抛出异常的描述中，错误的一项是( C )。
A、异常可以由try代码段中的语句抛出
B、异常可以从被try代码段中调用的方法中抛出
C、异常的抛出并不影响代码段的执行顺序
D、异常还可能产生于数组下标越界及Java虚拟机内部的错误等
17、下列描述中，正确的一项是( D )。
A、异常机制可以用于流程控制
B、finally代码段在发生异常时不一定必须执行
C、在catch代码段中可以使用return语句来返回到异常抛出点
D、可以把catch到的异常对象再次抛出，使上层try—catch结构继续处理该异常事件
18、下列描述中，哪一项不属于finally语句应该执行的功能( C )
A、释放资源
B、关闭文件
C、分配资源
D、关闭数据库
19、如果一个程序段中有多个catch，则程序会按如下哪种情况执行？ ( C )
A、找到合适的异常类型后继续执行后面的catch
B、找到每个符合条件的catch都执行一次
C、找到合适的异常类型后就不再执行后面的catch
D、对每个catch都执行一次
20、对于异常处理语句try…catch，下面那句话不正确？ ( A )
A、一个符合条件的catch的处理语句中没有break语句，则执行后会继续执行后续catch
B、不管有没有捕获异常，finally部分都会被执行
C、找到合适的异常类型后就不再执行后面的catch
D、应该先处理子异常类，再处理父异常类。
21、下列哪种操作不会抛出异常？( B )
A) 浮点数除0 B) 浮点数乘0
C) 打开不存在的文件 D) 用负数索引访问数组
22、程序员将可能发生异常的代码放在（）块中，后面紧跟着一个或多个（）块。( B )
A、catch、try
B、try、catch
C、try、exception
D、exception、try
23、异常包含下列那些内容？( C )
A)程序中的语法错误B)程序的编译错误
C)程序执行过程中遇到的事先没有预料到的情况
D)程序事先定义好的可能出现的意外情况
24、有下列程序
class TestException
{
class MyException extends Exception { }
public void testMethod() throws MyException{}
public void test()
{
testMethod();
}
}
在public void test()后加上哪一句可以使编译不出错。( B )
A、throw MyException
B、throws MyException
C、throw new MyException()
D、throws new MyException()
25、设有以下程序段
class TestException
{
public static void main(String [] args)
{
try{
return;
}finally{
System.out.println("finally");
}
}
}
程序编译并执行，其结果将是( B )
A、程序执行，但没有任何输出
B、程序输出finally
C、程序编译时出错，提示缺少catch
D、程序编译时出错，提示finally语句无法访问到。
26、用文件字节输出流对文件进行写操作时，需要先创建文件输出流对象，文件输出数据流的构造方法是 public FileOutputStream(String name,Boolean append) throws FileNotFoundException，当参数append的值为true时，表示( B )
A、创建一个新文件
B、在原文件的尾部添加数据
C、覆盖原文件的内容
D、在原文件的指定位置添加数据
27、编译和运行下面的应用程序，并在命令行界面输入12345，则回车后屏幕输
出的结果是（ A ）。
public class A {
public static void main(String args[]) throws IOException{
BufferedReader buf=new BufferedReader(
new InputStreamReader(System.in));
String str=buf.readLine();
int x=Integer.parseInt(str);
System.out.println(x%1000);
}
}
A) 345 B)5 C) 123 D) 12345
28、下列说法中，错误的一项是( D )。
A、Java系统的标准输入对象是System.in
B、打开一个文件时不可能产生IOException
C、使用File对象可以判断一个文件是否存在
D、使用File对象可以判断一个目录是否存在
29、下面的程序段的功能是( A )。
File file1=new File("e:\\xxx\\yyy");
file1.mkdir();
A)在当前目录下生成子目录：\xxx\yyy B)生成目录：e:\xxx\yyy
C)在当前目录下生成文件xxx.yyy D)以上说法都不对
30、下列叙述中，错误的是( B )
A）File类能够存储文件
B）File类能够读写文件
C）File类能够建立文件
D）File类能够获取文件目录信息
31、下列哪个是JAVA程序和数据库连接的一种机制 ( B )
A) URL B) JDBC C) SOCKET D) RMI
32、关于JDBC访问数据库的说法错误的是： ( D )
A) 建立数据库连接时，必须加载驱动程序，可采用Class.forName()实现
B) 用于建立与某个数据源的连接可采用DriverManager类的getConnection方法
C) 建立数据库连接时，必须要进行异常处理
D) JDBC中查询语句的执行方法必须采用Statement类实现
33、定义Java.Applet程序时，必须有的import语句是( C )。
A、import java.awt.event；
B、import java.util. * ；
C、import java.applet.Applet；
D、import java.1ang.* ；
34、以下哪个方法不属于Applet小程序生命周期中的方法？（ B ）
A、init
B、main
C、destroy
D、stop
35、下列说法中，错误的一项是( C )。
A、使用FlowLayout在容器中放置组件的策略是：从上到下、从左到右
B、使用FlowLayout进行布局管理时，组件的大小采用的是其最佳尺寸
C、使用FlowLayout进行布局管理时，不能调节组件之间的距离
D、用FlowLayout管理的组件随容器大小变化的变化规律是：组件大小不变，组
件之间的相对位置改变
36、在类中若要处理ActionEvent事件，则该类需要实现的接口是 ( A )。
A、ActionListener
B、Runnable
C、Serializable
D、Event
37、下列说法中，错误的一项是( C )。
A、内部类是被定义于另一个类中的类
B、使用内部类实现监听器，在编程时比较容易实现
C、内部类对象可以访问外部类的成员方法和变量，包括私有成员
D、由于内部类定义于另一个类，因此不适用于AWT的事件处理机制
38、选择正确的语句填入下列程序的横线处。（C）
import javax.swing.*；
public class ex28
{
public static void main(String[]args)
{
JFrame f=new JFrame(“ex28”)；
JMenuBar mb=new JMenuBar( )；
_________________________
JMenu ml=new JMenu(“menul”)；
JMenu m2=new JMenu(“menu2”)；
mb.add(m1)；
mb.add(m2)；
f.setSize(300，100)；
f.setVisible(true)；
}
A、setMenuBar(mB)；
B、mb.setMenuBar( )；
C、f.setMenuBar(mB)；
D、mb.setMenuBar(f)；
39、下列说法哪个是不正确的？( B )
A、一个组件可以注册多个事件监听器
B、一个监听器只能监听一个组件
C、一个组件可以引发多种事件
D、一个监听器可以监听处理多种事件
40、下面说法错误的是( D )
A)单击CheckBox （复选框）产生ItemEvent事件，并由ItemListener处理。
B) 处理JButton和JTextField事件监听器接口都是ActionListener。
C)一个面板(JPanel) 可以加入到另一个面板(JPanel)中。
D)在BorderLayout中，添加到NORTH区的两个按钮将并排显示。
41、下面说法错误的是：( C )
A)单击JCheckBox （复选框）产生ItemEvent事件，并由ItemListener处理。
B) 处理JButton和JTextField事件监听器接口都是ActionListener。
C) 处理鼠标事件的事件监听器接口只有MouseListener。
D) 在JTextField和JPasswordField中输入数据后按Enter键会激发一个事件。
42、下列说法哪个是不正确的？( B )
A)一个面板(Jpanel) 能被加入到另一个面板(Jpanel)中
B)一个监听器只能监听一个组件
C)Frame，Panel，Applet都属于容器组件。
D)Button和TextField都可用ActionListener接口实现事件处理
43、常规菜单是由（）、（）和菜单项组成。( D )
A)JMenuItem、JCheckBoxMenuItem
B)JButton、JRadioButton
C)JPopupMenu、JMenuItem
D)JMenuBar、JMenu
44、下列哪一个方法是自动调整窗口的大小 ( C )
A、setSize()
B、setDefaultClose()
C、pack()
D、setVisible()
45、下列哪个布局管理器使容器中各个构件呈网格布局，并且平均占据容器的空间？( A )
A)GridLayout
B)CardLayout
C)BorderLayout
D)FlowLayout
46、在AWT组建中用复选框组构件CheckboxGroup实现单选框的功能，但在Swing 中，JAVA语言直接提供了一个单选框，它是( C )
A) JButton B) JComboBox C) JRadioButton D) JCheckBox
47、下列叙述中，不符合JAVA语言特点的选项是( C )
A、可移植性和跨平台的特点
B、多线程的并发机制
C、编译器将JAVA源程序转换成机器码
D、Applet是JAVA的特殊应用程序，它嵌入到HTML中，随主页发布到互联网上
48、JPanel和Applet的默认布局管理器是( B )
A）CardLayout
B）FlowLayout
C）BorderLayout
D）GridLayout
49下列语句错误的是：( D )
A、ServerSocket svrsoc＝new ServerSocket(8000);
B、URL urlBase=new URL(“http://www. https://www.wendangku.net/doc/2c17865112.html,/”) ;
C、File inFile = new File(“C:/ test.txt”);
D、BufferedReader br = new BufferedReader(“C:/ test.txt”);
三、程序填空题
1、通过TCP协议方式，定义一个服务器端，端口为5000，要求可以同时连接多个客户端，并且每个客户端在休眠10秒钟之后退出连接；将下面的程序补齐：Import https://www.wendangku.net/doc/2c17865112.html,.*;
Import java.io.*;
public class ServerExample implements （1）_Runnable_______{
private Socket m_socket;
private int m_id;
public （2）_ServerExample_(Socket s, int id) {
m_socket= s; m_id= id;
}
public void （3）___run()____{
try {（4）____Thread___. sleep(10000);
System.out.println("Socket["+m_id+"] is closing.");
m_socket.close();
} catch (Exception e) {}
}
public static void main(String args[]){
int n= 1;
_（5）___ServerSocker______ server= null;
try{
server= new （6）___ServerSocker_________(5000);
System.out.println( "Server start." );
}
catch (IOException e){}
while (true){
try{
System.out.println("Wait NO. "+n+" connection." );
（7）___Socket______ s= server.accept( );
ServerExample t=new ServerExample(s, n++);
（8）__Thread_______ th =new Thread(t);
（9）____th__.start( );
}
catch (IOException e){}
} // End of loop: while
} // End of method: main
}
2、下面是一个支持多个客户端交互的程序，请根据注释要求补充、完成代码：Import java.io.*;
（1）_import https://www.wendangku.net/doc/2c17865112.html,.*;_______ //加载网络API包
public class ServerThread extends Thread{
Socket socket=null;
int clientnum;
publicServerThread(Socket socket,int num) {
this.socket=socket;
clientnum=num+1;
}
public void run() {
try{
String line;
InputStream in=（2）__socket.getInputStream();_//得到socket的输入流BufferedReader is=new BufferedReader(new InputStreamReader(in)); PrintWriter os=new PrintWriter(socket.getOutputStream());
//由系统标准输入设备构造BufferedReader对象
BufferedReader sin=new BufferedReader
(（3）_new InputStreamReader(System.in)__);
System.out.println("Client-"+ clientnum +":" +is.readLine());
line=sin.readLine();
while(!line.equals("bye")){
os.println(line);
//刷新输出流，使Client马上收到该字符串
（4）_os.flush();___________
System.out.println("Server:"+line);
System.out.println("Client-"+ clientnum +":" +is.readLine());
line=sin.readLine();
}
os.close();//关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket对象
}catch(Exception e){
System.out.println("Error:"+e.toString());
}
}
}
3、定义类ThdTest，其父类为Thread类；并在主方法中创建一个ThdTest的对象，同时启动该线程对象。
//声明类ThdTest，其父类为Thread类
(1)_class ThdTest extends Thread__________________
{
public void run(){
for(int i = 0; i < 10; i++){
(2)_System.out.println(Thread.currentThread().getName()
+“:”+i);__//输出当前线程的名字和i的值
try{
（3）_Thread.sleep();__//让当前线程休眠100ms
}catch(Exception e){ e.printStackTrace ();}
}
}
}
public class Demo{
public static void main(String[] args){
（4）___ThdTest tt=new ThdTest();___//创建一个ThdTest的对象
（5）____tt.start();____//启动线程对象，使其进入就绪状态
}
}
4、下面的程序利用线程输出从a到z的26个字母，每隔一秒钟输出一个字母，程序不完整，请阅读程序代码，根据注释要求在划线处补充完成代码。
public class Test4 implements Runnable
{
charcharArray[]=new char[26];
public Test4()
{
for(int i = 0; i { charArray[i]=(char)(i+'a'); } } public void run() { try { for (int i = 0; i { （1）__Thread.sleep(1000);__________//休眠一秒钟 System.out.print(charArray[i]); } } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String args[]) { Thread t = _（2）_new Thewad(new Test4());__//实例化线程对象（3）_____t.start();___________//启动线程 } } 5、定义类ThdDemo，实现接口Runnable；并在主方法中创建一个ThdDemo的对象td，然后使用对象td创建一个线程对象，同时启动该线程对象。 //声明类ThdDemo，实现接口Runnable (1)_class TheDemo implements Runnable_______ class ThdDemo implements Runnable{ public void run(){ for(int i = 0; i < 10; i++){ //输出当前线程的名字和i的值 System.out.println(Thread.currentThread().getName() + “:” + i); try{ (2)_Thread.sleep(100);__//让当前线程休眠100ms }catch(Exception e){ e.printStackTrace ();} } } } public class Demo{ public static void main(String[] args){ _(3)__ThdDemo td=new ThdDemo();____//创建一个ThdDemo的对象td _(4)__Thread t=new Thread(td);___________//使用td创建线程对象 _(5)____t.start();___________//启动线程对象，使其进入就绪状态 } } 6、制作一个Applet小应用程序，设置其布局为BorderLayout，定义一个按钮和多行文本框并分别放到“North”区域和“Center”区域。创建网页文件运行这个Applet程序。 import java.applet.*; import javax.swing.*; _(1)_class AppletDemo extends Applet implements ActionListener_//声明AppletDemo类，其父类为Applet，并实现接口ActionListener { JButton btn; JTextArea txt; public void init(){ _(2)___setLayout(new BorderLayout());____//设置其布局为BorderLayout btn = new JButton(“Show Msg”); txt = new JTextArea(3, 20); __add(btn,”North”);_____ //把按钮btn放到“North”区域，txt放到“Center”区域 (3)__add(txt,”Center”);_____ _(4)___btn.addActionListener(this);__________//给按钮注册监听器 } public void actionPerformed(ActionEvent e){ txt.append(btn.getText()); } } 网页文件为： 7、编写程序实现窗口，包含一个标签、一个文本框和一个按钮，当用户单击按钮时，程序把文本框中的内容提制到标签中。（使用AWT） (1)import java.awt.event.*; Import java.awt.*;//引入相关包 publicMyFrame{ publicMyFrame(){ Frame fr = new Frame(); //设置窗体的布局为FlowLayout (2)fr.addLayout(new FlowLayout()); Label lbl = new Label(“Init info”); TextField txt = new TextField(30); Button btn = new Button(“Sure”); fr.add(lbl); fr.add(txt); fr.add(btn); //给按钮注册监听器 (3)Btn.addActionListner(new Monitor()); //使用窗体可见，并设置大小 (3)fr.setVisible(true);fr.setSize(300,400); } //定义内部类监听ActionEvent事件 (4)class Monitor implements ActionEvent { public void actionPerformed(ActionEvent e){ lbl.setText(txt.getText()); } } public static void main(String[] args){ newMyFrame(); } } 8、设计程序实现带菜单的窗口，包含“File”和“Edit”二个菜单，在“File”下又包含“New”, “Open”, “Exit”三个菜单项，选择“Exit”项时退出应用程序。（提示：涉及到的类有MenuBar, Menu, MenuItem） importjava.awt.*; importjava.awt.event.*; public class MenuTest{ //定义各菜单项 MenuItem newItem = new MenuItem(“New”); MenuItem openItem = new MenuItem(“Open”); MenuItem exitItem = new MenuItem(“Exit”); public MenuTest(){ Frame fr = new Frame(); //定义菜单 Menu fileMenu = new Menu(“File”); Menu editMenu = new Menu(“Edit”); //往File菜单中添加菜单项newItem, openItem, exitItem (1)fileMenu.add(newItem); fileMenu.add(openItem); fileMenu.add(exitItem); //定义菜单条，并添加菜单fileMenu, editMenu (2)MenuBar bar=new MenuBar(); bar.add(fileMenu); bar.add(editMenu); //给窗口添加菜单条 fr.setMenuBar(bar); //给exitItem注册事件 (3)_exitItem.addActionListener(new MenuHandler());______ //设置窗口的可见性 fr.setSize(200,200); //fr.setVisible(true); } //定义内部类处理菜单事件 class MenuHandler implements ActionListener{ public void actionPerformed(ActionEvent e){ //如果用户点击了exit菜单项则退出程序 (4)_if(e.getSource()==exitItem)_____ System.exit(0); } } //定义main方法 (5)_public static void main(String[] args) {new MenuTest();}__________________ } 9、写程序实现包括一个复选框的窗体，并处理用户选取事件。 importjava.awt.*; importjava.awt.event.*; (1) class MyCheck extends Frame//类声明，类名为MyCheck，继承自Frame 类 { //类体 public MyCheck(){ (2)__Panel p=new Panel(); p.addLayout(new FlowLayout());_//创建Panel的一个实例，并设置其布局为FlowLayout Checkbox cbx = new Checkbox(“isPassed”); (3)__p.add(cbx);_ _cbx.addActionListener(new Mt());_____________ //向面板中加入组件cbx，并为组件注册监听器 add(p); (4)__setVisible(true);_setSize(200,400);__ //把窗体设为可见，并设置大小 } public static void main(String[] args){ newMyCheck(); } //定义内部类实现监听，相应的监听接口为ItemListener (5) __class Mt implements ActionListener_____//内部类的声明 { public void itemStateChanged(ItemEvent e){ System.out.println(e); } } } 10、制作一个窗体，包括一个带图标的按钮（JButton类对象），并设置边框，当用户点击按钮时，弹出一个确认对话框。 importjavax.swing.*; importjavax.swing.border.*; importjava.awt.*; class ViewDemo{ JFrame fr; public ViewDemo(){ //用ImageIcon类包装一张图片(java.gif)， //该图片在当前目录的img子目录下 (1)__ImageIcon ii=new ImageIcon(“java.gif”);___________________ //创建一个带有图标的按钮btn (2)_JButton btn =new JButton(ii);___________________________ /**使用线形边框类的构造方法LineBorder(Color c, int n)， *创建一个边框对象bd，其中c为边框的颜色，n为边框的粗细。 */ (3)__LineBorder bd =new LineBorder(new Color(0,0,0)，5)； btn.setBorder(bd); //给按钮注册监听事件 (4)__btn.addActionListener(new BtnHandler());____________________ fr = new JFrame(); Container c = fr.getContentPane(); c.add(btn); fr.setSize(300,300); fr.setVisible(true); } class BtnHandler implements ActionListener{ public void actionPerformed(ActionEvent e){ String msg = "Are you sure?"; /*使用JOptionPane类的静态方法showConfirmDialog(Frame f, String s)，其中f为对话框所属的窗体，s为对话框显示的信息，弹出一个确认对话框。*/ (5)__JOptionPane.showConfirmDialog(new Frame(),msg);___________ } } } 11、以下程序的功能为：读入从键盘输入的一串字符存放于一个字节数组中，然后将该数组写入到当前目录下的文件out.txt中。 import__java.io.*;______________ public class byteArraytofile{ public static void main(String[] args){ try{ byte buffer[]=new ___byte____[128]; FileOutputStream fos= new FileOutputStream(____”out.txt”______); System.in.read(buffer); fos.write(_____buffer_____,0,buffer.length); fos.close(); } catch(__IOException e__ ){} } } 四、程序阅读题 1、掌握数据库的操作 import java.sql.*; class Test_JDBC { public static void main(String[] srg) { String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; String dbURL = "jdbc:sqlserver://localhost:1433; DatabaseName=DATA_TEST"; String userName = "sa"; String userPwd = "123456"; Connection dbConn=null; Statement stat=null; ResultSet rs=null; String sql="select * from student"; try { Class.forName(driverName); dbConn = DriverManager.getConnection(dbURL, userName, userPwd); stat=dbConn.createStatement(); rs=stat.executeQuery(sql); while(rs.next()) { System.out.println(rs.getInt(1)); System.out.println(rs.getString(2)); } } catch (Exception e) { e.printStackTrace(); } } } 2、掌握列表的操作 import java.util.*; class IteratorDemo2 { public static void main(String args[]){ //我们先往链表中装东西 ArrayList a.add("东西1"); a.add("东西2"); a.add("东西3"); a.add("东西4"); a.add(2,"东西5"); //从链表中取东西怎么办呢，自然就用到了迭代器 //用法是这样的 Iterator while(iter.hasNext()){ //先往左数，如果有东西就执行{}里的语句 String m = iter.next(); //数到什么就拿出来赋值给m System.out.println(m); //拿出m用一下，即打印 } } } 3、写出下列程序的作用我不会做，你们自便！ import java.io.IOException; import https://www.wendangku.net/doc/2c17865112.html,.Socket; class Scan extends Thread{ private int[] p; Socket ss = null; public Scan(int[] p) { this.p = p; } public static void main(String[] args) { for(int i=0;i<5000;i=i+1000){ new Scan(new int[]{ i+1,i+1000 }).start(); } } public void run() { System.err.println("启动线程"); for(int i=p[0]; i try { ss = new Socket("127.0.0.1",i); System.err.println("这是你想要的数据： " + i); } catch (IOException e) { e.printStackTrace(); } } } } 4、写出下列程序代码的运行结果： class userException extends Exception{ userException: 数组可能越界！ userException(){} 退出返回！ userException(String str){ super(str); } } class MyException { final static int ARRAY_MAX_LENGTH=10; void judge(int []a){ try{ if(a.length System.out.println("数组的长度没有超过规定的最大值!"); } throw new userException("数组可能越界！"); } }catch(userException e){ System.out.println(e.toString()); } finally{ System.out.println("退出返回！"); } } public static void main(String agrs[]){ try{ int a[]=new int[10]; MyException myE=new MyException(); myE.judge(a); }catch(Exception e){ System.out.println(e.toString()); } } } 5、写出下列程序代码的运行结果： class MinusException extends Exception { 张三的工资为1000元。 int number; 异常:工资不能为负！ public MinusException (String msg, int i) { super(msg); this.number = i; } } class Salary { private String name; private int salary; public Salary(String n, int s ) throws MinusException { https://www.wendangku.net/doc/2c17865112.html,=n; if (s<0) throw new MinusException("工资不能为负！",s); this.salary=s; } public void print() { System.out.println(name+"的工资为"+salary+"元。"); } } class TestSalary { public static void main(String [] args) { Salary s1=new Salary(“张三”,1000); s1.print( ); Salary s2=new Salary(“李四”,-10); s2.print( ); } catch(MinusException e) { System.out.println("异常:"+e.getMessage()); } } } 6、仔细阅读下面的程序代码，编译和运行后，请写出该程序的输出结果。class TestException 1,200.45 { 参数错误！要求是数字格式！ public static String toSeparateNumber(String number) { String formatedNumber=""; try { double n=Double.parseDouble(number); //double=1200.45 number=Double.toString(n); int i=number.indexOf('.'); //在number字符串中找到字符.的位置在第4个 if (i>=0) { formatedNumber=number.substring(i,number.length());//截取字符串从4开始，到7结束 i=i-1; } else i=number.length()-1; int k=0; for (int j = i; j>=0; j--) //i=3 { formatedNumber=number.charAt(j)+formatedNumber; //charAt(j)是取指定位置的字符，就是去3位置上的字符与formatedNumber(.45)合并 k=(k+1)%3; if (k==0 && j!=0) formatedNumber=","+formatedNumber; // 得到最后结果1,200.45 } } catch(NumberFormatException e) { System.out.println ("参数错误！要求是数字格式！"); 信息工程学院1 Java程序设计实验/实习报告 学院: 班级:地信姓名: 学号:2 成绩:A 面向对象编程 一、实验/实习过程 （一）实验目的 掌握Java程序面向对象编程的基本架构，会运用面向对象的思想编写Java程序。（二）实验过程 【实验题1】完成如下程序，完成思考题 [基本要求] 运行程序并观察运行结果。 [思考问题] 试述程序中主要语句的作用 运行结果： 主要程序语句的作用已标注为注释： class CCircle // 类的声明 { double pi; //申明成员变量 double radius; //申明成员变量 double getRadius() //创建方法 实验报告的内容与格式按任课教师的要求书写。 { return radius; //返回 radius } void setCircle(double r, double p) //创建方法 { pi=p; //初始化数据成员 radius=r; //初始化数据成员 } } public class Ex2_1 //类的声明 { public static void main(String args[]) //主方法 { CCircle cir1=new CCircle(); //创建对象 cir1.setCircle(2.0,3.1416); //调用对象 System.out.println("radius="+cir1.getRadius()); //输出结果 } } 【实验题2】设计一个用来描述汽车的类，使用类的静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。 package zz1; public class Car{ String name; int speed; int jiaodu; public Car(String name,int speed,int jiaodu){ https://www.wendangku.net/doc/2c17865112.html,=name; this.speed=speed; this.jiaodu=jiaodu; System.out.println("车主："+https://www.wendangku.net/doc/2c17865112.html,); System.out.println("车速为："+this.speed); JAVA语言基础内部测试题 一．单项选择题（请选择最符合题目要求的答案）（每题2分） 1.定义类头时，不可能用到的关键字是( )。 A) class B)private C)extends D)public 2.下列类定义中，不正确的是( )。 A)class x { .... } B)class x extends y { .... } C)static class x implements y1,y2 { .... } D)public class x extends Applet { .... } 3.设 A为已定义的类名，下列声明A类的对象a的语句中正确的是( )。 A)float A a; B)public A a=A( ); C) A a=new int( ); D) A a=new A( ); 4.有一个类A，以下为其构造方法的声明，其中正确的是( )。 A)public A(int x){...} B)static A(int x){...} C)public a(int x){...} D)void A(int x){...} 5.下列语句哪一个正确（） A)Java程序经编译后会产生machine code B)Java程序经编译后会产生byte code C)Java程序经编译后会产生DLL D)以上都不正确 6.下列选项中，定义接口MyInterface的语句正确的是：（） A)interface MyInterface{ } B) implements MyInterface { } C) class MyInterface{ } D) implements interface My{ } 7.如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定 义如下：void mymethod(int a)，则子类方法的定义不合法的是：（） A)public void mymethod(int a) B)protected void mymethod(int a) C)private void mymethod(int a) D)void mymethod(int a) 8.在异常处理中，如释放资源、关闭文件、关闭数据库等由( )来完成。 A.try子句 B.catch子句 C.throw子句 D.finally子句 9.给定以下JAVA代码，这段代码编译运行后输出的结果是（） public class Test { public static int aMethod(int i) throws Exception { try{ return i/10; }catch(Exception ex){ throw new Exception ("exception in a aMothod"); }finally{ System.out.print("finally"); } } package cn.Testcx; import java.util.Scanner; public class lesson2 { public static void main(String[] args){ @SuppressWarnings("resource") Scanner input =new Scanner(System.in); System.out.print("请输入一个摄氏温度："); double Celsius =input.nextDouble(); double Fahrenheit =(9.0/5)*Celsius+32; System.out.println("摄氏温度："+Celsius+"度"+"转换成华氏温度为："+Fahrenheit+"度"); System.out.print("请输入圆柱的半径和高："); double radius =input.nextDouble(); int higth = input.nextInt(); double areas =radius*radius*Math.PI; double volume =areas*higth; System.out.println("圆柱体的面积为："+areas); System.out.println("圆柱体的体积为："+volume); System.out.print("输入英尺数："); double feet =input.nextDouble(); double meters =feet*0.305; System.out.println(feet+"英尺转换成米："+meters); System.out.print("输入一个磅数："); double pounds =input.nextDouble(); double kilograms =pounds*0.454; System.out.println(pounds+"磅转换成千克为："+kilograms); System.out.println("输入分钟数："); long minutes =input.nextInt(); long years =minutes/(24*60*365); long days = (minutes%(24*60*365))/(24*60); System.out.println(minutes+"分钟"+"有"+years+"年和"+days+"天"); long totalCurrentTimeMillis =System.currentTimeMillis(); long totalSeconds =totalCurrentTimeMillis/1000; long currentSeconds =totalSeconds%60; long totalMinutes =totalSeconds/60; long currentMinutes =(totalSeconds%(60*60))/60; long currenthours =(totalMinutes/60)%24; System.out.print("输入时区偏移量："); byte zoneOffset = input.nextByte(); long currentHour =(currenthours+(zoneOffset*1))%24; System.out.println("当期时区的时间为："+currentHour+"时"+currentMinutes+"分"+currentSeconds+"秒"); 1.设计一个名为figure的图形软件包（package）。包中包 含三角形、矩形、圆三个类。要求：（1）每个类都要构造 方法并为成员设置get和set方法；（2）每个类都要有计 算周长和面积的成员方法；（3）完成该软件包后的编码后， 在另一个包的含有main方法的类中编写代码，分别使用 图形软件包中的三个类，生成三个对象，并打印出其周长 和面积。 ****************************************************** package figure; public class juxing{//矩形的计算函数 private double lenth,width; public juxing(){ lenth=0; width=0; } public juxing (double x,double y){ lenth=x; width=y; } public void setLenth(double lenth){ this.lenth=lenth; } public double getLenth(){ return lenth; } public void setWidth(double width){ this.width=width; } public double getWidth(){ return width; } public double perimeter(){ return lenth*width; } public double Area(){ return (lenth+width)*2; } } ****************************************************** package figure; import java.math.*; public class sanjiaoxing {//三角形的计算函数 private double side1; private double side2; private double side3; public sanjiaoxing(){ side1=0; side2=0; side3=0; } public sanjiaoxing(double x,double y,double z){ side1=x; side2=y; side3=z; } public void setSide1(double side1){ this.side1=side1; } public double getSide1(){ return side1; } public void setSide2(double side2){ this.side2=side2; } public double getSide2(){ return side2; } public void setSide3(double side3){ this.side3=side3; } public double getSide3(){ return side3; } public double perimeter(){ return side1+side2+side3; } public double Area(){ double p=(side1+side2+side3)/2; return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3)); } } ****************************************************** package figure; import java.math.*; public class yuanxing {//圆形的计算函数 Java iSW程序设il?（郑莉） 第二章习题答案 1.什么是对象、类，它们之间的联系 答：1）对象是包含现实世界物体特征的捕象实体，它反映系统为之保存信息和与它交互的能力。对象是一些属性及服务的封装体，在程序设计领域，可以用“对象二数据+作用于这些数据上的操作”来表示。现实生活中对象是指客观世界的实体：在程序中对象是指一组变量和相关方法的集合。 2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！ 3）两者的关系：对象是类的具体实例 2.什么是而向对象的程序设计方法它有那些基本特征 答:而向对象程序设计从所处理的数据入手，以数抵为中心而不是以服务为中心来描述系统。 它把编程问题视为一个数据集合，数据相对于功能而言，具有更强的稳世性。 它的特征：抽象，封装，继承，多态。 3.在下而的应用中，找出可能用到的对象，对毎一个对象，列出可能的状态和行为。 1）模拟航空预订系统交易的程序 2）模拟银行交易的程序 答：1）航空预订交易： 状态：旅客姓名，身份证号，联系号码，出发地址，抵达地址，出发日期。 行为：订票，领票，买票，退票。 2）银行交易： 状态：客户姓名，账号，身份证号。 行为：存款，取款，『款。 4.请解释类属性、实例属性及其区别。 答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。 5.请解释类方法、实例属性及其区别。 答：实例方法表示特定对象的行为，在声明时前而不加static修饰符，在使用时需要发送给一个类实例。 类方法也称为静态方法，在方法声明时前而需加static修饰符，类方法表示具体实例中类对象的共有行为。 区别：实例方法可以宜接访问实例变量，调用实例方法，实例方法可以直接访问类变量, 调用类方法：类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法： 6.类的访问控制符有哪几种具体含义及其区别。 答：类的访问控制符只有public （公共类）及无修饰符（默认类）两种。 区別：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与 第一章 1.Given the following, 1. interface Base { 2. boolean m1 (); 3. byte m2(short s); 4. }Which code fragments will compile?(Choose all that apply.) A.interface Base2 implements Base { } B.abstract class Class2 extends Base { public boolean ml() { return true; } } C.abstract class Class2 implements Base { } D.abstract class Class2. implements Base { public boolean m1() { return (true); } } E.class Class2 implements Base { boolean m1( ) { return false; } byte m2(short s) { return 42; } } 2. Which declare a compilable abstract class? (Choose all that apply.) A.public abstract class Canine { public Bark speak(); } B.public abstract class Canine { public Bark speak() { } } C.public class Canine { public abstract Bark speak(); } D.public class Canine abstract{ public abstract Bark speak(); } 3. Which is true? (Choose all that apply. ) A."X extends Y" is correct if and only if X is a class and Y is an interface. B."X extends Y" is correct if and only if X is an interface and Y is a class. C."X extends Y" is correct if X and Y are either both classes or both interfaces. D."X extends Y" is correct for all combinations of X and Y being classes and/or interfaces. 4. Which are valid declarations? (Choose all that apply.) A.int $x; B.int 123; C.int _123; D.int #dim; E.int %percent; F.int *divide; G.int central_sales_region_Summer_2005_gross _sales 第二章 1. Which statement(s) are true? (Choose all that apply.) A.Has-a relationships always rely on inheritance. B.Has-a relationships always rely on instance variables. C.Has-a relationships always require at least two class types. D.Has-a relationships always rely on polymorphism. E.Has-a relationships are always tightly coupled. 2.Given: class Clidders {public final void flipper() { System.out.println("Clidder"); }} public class Clidlets extends Clidders { public void flipper() { System.out.println("Flip a Clidlet"); super.flipper(); } public static void main(String [] args) { new Clidlets().flipper(); } } What is the result? A.Flip a Clidlet B.Flip a Clidder 华北电力大学 实验报告 实验名称Java程序面向对象设计（一）课程名称Java程序设计 专业班级：学生姓名： 学号：成绩： 指导教师：张学斌实验日期： 一、实验目的及要求 1.掌握类的定义。 2.掌握成员变量和成员方法的定义。 3.掌握构造方法的定义和使用。 4.掌握类的多态性 二、实验环境 Windows2000/Windows XP，JDK 1.2~1.6 三、试验内容和步骤 要求按照实验内容，写出详细实验过程和步骤，必要时截图。 实验1 机动车 1.1实验要求 编写一个Java应用程序，该程序有两个类：Vehicle（用于刻画机动车）和User（主类）。具体要求如下： Vehicle类有一个double类型的变量speed,用于刻画机动车的速度，一个int型变量power，用于刻画机动车的功率。定义了speedUp(int s)方法，体现机动车有加速功能。定义了speedDown()方法，体现机动车有减速功能。定义了setPower(int s),用于设置机动车的功率。定义了getPower()方法，用于获取机动车的功率。 在主类User的mian()方法中用Vehicle类创建对象，并让该对象调用方法设置功率，演示加速和减速功能。 1.2程序模板 Vehicle.java public class Vehicle { 【代码1】//声明double型变量speed,刻画速度 【代码2】//声明int型变量power,刻画功率 void speedUp(int s) { 【代码3】//将参数s的值与成员变量speed的和赋值给成员变量speed } void speedDown(int d) { 【代码4】//将成员变量speed与参数d的差赋值给成员变量speed } void setPower(int p) { 【代码5】//将参数p的值赋值给成员变量power } int getPower() { 【代码6】//返回成员变量power的值 《JAVA程序设计》期末考试试题（二） 一．判断题 1．Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。（√）2．Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。（×）分析: java中没有回收（FREE）内存的功能, 它会自动回收的, 只要把对象close掉就等着回收就行了. 由于对象是使用new运算符动态分配的，java方法是自动为你的处理存储单元重新分配问题。完成这项工作的技术被称为无用单元收集（garbage collection)。它的工作原理：当不存在对一个对象的引用时，我们就假定不再需要那个对象了，那个对象所占有的存储单元可以被收回。在java中并不像在C++中一样需要明确地销毁对象。无用单元收集仅在偶尔执行程序时出现。它不会出现，是因为存在一个或多个不再使用的对象。还有，不同的Java运行时实现将会使用不同的无用单元收集方法，但是在大多数情况下，在编程时不必考虑它。如果一个对象正在持有某些非Java资源，如文件处理或窗口字符字体，那么Java提供了一种称为结束（finalization）的机制。 3．Java有垃圾回收机制，内存回收程序可在指定的时间释放内存对象。（×） 分析: 不对，JAVA虽然有垃圾回收机制，但是不能在指定的时间释放内存对象，只能在程序运行期间，当虚拟机空闲的时候回收。 4．构造函数用于创建类的实例对象，构造函数名应与类名相同，返回类型为void。（×）分析: 无返回类型 5．在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch 中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。（√） 分析: 个人觉得原因是子类更加具体一些, 可以更好得描述这个异常, 所以会把子类写在前面, 如果把父类写在前面, 那么这个父类就会接受很多的异常了, 后面的子类就接收不到了6．拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法。（√） 7．Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。（×） 分析: 左上角被确定为坐标的起点 8．静态初始化器是在其所属的类加载内存时由系统自动调用执行。（√） 9．在Java中对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象。（×） 分析: 并不是生成一个新对象, 只是引用相同而已, 真正的对象的空间是一样的. 二．单项选择题 1．Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（）A、String args B、String ar[] C、Char arg D、StringBuffer args[] 分析: 比较常见的是String[] args, 但是String args[]也是可以的, ar和args并没有什么区别. 2．以下关于继承的叙述正确的是（）。 A、在Java中类只允许单一继承 B、在Java中一个类只能实现一个接口 C、在Java中一个类不能同时继承一个类和实现一个接口 D、在Java中接口只允许单一继承 3．paint()方法使用哪种类型的参数? （） A、Graphics B、Graphics2D C、String D、Color 分析:这是GUI里面的, 不考. 第二章Java编程基础 案例2-1 定义不同类型的变量 一、案例描述 1、考核知识点 编号：00102005 名称：变量的定义及其数据类型 2、练习目标 了解变量的定义方式 掌握如何为不同类型的变量赋值 3、需求分析 变量用于存储程序运行期间的一些数据。为了加深初学者对变量的认识，本案例针对八种基本数据类型，分别定义了八个变量，并进行赋值操作。 4、设计思路（实现原理） 1）编写一个类Example01。 2）在Example01的main()方法中，针对八种基本数据类型，分别定义变量并赋值。 3）使用println语句打印变量的值。 二、案例实现 定义Example01类，其代码如下： class Example01{ public static void main(String[] args) { //定义字节变量 byte b = 12; System.out.println(b); //定义短整型变量 short s = 1234; System.out.println(s); //定义整数变量 int i = 12345; System.out.println(i); //定义长整型变量 long l = 12345678912345L; System.out.println(l); //定义单精度类型(7-8位的有效数字) float f = 12.5F; System.out.println(f); //定义双精度类型(15-16 位的有效数字) double d = 12.5; System.out.println(d); //定义字符类型 char c = 'a'; //重新赋值,Java 中的字符采用的编码是Unicode 编码。占用2个字节。 c = '中'; System.out.println(c); //定义布尔类型 boolean flag = true; System.out.println(flag); } } 运行结果如图2-1所示。 图2-1 运行结果 三、案例总结 1、Java 对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，并且变量值的类型和变量类型必须一致，否则程序会报错。 2、byte 类型的变量存储的值必须是-27 ～ 27-1之间的整数。赋值的时候，尽量不要超出范围，如果超出可能损失精度。 3、定义变量的方式有两种，具体如下： 方式一： 数据类型 变量名 = 初始化值; 方式二： 数据类型 变量名; 变量名 = 初始化值; 案例2-2 变量的自动类型转换 一、案例描述 1、 考核知识点 1 (2) 2.输入和输出数据，JOptionPane类，Scanner类; (2) 3.产生随机数 (3) 4.数学类Math (3) 1)三角函数方法： (3) 2)指数函数方法： (4) 3)取整方法： (4) 4)min\max和abs方法 (5) 5.Arrays类 (5) 6.Random类 (6) 7.GregorianCalendar类 (7) 8.String类 (7) 7)字符串转换为一个字符数组 (9) 8）将字符串转换为字符数组 (9) 1. 1)调用System.currentTimeMillis()方法获得从1970年1月1日0点到现在的毫秒数; 2)System.exit(0);是个静态方法，它在System类中定义。调用这个方法 可以终止程序，参数0表示程序正常结束。 3)String s=String.format(“counts is%d and amount is%f”,5,45.56); System.out.println(s); 相当于：System.out.println(“counts is%d and amount is%f”,5,45,56); 4)对于void方法，return语句是不需要的，但它能用于终止方法并返回到方法的调用者。 5) 2.输入和输出数据，JOptionPane类，Scanner类; 输入： Javax.swing.JOptionPane; String input=JOptionPane.showInputDialog(null,x,y,JOptionPane.QUESTION_MESSAGE) ; String input=JOptionPane.showInputDialog(x); 使用确认对话控制循环： int option=JOptionPane.showConfirmDialog(null,”continue”); Yes按钮返回JOptionPane.YES_OPTION(0), No按钮返回JOptionPane.NO_OPTION(1), Canel按钮返回JOptionPane.CANCEL_OPTION(2); Scanner scanner=new Scanner(System.in); String str=scanner.next();//读取一个字符串。字符串用空格分隔 实验 2 Java 基本语法练习 一、实验目的 1．了解Java 的数据类型 2．掌握各种变量的声明方式。 3．理解运算符的优先级。 4．掌握Java 基本数据类型、运算符与表达式。 5．理解Java 程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法。 6．通过以上内容，掌握Java 语言的编程规则。 二、实验要求 1. 编写一个声明Java 不同数据类型变量的程序。 2. 编写一个使用运算符、表达式、变量的程序。 3. 编写一个使用Java 数组的的程序。 4. 编写表达式语句、复合语句的程序。 5. 编写使用不同选择结构的程序。 6. 编写使用不同循环结构结构的程序。 三、实验内容 （一）声明不同数据类型的变量 1．编写声明不同数据类型变量的程序文件KY2_1.java，源代码如下。 2．编译并运行该程序 （二）了解变量的使用范围 1．建立KY2_2.java 文件，通过本程序了解变量的使用范围，源代码如下。 2．编译KY2_2.java 此时会出现错误提示。因为变量k 在方法块中声明，在方法块之外它是不存在的，所以编译时会出错。 3．修改上面的程序。 4．成功运行该程序。 思考：KY2_2.java 程序说明了什么问题？ （三）使用关系运算符和逻辑运算符 1．建立使用关系运算符和逻辑运算符的程序文件，源代码如下。 2．编译并运行该程序。 （四）使用表达式语句与复合语句 1．建立包含表达式语句程序，源代码如下。 2．建立包含复合语句程序，源代码如下。 3．编译并运行上述两个源程序 4．将变量i 在块内定义会怎样？改变其他变量的位置看看会发生什么变化。 思考：指出程序的复合结构以及变量的使用范围。 （五）使用选择语句 1．使用if...else 语句 ?程序功能：使用if...else 语句构造多分支，判断某一年是否为闰年。闰年的条件是符合下面二者之一：能被4 整除，但不能被100 整除；能被4 整除，又能被100 整除。 ?编写源程序文件，代码如下。 1、简述java语言的特点？ Java语言是目前使用最为广泛的网络编程语言之一（1分） 具有面向对象（1分） 与平台无关性（1分） 多线程性（1分） 动态性等特点（1分） 2、简述Java程序的开发过程 1使用一个文字编辑器，编写源文件。（1分） 2使用java编译器，编译源文件得到字节码文件。（2分） 3运行java程序，分两种java应用程序必须通过java解释器来解释执行，java小应用程序必须使用解释器和浏览器运行程序。（2 分） 3、java源文件的命名规则是什么？ 如果源文件中有多个类，那么只能有一个类是public类（1分） 如果有一个类是public类，源文件的名字必须与这个类的名字完全相同，扩展名是java （2分） 如果源文件没有public类，源文件的名字只要和某个类的名字相同，并且扩展名是java （2分） 4、怎样区分应用程序和小应用程序？ 一个java应用程序必须且只有一个类含有main方法，这个类称为应用程序的主类，其 main 方法必须被说明为public static void （1分） —个Java Applet小应用程序不再需要main方法，但必须有一个类扩展了Applet类，即它是Applet类的主类。（2.5分） 5、Java中共有哪些基本数据类型？ 基本类型共有8种，分四类分别是（1分） 逻辑型（1分） 字符型（1分） 整型（1分） 浮点型（1分） 6、Java中数据类型分别用什么符号来表示？ 逻辑型用boolean表示（1分） 字符型用char表示（1分） 整型共有4种分别是byte、short、long、int （2分）浮点型共两种float和double （1分） 7、简答标示符的根I念及定义原则 标示符是用来标识类名、变量名、方法名、类型名等有效字符序列。（2.5分） Java语言规定标示符由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字，及java 中的关键字不能用作标示符。（2.5分） &简答什么是强制类型转换及转换格式 较少的变量的值赋给占字节较多的变量时, 系统自动完成数据类型的转换（2.5分） 格式数据类型名变量名或表达式（2.5 分） ++X表示在使用x之前，先使x的值加1（2.5 分） x++表示在使用x之后，使x的值加1（2.5 分） 当把一种数据类型变量的值赋给另一种数据类型时会用到数据转换。当把在内存中占字节数 9、简答表达式++x和x++的区别 10、Java中常用的运算符按功能分有哪些 Java运算符按功能分6种，具体如下（1分）算术运算符、关系运算符、逻辑运算符（2分）位运算符、赋值运算符、条件运算符（2分） 11、Java中结构化程序设计有哪三种基本流程及分别对应java中那些语句 结构化程序设计有顺序、分支、循环三种基本流程（2分） java中的分支语句包括if语句、switch语句（1分） 循环语句包括while语句、do?while语句、for?语句（1分） 其他如对象、变量定义语句、赋值语句、方法调用语句等都是顺序语句。（1分） 12、在一个循环中使用break和continue语句有什么不同的效果？ 在循环中使用break语句将使循环终止，流程跳转到break语句所在的循环外面的第一个语 句继续执行（2.5分） 在循环中使用continue语句将提前结束本次循环，流程跳转到continue语句所在循环的第 一个语句继续执行（2.5分） 13、package语句与import语句分别作用是什么？ package语句作为java源程序的第一条语句，指明该源文件定义的类所在的包。（2.5分）import语句作用是为了能使用java提供的类，可以使用import语句来引入所需要的类。（2.5 分） 华北电力大学 实验报告实验名称Java程序面向对象设计（一）课程名称Java程序设计 专业班级：学生姓名： 学号：成绩： 指导教师：张学斌实验日期： 一、实验目的及要求 1.掌握类的定义。 2.掌握成员变量和成员方法的定义。 3.掌握构造方法的定义和使用。 4.掌握类的多态性 二、实验环境 Windows2000/Windows XP，JDK 1.2~1.6 三、试验内容和步骤 要求按照实验内容，写出详细实验过程和步骤，必要时截图。 实验1 机动车 1.1实验要求 编写一个Java应用程序，该程序有两个类：Vehicle（用于刻画机动车）和User（主类）。具体要求如下： Vehicle类有一个double类型的变量speed,用于刻画机动车的速度，一个int型变量power，用于刻画机动车的功率。定义了speedUp(int s)方法，体现机动车有加速功能。定义了speedDown()方法，体现机动车有减速功能。定义了setPower(int s),用于设置机动车的功率。定义了getPower()方法，用于获取机动车的功率。 在主类User的mian()方法中用Vehicle类创建对象，并让该对象调用方法设置功率，演示加速和减速功能。 1.2程序模板 Vehicle.java 【代码1】//声明double型变量speed,刻画速度 【代码2】//声明int型变量power,刻画功率 void speedUp(int s) { 【代码3】 //将参数s的值与成员变量speed的和赋值给成员变量speed } void speedDown(int d) { 【代码4】//将成员变量speed与参数d的差赋值给成员变量speed } void setPower(int p) { 【代码5】 //将参数p的值赋值给成员变量power } int getPower() { 【代码6】 //返回成员变量power的值 } double getSpeed() { return speed; } } ---------------------------------------------------------------------------------------------- User.java 实验报告 班级： 学号： 姓名： 实验二标识符、关键字和数据类型 一、实验目的 1．认识标识符、关键字、运算符及数据类型。 2．掌握标识符的书写格式、常见的基本数据类型以及运算符的使用方式。 3．了解强制数据类型转换和弱类型转换。 二、实验原理 Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。 Java标识符给变量起上一个名字叫做变量名称，这个自定义的变量名称其实就是一个标识符，其实你自定义的类名称也是一个标识符，也就是说你自定义的名称都是标识符，它可以是类的名称、变量的名称、包的名称、方法的名称等。 1. 标识符可以由字母，数字，下划线（__），美元（$）组成，但是不能包含@，%，空格等其他的特殊符号，不能以数字开头。例如 123name 就是不合法的。 2.标识符不能是Java关键字和保留字（Java预留的关键字，或者以后升级版本中有可能作为关键字），但可以包含关键字和保留字~例如：不可以使用void 作为标识符，但是Myvoid 可以。 3.标识符是严格却分大小写的，所以一定要分清alibaba和ALIbaba是两个不同的标识符哦。 4.标识符的命名最好能反应出其作用，做到见名知意。 Java运算符算术运算符、赋值运算符、比较运算符、逻辑运算符、条件运算符。 1.算术运算符：算术运算符主要用于进行基本的算术运算，如加法、减法、乘法、除法等。 2.赋值运算符：赋值运算符是指为变量或常量指定数值的符号。如可以使用“=” 将右边的表达式结果赋给左边的操作数。 3.比较运算符：比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。 4.逻辑运算符：逻辑运算符主要用于进行逻辑运算。 5.条件运算符： 条件运算符（ ? : ）也称为“三元运算符”。 语法形式：布尔表达式？表达式1 ：表达式2。 运算过程：如果布尔表达式的值为true ，则返回表达式1 的值，否则返回表达式2 的值。 Java类型转换：基本数据类型中，布尔类型boolean占有一个字节，由于其本身所代码的特殊含义，boolean类型与其他基本类型不能进行类型的转换（既不能进行自动类型的提升，也不能强制类型转换），否则，将编译出错。 1.基本数据类型中数值类型的自动类型提升。 数值类型在内存中直接存储其本身的值，对于不同的数值类型，内存中会分配相应的大小去存储。如:byte类型的变量占用8位，int类型变量占用32位等。相应的，不同的数值类型会有与其存储空间相匹配的取值范围。 2.基本数据类型中的数值类型强制转换 类的继承习题 一、选择题 1. Java语言的类间的继承关系是( B )。 A) 多重的B) 单重的C) 线程的D) 不能继承 2. 以下关于Java语言继承的说法正确的是( C )。 A)Java中的类可以有多个直接父类B)抽象类不能有子类 C)Java中的接口支持多继承D)最终类可以作为其它类的父类 3. 现有两个类A、B，以下描述中表示B继承自A的是(D)。 A) class A extends B B) class B implements A C) class A implements B D) class B extends A 4. 下列选项中，用于定义接口的关键字是( A)。 A）interface B) implements C) abstract D) class 5. 下列选项中，用于实现接口的关键字是( B)。 A）interface B) implements C) abstract D) class 6. Java语言的类间的继承的关键字是( B )。 A) implements B) extends C) class D) public 7. 以下关于Java语言继承的说法错误的是( A )。 A)Java中的类可以有多个直接父类B)抽象类可以有子类 C)Java中的接口支持多继承D)最终类不可以作为其它类的父类 8. 现有两个类M、N，以下描述中表示N继承自M的是(D)。 A) class M extends N B) class N implements M C) class M implements N D) class N extends M 9. 现有类A和接口Ｂ，以下描述中表示类Ａ实现接口Ｂ的语句是(A)。 A) class Ａimplements B B) class B implements Ａ C) class Ａextends B D) class B extends Ａ 10. 下列选项中，定义抽象类的关键字是( C)。 A）interface B) implements C) abstract D) class 11. 下列选项中，定义最终类的关键字是(D)。 A）interface B) implements C) abstract D) final 12. 下列选项中，哪个是java语言所有类的父类(C) A）String B) Vector C) Object D) KeyEvent 13. java语言中，用于判断某个对象是否是某个类的实例的运算符是（A） A）instanceof B) + C) isinstance D) && 14. 下列选项中，表示数据或方法可以被同一包中的任何类或它的子类访问，即使子类在不同的包中也可以的修饰符是（B） A）public B) protected C) private D) final 15. 下列选项中，表示数据或方法只能被本类访问的修饰符是（C） A）public B) protected C) private D) final 16. 下列选项中，接口中方法的默认可见性修饰符是(A) A）public B) protected C) private D) final 17. 下列选项中，表示终极方法的修饰符是：（B） A）interface B) final C) abstract D) implements 18. 下列选项中，定义接口MyInterface的语句正确的是：（A） A）interface MyInterface{ } B) implements MyInterface { } C) class MyInterface{ } D) implements interface My{ } 19. 如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定义如下：void mymethod(int a)，则子类方法的定义不合法的是：（C） A）public void mymethod(int a) B) protected void mymethod(int a) C) private void mymethod(int a) D) void mymethod(int a) 二、填空题 1. 如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量________了父类的同名变量。（隐藏） 2. 属性的隐藏是指子类重新定义从父类继承来的__________。（同名变量或属性）java实验二
java测试试卷(二)
java语言程序设计基础篇第十版课后答案第二章答案
JAVA实验2复习资料
java第二版第二章答案
JAVA复习资料
Java程序设计-试验2(学生版)
分析《JAVA程序设计》期末考试试题_(二)
第2章 Java编程基础_补充案例
JAVA资料
实验 2 Java 基本语法练习
java程序设计复习资料.doc
java程序设计-试验2(学生版)()
java实验报告实验二
java测试试卷二