java实验

二．1）使用continue语句实现：将100～300之间的不能被3整除的数输出。

public class zhengchu{

public static void main(String[] args){ for(int i=100;i<=300;i++){ if(i%3==0)continue; System.out.println(i); } } }

2）使用break语句实现记数：从1～100，当数到78时程序终止。

public class BreakTest {

public static void main(String[] args) { int i;

for (i = 1; i <= 100; ++i) { System.out.println(i); if (i == 78) break; } } }

3）分别使用for语句编程，找出所有的水仙花数并输出。 public class shuixianhua {

public static void main(String[] args){ for(int i=1; i<=9; i++)

for(int j=0; j<=9; j++) for(int k=0; k<=9; k++)

if(i*i*i+j*j*j+k*k*k == 100*i+10*j+k) System.out.print(i*100+j*10+k+\" \"); } }

4）编写一程序，判断2011年份是否是闰年,并在屏幕上输出判断结果。

public class zhengchu{

public static void main(String[] args){ if(2011%4!=0)System.out.print(\"No\"); else

if(2011%400!=0&&2011%100==0)System.out.print(\"No\");

else System.out.print(\"Y es\"); } }

三．1）定义一个类MyValue，其中包括：用Value来保存一属性值；方法setValue设置Value，方法getValue获取Value，

定义一个类UseValue，在该类的Main方法里面完成如下功能：创建一个MyValue类的对象MyValue；为MyValue对象中的Value赋值10；使用getValue方法获得MyValue

对象中的数据并在屏幕上输出。 class MyV alue{ private int value;

public void setvalue(int x ){ value=x; }

public int getV alue(){ return value; }

}

public class UseV alue{

public static void main(String args[]){ MyV alue MyV=new MyV alue(); MyV.setvalue(10);

System.out.println(MyV.getV alue()); } }

2）编写Java代码实现一个计数器类Computer，其中包括： 用CountValue来保存计数器的当前值。

方法Computer（int a）是构造方法并给CountValue赋初值。 方法increment()计数器加一 方法decrement()计数器减一 方法reset（）计数器清零

使用计数器类创建一对象，该计数器对象当前值为10，调用三次increment()，输出计数器当前值，调用一次d ecrement()，输出计数器当前值，调用reset（）, 输出计数器当前值.

public class Computer{ public int CountV alue; Computer (int a){ CountV alue=a; }

public void increment (){ CountV alue++; }

public void decrement (){ CountV alue--; }

public void reset (){ CountV alue=0;

}

public static void main(String args[]){ Computer MyV=new Computer(10); MyV.increment(); MyV.increment(); MyV.increment();

System.out.println(MyV. CountV alue); MyV.decrement ();

System.out.println(MyV. CountV alue); MyV. reset ();

System.out.println(MyV. CountV alue); } }

3）定义一个名字为MyRectangle的矩形类，类中有4个私有的整型成员变量，分别是矩形的左上角坐标（xUp，yUp）和右下角坐标（xDown，yDown）；类中定义了无参数的构造方法和有4个int参数的构造方法，用来初始化类对象。类中还有以下方法：getW（）－计算矩形的宽度；

getH（）－计算矩形的高度； area（）－计算矩形的面积；

toString（）－把矩形的宽、高和面积等信息作为一个字符串返回。

编写应用程序使用MyRectangle类。 class MyRectangle{

private int xUp,yUp,xDown,yDown; MyRectangle(){

xUp = 0; yUp = 0; xDown = 0; yDown = 0; }

MyRectangle(int x1,int y1,int x2,int y2 ){ xUp = x1;yUp = y1;xDown = x2; yDown = y2;

}

public int getW(){ return xDown - xUp; }

public int getH(){ return yDown - yUp; }

public int area(){ return getW() * getH(); }

public String toString() {

return \"矩形宽：\" + getW() +\"矩形高：\" + getH() + \"矩形面积：\"+area();

} }

public class test {

public static void main(String args[]) {

MyRectangle rectangle = new MyRectangle(1,2,7,8); System.out.println(rectangle.toString()); } }

1）定义一个接口，接口中有四个抽象方法：求面积方法、求周长方法、显示面积方法及显示周长方法。定义Circle类和Rectangle类分别实现接口，在主类中实现显示圆和矩形的面积和周长。

interface J_Shape {

public abstract double mb_getArea(); public abstract double mb_getPerimeter(); }

public class J_Circle implements J_Shape {

public double m_radius; public J_Circle(double r) {

m_radius=r; }

public double mb_getArea() {

return(Math.PI*m_radius*m_radius); }

public double mb_getPerimeter() {

return(Math.PI*2*m_radius); }

public static void main(String args[]) {

J_Shape a=new J_Circle(5);

System.out.println(\"the area of circle is:\" + a.mb_getArea()); System.out.println(\"the a.mb_getPerimeter());

} }

interface J_Shape {

public abstract double mb_getArea(); public abstract double mb_getPerimeter(); }

public class Rectangle implements J_Shape { public double longs,wides;

public Rectangle(double l,double w) { longs=l;

perimeter

of

circle

is\"

+

wides=w; }

public double mb_getArea() { return(longs*wides); }

public double mb_getPerimeter() { return (2*(longs+wides)); }

public static void main(String args[]) {

J_Shape a=new Rectangle(2,3); System.out.println(\"the is:\"+a.mb_getArea());

System.out.println(\"the is:\"+a.mb_getPerimeter());

} }

2）重写上面的程序，要求矩型，圆的类放到不同的包中，用包的技术组织程序的设计。同时要求程序能从键盘上接受数据以便求解不同的几何图形的周长面积。

提示：从键盘上输入双精度数的一种方法(程序片段) package Mytest; interface J_Shape {

public abstract double mb_getArea(); public abstract double mb_getPerimeter(); }

public class J_Circle implements J_Shape { public double m_radius; public J_Circle(double r) {

perimeter

of

rectangle

area

of

rectangle

m_radius=r; }

public double mb_getArea() {

return(Math.PI*m_radius*m_radius); }

public double mb_getPerimeter() {

return(Math.PI*2*m_radius); } }

package Mypackage; interface J_Shape {

public abstract double mb_getArea(); public abstract double mb_getPerimeter(); }

public class Rectangle implements J_Shape { public double longs,wides;

public Rectangle(double l,double w) { longs=l; wides=w; }

public double mb_getArea() { return(longs*wides); }

public double mb_getPerimeter() { return (2*(longs+wides)); } }

import Mypackage.Rectangle; import Mytest.J_Circle; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class J_test {

public static void main(String args[])throws IOException {

BufferedReader

input=new

BufferedReader(new

InputStreamReader(System.in));

System.out.print(\"请输入圆半径：:\");

int number=Integer.parseInt(input.readLine()); J_Circle a=new J_Circle(number);

System.out.println(\"the area of circle is:\"+a.mb_getArea()); System.out.println(\"the is:\"+a.mb_getPerimeter());

BufferedReader

input1=new

BufferedReader(new

InputStreamReader(System.in));

System.out.print(\"请输入长方的一边:\");

int number1=Integer.parseInt(input.readLine()); System.out.print(\"请输入长方的另一边:\");

int number2=Integer.parseInt(input1.readLine()); Rectangle b=new Rectangle(number1,number2); System.out.println(\"the is:\"+b.mb_getArea());

System.out.println(\"the is:\"+b.mb_getPerimeter());

} }

1、编写一程序，随机生成5个不大于100的整数存入一数组，计

perimeter

of

rectangle

area

of

rectangle

perimeter

of

circle

算该数组的平均值，输出

该5个整数及平均值。 public class Average {

public static void main(String[] args) {

int intNumber[]; int i;

intNumber = new int[5];

for ( i = 0 ; i < intNumber.length ; i++) {

intNumber[i] = (int)(Math.random()*100); System.out.print( intNumber[i] + \" \"); }

System.out.println( \"+GetAverage(intNumber) );

}

static double GetAverage(int intNumber[]) {

int i,intTotal = 0; double dblResult;

for ( i = 0 ; i < intNumber.length ; i++ ) {

intTotal = intTotal + intNumber[i]; }

dblResult = (double)intTotal/intNumber.length; return (dblResult); } }

2、编写一程序，该程序输入一个字符串参数，返回该字符串的反

\"\\nThe

Average

is

:

序字符串.

import java.io.*; public class J_Test3 {

public static void main(String args[])throws IOException {

BufferedReader String s;

s=keyin.readLine(); int j=s.length();

StringBuffer buffer=new StringBuffer(j); for (int k=j-1;k>=0;k--) {

buffer.append(s.charAt(k)); }

System.out.println(\"原来为\"+s); System.out.println(\"现在为\"+buffer); } }

3、编写一程序，计算矩阵A={{7,9,4},{5,6,8}}与矩阵B={{9,5,2,8},{5,9,7,2},{4,7,5,8}}相乘，把结果存入矩阵C,并在屏幕输出结果。public class MatrixMultiply

{

public static void main( String args[] ) {

int intMatrixA[][] = { {7,9,4} , {5,6,8} };

int intMatrixB[][] = { {9,5,2,8} , {5,9,7,2} , {4,7,5,8} }; int intMatrixC[][] = new int[2][4];

Multiply( intMatrixA , intMatrixB , intMatrixC );

keyin=new

BufferedReader(new

InputStreamReader(System.in));

System.out.println(\"\\n*** Matrix A ***\"); OutputMatrix( intMatrixA );

System.out.println(\"\\n*** Matrix B ***\"); OutputMatrix( intMatrixB );

System.out.println(\"\\n*** Matrix C ***\"); OutputMatrix( intMatrixC ); }

static void Multiply(int intMatrixA[][] , int intMatrixB[][] , int intMatrixC[][] )

{ int i,j,k;

for( i = 0 ; i < intMatrixA.length ; i++ ) {

for( j = 0; j < intMatrixB[i].length ; j++ ) {

intMatrixC[i][j] = 0;

for( k = 0; k < intMatrixB.length ; k++ )

intMatrixC[i][j] += intMatrixA[i][k] * intMatrixB[k][j]; } } }

static void OutputMatrix(int intMatrix[][]){ int i,j;

for ( i = 0 ; i < intMatrix.length ; i++) {

for ( j = 0 ; j < intMatrix[i].length ; j++) {

System.out.print( intMatrix[i][j] + \" \" ); }

System.out.println();

} } }

1、编写程序，该程序将整型变量n=20、实型变量b=3.14和字符型变量c=’a’显示在屏幕

上。

public class Welcome {

public static void main(String[] args) { int n; n=3;

System.out.println(n); float b; b=3.14f;

System.out.println(b); char c; c='a';

System.out.println(c); }

}2、编写程序，该程序实现打开一个文本文件，每次读取一行内容，将每行作为一个字符串读入，并将字符串输出显示到屏幕上。

import java.io.*; public class Printlnt {

public static void main(String args[]) throws IOException { File filePath = new File(\"D:\\\\123.txt\"); BufferedReader br; String s = null; try {

br = new BufferedReader(new FileReader(filePath));

while ((s = br.readLine()) != null) { System.out.println(s + \"\\r\\n\"); }

} catch (FileNotFoundException e) { e.printStackTrace(); } } }

3、编写一个程序，在控制台中窗口中提示输入两个整数，然后接收这两个整数，并输出它们的和。下面是运行过程的示例：

请输入第一个整数：45 请输入第二个整数：23 计算结果：45+23=68

上面的两个黑斜体整数是用键盘输入的，其余字符是程序输出的。 import java.util.Scanner; public class PrintInt {

public static void main(String[] args) { String a,b;

Scanner scan = new Scanner(System.in); System.out.print(\"输入第一个整数： \"); a = scan.next();

System.out.print(\"输入第二个整数：\"); b = scan.next(); try{

int c=(Integer.parseInt(a)); int d=(Integer.parseInt(b)); int e; e=c+d;

System.out.println(\"计算结果：\"+c+\"+\"+d+\"=\"+e); }catch(NumberFormatException e) {

System.out.println(\"请输入整数！\");

1）运用布局管理器，设置如下界面布局管理器嵌套

import java.awt.*; import javax.swing.*; public class work1{

public static void main(String args[]){

JFrame app=new JFrame(\"Multiple Layouts\");

app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); app.setSize(215,150);

Container c=app.getContentPane(); c.setLayout(new FlowLayout()); JPanel[] p=new JPanel[3]; for(int i=0;i<=2;i++){ p[i]=new JPanel();

p[i].setLayout(new BoxLayout(p[i],BoxLayout.X_AXIS)); c.add(p[i]); } String s; JButton b;

int[]pj={2,1,1,0,0,0}; for(int i=0;i<6;i++){ s=\"Button\"+(i+1); b=new JButton(s); p[pj[i]].add(b);

}

app.setV isible(true); } }

2）编写如下界面程序（P177），掌握基本组件的使用。

import java.awt.*; import javax.swing.*;

public class J_FlowBoxLayout{ public static void main(String args[]){ JFrame app=new JFrame(\"Multiple Layouts\");

app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); app.setSize(320,120);

Container c=app.getContentPane(); c.setLayout(new FlowLayout()); JTextField[]t={

new JTextField(\"Text 1\new here\

t[0].setEditable(false); t[2].setEditable(false); for(int i=0;i<4;i++) c.add(t[i]);

app.setV isible(true); } }

3）在应用程序窗体中安排两个文本框分别用来输入两个整数，两

JTextField(\"Text

2\

JTextField(\"Enter

text

个按钮分别为“+”、“*”，一个结果标签。点击按纽“+”将两文本框的数据做加法运算；点击按钮“*”做乘法运算，将结果显示在标签中。

import java.awt.*; import java.awt.event.*; public

class

myFrame

extends

Frame

implements

ActionListener {

Label res; TextField f1,f2; public myFrame (){ f1 =new TextField(20); f2 =new TextField(20); Button b1=new Button(\"+\"); Button b2=new Button(\"*\"); res=new Label(\" 运算结果 \"); setLayout(new GridLayout(3,2)); add(f1); add(f2);

add(b1); add(b2); add(res); b1.addActionListener(this); b2.addActionListener(this); }

public void actionPerformed(ActionEvent e) { int x1=Integer.parseInt(f1.getText()); int x2=Integer.parseInt(f2.getText());

if (e.getActionCommand().equals(\"+\")) //区分用户点击的是哪个按钮 res.setText(\"\"+(x1+x2));

else

res.setText(\"\"+(x1*x2)); }

public static void main(String args[]) {

Frame my= new myFrame(); my.setSize(200,200); my.setVisible(true); } }

1) 在J Applet类中添加3个带有图片的按钮和一个带有图片的标签。

import javax.swing.*; import java.awt.*; import java.awt.Color;

public class PicApplet extends JApplet { Container pane; JPanel panel1,panel2;

JButton button1,button2,button3; JLabel label; public void init() { pane=getContentPane();

panel1=new JPanel(new FlowLayout()); panel2=new JPanel(new FlowLayout()); ImageIcon

icon

=

new

ImageIcon(\"image/PreviousArrow.gif\

button1=new JButton(icon);

button2=new JButton(new ImageIcon(\"image/go.GIF\")); button3=new

ImageIcon(\"image/NextArrow.gif\"));

label=new JLabel(\"图像标签\new

ImageIcon(\"image/Candl02.gif\"),SwingConstants.CENTER);

pane.setBackground(new Color(255,255,200)); panel1.setBackground(new Color(255,255,104));

JButton(new

panel2.setBackground(new Color(255,255,214)); button1.setToolTipText(\"向上翻页按钮\"); button2.setToolTipText(\"跳转按钮\"); button3.setToolTipText(\"向下翻页按钮\"); pane.add(\"North\

pane.add(panel2,BorderLayout.SOUTH); panel1.add(button1); panel1.add(button3);

panel2.add(label); } }

2) 编写一个Applet程序从网页文件转入三个数,输出其中的最大值和最小值.

1. 利用多线程编程思想编写一个龟兔赛跑程序。乌龟：速度慢，休息时间短；兔子：速度快，休息时间长。

class Animal extends Thread { int speed; //速度

public Animal( String str,int speed) { super(str); //线程名用动物名代表 this.speed=speed; }

public void run() { int distance=0; int sleepTime;

while (distance<=1000) {

System.out.println(getName()+\"is at\"+distance); try {

distance+=speed; //每次跑的距离简单用速度计算

panel1.add(button2);

sleepTime=(int)( speed+Math.random()*speed); //速度快休息时间要长

sleep(sleepTime);

} catch (InterruptedException e) {} } } }

public class Race {

public static void main(String arg[]) { Animal a1, a2;

a1=new Animal(\"rabit\a2=new Animal(\"turtle\

a2.setPriority(Thread.MAX_PRIORITY); //让乌龟的运行优先级更高

a1.start(); a2.start(); } }

2. 编写一个猜数字游戏，其中一个线程生成随机数，让另一个线程猜。public class GuessNum

{

public static void main(String args[]) {

Number number=new Number(); number.giveNumberThread.start(); number.guessNumberThread.start(); } }

class Number implements Runnable {

int realNumber,guessNumber,min=0,max=100,message; final int SMALLER=-1,LARGER=1,SUCCESS=8; Thread giveNumberThread,guessNumberThread; Number()

{ giveNumberThread=new Thread(this); guessNumberThread=new Thread(this); }

public void run() {

for(int count=1;true;count++) {

if(Thread.currentThread()==giveNumberThread) {

if(count==1)

{ realNumber=(int)(Math.random()*100)+1; System.out.println(\"随机给你一个数，猜猜是多少？\"); } else

{ if(realNumber>guessNumber) { message=SMALLER;

System.out.println(\"你猜小了\"); } else

if(realNumberbdsfid=\"2\"

p=\"\">

{ message=LARGER;

System.out.println(\"你猜大了\"); } else

{ message=SUCCESS;

System.out.println(\"恭喜，你猜对了\");

return; } }

try{ Thread.sleep(1500); }

catch(Exception e){} }

if(Thread.currentThread()==guessNumberThread) {

if(count==1)

{ guessNumber=(min+max)/2;

System.out.println(\"我第\"+count+\"次猜这是:\"+guessNumber);

} else

{ if(message==SMALLER) { min=guessNumber; guessNumber=(min+max)/2;

System.out.println(\"我第\"+count+\"次猜这是:\"+guessNumber);

}

else if(message==LARGER) { max=guessNumber; guessNumber=(min+max)/2;

System.out.println(\"我第\"+count+\"次猜这个数 是:\"+guessNumber); }

else if(message==SUCCESS) { System.out.println(\"我成功了！\"); return;

个数个数} }

try{ Thread.sleep(1500); }

catch(Exception e){} } } } }