java平时实验

1．使用if...else 语句

（1）程序功能：使用if...else 语句构造多分支，判断某一年是否为闰年。闰年的条件是符合下面二者之一：一 能被4 整除，但不能被100 整除；二能被400 整除。 （2）编写源程序文件，代码如下。 public class Demo2_6 {

public static void main(String args[]) { int year=2005;

if ((year%4==0 && year%100!=0) || (year%400==0)) // System.out.println(year+\" 年是闰年\"); else

System.out.println(year+\" 年不是闰年\"); ｝ ｝

2．使用switch 语句

（1）程序功能：在不同温度时显示不同的解释说明。 （2）程序源代码如下。 class Demo2_7{

public static void main(String args[]) { int c=28;

switch (c/10) { case 1:

System.out.println(\" \"+c+\"℃ 有点冷。要多穿衣服。\"); case 2:

System.out.println(\" \"+c+\"℃ 正合适。出去玩吧。\"); case 3:

System.out.println(\" \"+c+\"℃ 有点热。\"); default:

System.out.println(\" \"+c+\"℃ 太热了!开空调。\"); } } }

3． for 循环语句练习

（1） 程序功能：按5 度的增量打印出一个从摄氏温度到华氏温度的转换表。 （2） 程序源代码如下。

class Demo2_8{

public static void main (String args[]) { int h,c;

System.out.println(\"摄氏温度 华氏温度\"); for (c=0; c<=40; c+=5) { h=c*9/5+32;

System.out.println(\" \"+c+\" \"+h);

1－17

} } }

4．do„while 循环语句练习

（1） 程序功能：求1＋2＋„+100 之和，并将求和表达式与所求的和显示出来。 class Demo2_10 {

public static void main(String args[]) { int n=1, sum=0; do {

sum+=n; n++;

}while (n<=100);

System.out.println(\"1+2＋...+100 =\"+sum); } }

运行结果：1+2＋...+100 =5050 Ⅱ练习内容

1．分别使用while语句、for循环完成100以内数的求和

2 利用循环语句编程，找出所有的水仙花数并输出。其中水仙花数是三位数，它的各位数字的立方和等于这个三位数本身，例如：371=33+73+13，371就是一个水仙花数。

题目：打印出所有的 \"水仙花数 \"，所谓 \"水仙花数 \"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 \"水仙花数 \"，因为153=1的三次方＋5的三次方＋3的三次方。 public class lianxi03 {

public static void main(String[] args) { int b1, b2, b3;

for(int m=101; m<1000; m++) { b3 = m / 100;

b2 = m % 100 / 10; b1 = m % 10;

if((b3*b3*b3 + b2*b2*b2 + b1*b1*b1) == m) { System.out.println(m+\"是一个水仙花数\"); } } } }

3．编程输出如下图形(在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下：) * *** ***** ******* *********

2－17

//打印金字塔图案 public class PrintStar{

public static void main(String args[]){ int col = Integer.parseInt(args[0]); for(int i=1;i<=col;i++){//i表示行数 //打印空格

for(int k=0;k//打印星星

for(int m=0;m<2*i-1;m++){ System.out.print(\"*\"); }

System.out.println(); } } }

类的继承性练习

新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。

当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。

Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 6.1、 创建将被继承的类 (1) 程序源代码如下。

public class EXP3_7 {

protected String xm; //具有保护修饰符的成员变量 protected int xh;

void setdata(String m,int h) //设置数据的方法 {

xm =m; xh = h;

3－17

}

public void print() //输出数据的方法 {

System.out.println(xm+\

} } (2) 编译源程序。 6.2、 创建将被继承的类

(1) 程序功能：通过EXP3_7类产生子类EXP3_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），

还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。

class EXP3_8 extends EXP3_7{

protected String xy; protected String xi;

public static void main(String args[]){ EXP3_7 p1 = new EXP3_7(); p1.setdata(\"李四\ p1.print();

EXP3_8 s1 = new EXP3_8() ;

s1.setdata(\"张三\调用父类的成员方法 s1.xy=\"成都信息工程学院\"; //访问本类的成员变量 s1.xi=\"计算机系\"; //访问本类的成员变量 s1.print();

System.out.print(s1.xm+\ } }

李四，12321 张三，12345

张三，成都信息工程学院，计算机系

通过shiyan类产生子类shiyan2，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。创建将被继承的类 public class shiyan {

protected String xm; //具有保护修饰符的成员变量 protected int xh;

void setdata(String m,int h) //设置数据的方法 {

xm =m; xh = h;

4－17

}

public void print() //输出数据的方法 {

System.out.println(xm+\} }

6.3、 了解成员方法的覆盖方式

通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。例如，子类可以修改层层继承下来的Object 根类的toString 方法，让它输出一些更有用的信息。下面的程序显示了在子类Circle 中添加toString 方法，用来返回圆半径和圆面积信息。

(1) 编写覆盖Object 类toString方法的程序文件EXP3_9.java，源代码如下。

class Circle {

private int radius; Circle(int r) { setRadius(r); }

public void setRadius(int r) { radius=r; }

public int getRadius() { return radius; }

public double area() {

return 3.14159*radius*radius; }

public String toString() {

return \"圆半径：\"+getRadius()+\" 圆面积：\"+area(); } }

public class EXP3_9{

public static void main(String args[]) { Circle c=new Circle(10);

System.out.println(\"\\n\"+c.toString()); }

} 运行结果：圆半径：10 圆面积：314.16

6.1、 this、super和super()的使用

5－17

(1) 程序功能：程序功能：说明this、super 和super()的用法。程序首先定义Point（点）类，然

后创建点的子类Line（线）。最后通过LX3_10 类输出线段的长度。程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。

class Point {

protected int x, y; Point(int a, int b) { setPoint(a, b); }

public void setPoint(int a, int b) { x=a; y=b; } }

class Line extends Point { protected int x, y; Line(int a, int b) { super(a, b);SZ setLine(a, b); }

public void setLine(int x, int y) { this.x=x+x; this.y=y+y; }

public double length() {

int x1=super.x, y1=super.y, x2=this.x, y2=this.y;

return Math.sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1)); }

public String toString() {

return \"直线端点：[\" + super.x + \ x + \直线长度：\" + this.length(); } }

public class EXP3_10{

public static void main(String args[]) { Line line=new Line(50, 50);

System.out.println(\"\\n\"+line.toString()); } }

6－17

行结果：直线端点：[50,50] [100,100]直线长度；70.7106781184

1、理解 Java 语言是如何体现面向对象编程基本思想。 2、了解类的封装方法，以及如何创建类和对象。

3、掌握成员变量和成员方法的特性及构造方法和析构方法的使用。

4、熟练掌握 OOP 方式进行程序设计的方法，理解类的继承性和多态性的作用。

1、定义一个“圆”类Circle，该圆类的属性包括：圆心点位置及圆的半径；方法有：设置圆心位置和半径的方法，获取圆心位置和半径的方法及构造方法。要求构造方法可以接收圆心位置参数，而半径使用缺省值0。编写完整的程序并创建Circle类的对象，并设置圆心为（0，0），半径为1.5，打印并显示圆的面积。 class cy {

private int radius; cy(int r) { setRadius(r); }

public void setRadius(int r) { radius=r; }

public int getRadius() { return radius; }

public double area() {

return 3.14159*radius*radius; }

public String toString() {

return \"圆半径：\"+getRadius()+\" 圆面积：\"+area(); } }

public class shiyan3{

public static void main(String args[]){ cy c=new cy(10);

System.out.println(\"\\n\"+c.toString()); } }

2、编写程序计算下列数学表达式的值 (1) sin(30°)

(2) 2.73的向上取整、向下取整、四舍五入值(ceil, floor,round) (3) 36的平方、平方根(sqrt,pow)

(4) 产生10个-20到40之间的随机数 import java.math.*;

import java.util.Random; public class qy {

7－17

}

/**

* @param args */

public static void main(String[] args) { System.out.println(Math.sin(Math.toRadians(30))); System.out.println(Math.ceil(2.73)); System.out.println(Math.floor(2.73)); System.out.println(Math.round(2.73)); System.out.println(Math.sqrt(36)); System.out.println(Math.pow(36, 2)); for(int i=0;i<10;i++){ System.out.println((int) (Math.random()*60-20)); } }

1、理解 Java 语言是如何体现面向对象编程基本思想。 2、了解类的封装方法，以及如何创建类和对象。

3、掌握成员变量和成员方法的特性及构造方法和析构方法的使用。

4、熟练掌握 OOP 方式进行程序设计的方法，理解类的继承性和多态性的作用。 二、实验内容

1、下面给出一个根据雇员类型利用多态性完成工资单计算的程序。定义一个抽象类Employee作为父类，其中含有属性name，并由一个构造方法用以设置name的值。Employee的子类有Boss（每星期发给他固定工资，而不计工作时间）、PieceWorker（按其生产的产品数以及产品单价发放工资）、HourlyWorker（根据工作时间长短发放工资）。对所有雇员类型都使用Employee类中定义的抽象方法earnings()完成其工资单的计算，但每个人挣的工资按他所属的雇员类计算，所有雇员类都是从父类Employee派出生的。所以在父类中声明earnings()方法，该方法没有实质性工作，而是在每个子类都提供恰当的earnings()方法的重写。请设置boss的名字为bill 周薪为1000，pieceworker的名字为damon，生产的产品为500，产品单价为1.5，hourlyworker的名字为ketty，每周工作40小时，每小时薪水为20。最后打印每个雇员每周的工资单。 创建父类Employee class Employee{

private String Name;

public Employee(String s){ Name=s; }

public String getEmployeeName(){ return Name; }

public String toStrings(){ return Name; }

public double earnings(){

System.out.println(\"Employ's salary is 0.0\");

8－17

return 0.0; } }

创建子类BOSS

class boss extends Employee{

private double weeklySalary; public boss(String first,double s){ super(first);

setWeeklySalary(s); }

public void setWeeklySalary(double s){ weeklySalary=(s>0?s:0);} public double earnings(){

return weeklySalary; }

public String toStrings(){

return \"Boss: \"+super.toStrings(); } }

创建子类HourlyWorker

class HourlyWorker extends Employee{ private double wage; private double hours;

public HourlyWorker(String first,double w,double h) { super(first); setWage(w); setHours(h); }

public void setWage (double w){ wage=(w>0?w:0); }

public void setHours(double h){

hours=(h>=0&&h<168?h:0); }

public double earnings(){

return wage*hours; }

public String toStrings(){

return \"HourlyWorker: \"+super.toStrings(); } }

创建子类PieceWorker

class PieceWorker extends Employee{

private double wagePiece;

9－17

private int quantity;

public PieceWorker(String first,double w,int q){ super(first); setWage(w); setQuantity(q); }

public void setWage(double w){

wagePiece=(w>0?w:0); }

public void setQuantity(int q){

quantity=(q>0?q:0); }

public double earnings(){

return quantity*wagePiece; }

public String toStrings(){

return \"PieceWoeker: \"+super.toStrings(); } }

创建子类TestEmployee public class TestEmployee{

public static void main(String args[ ]){ //使用超类声明ref

Employee ref; String out=\"\"; //分别定义各子类

boss b=new boss(\"bill\

PieceWorker p=new PieceWorker(\"damon\ HourlyWorker h=new HourlyWorker(\"Karen\//使用子类分别实例化 ref=b;

System.out.print(ref.toStrings()+\"earned $\"+ref.earnings()+\"\\n\"); ref=p;

System.out.print(ref.toStrings()+\"earned $\"+ref.earnings()+\"\\n\"); ref=h;

System.out.print(ref.toStrings()+\"earned $\"+ref.earnings()+\"\\n\"); } }

（使用类的成员变量来表示事物的属性和状态，使用类的成员方法来提供对成员变量的访问或修改） 设计一个用来描述汽车的类，使用类的非静态成员变量来表示汽车的车主姓名、当前的速率和当前方向盘的转向角度，使用类的非静态成员方法来表示改变汽车的速率和停车两个操作。其中类的初始化采用构造函数进行描述。 qv.java

package jing; public class qv {

10－17

String ownerName; //车主姓名 double curSpeed; //当前车速 double curDirInDegree; //当前方向盘转向角度 public qv(String ownerName){ this.ownerName=ownerName;//注意this引用 } public qv(String ownerName, double speed, double dirInDegree){ this.ownerName=ownerName; this.curSpeed=speed; this.curDirInDegree=dirInDegree; } public String getOwnerName() { //提供对车主姓名的访问 return ownerName; } public double getCurDirInDegree() { //提供对当前方向盘转向角度的访问 return curDirInDegree; } public double getCurSpeed() { //提供对当前车速的访问 return curSpeed; } public void changeSpeed(double curSpeed) { //提供改变当前的车速 this.curSpeed = curSpeed; } public void stop(){ //提供停车 this.curSpeed=0; } }

yan.java package jing; public class yan {

public static void main(String[] args){ qv car=new qv(\"成龙\

System.out.println(\"车主姓名: \"+car.getOwnerName()); System.out.println(\"当前车速: \"+car.getCurSpeed());

System.out.println(\"当前转向角度: \"+car.getCurDirInDegree()); car.changeSpeed(80);

System.out.println(\"在调用changeSpeed(80)后,车速变为: \" + car.getCurSpeed()); car.stop();

System.out.println(\"在调用stop()后, 车速变为: \"+car.getCurSpeed()); } }

运行结果：车主姓名：成龙 当前车速：200.0 当前转向角度：25.0

11－17

在调用changeSpeed(80)后，车速变为：80.0 在调用stop（）后，车速变为：0.0

思考题 为何将Employee类设置为抽象类？ 对于每个不同的Employee类的子类，都有earnings（）方法，但计算方法都不一样，这在java语言中被称为什么？

1、编写一个身份证的类，可以用来验证身份证的长度，并可以显示地址码，生日，性别。 说明：公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码（最后一位如果为奇数，代表男生，偶数代表女生）和一位数字校验码。

1、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。

2、将这17位数字和系数相乘的结果相加 3、用加出来和除以11，看余数是多少？

4、余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字。其分别对应的最后一位身份证的号码为1－0－X －9－8－7－6－5－4－3－2。

5、通过上面得知如果余数是2，身份证的最后一位号码就是罗马数字2。如果余数是10，就会在身份证的第18位数字上出现的是X。

例如：某男性的身份证号码是34052419800101001X。我们要看看这个身份证是不是合法的身份证。 首先我们得出前17位的乘积和是1，然后用1除以11得出的结果是17+2/11，也就是说其余数是2。最后通过对应规则就可以知道余数2对应的是罗马数字X。所以，可以判定这是一个合格的身份证号码。

public class 身份证 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String 身份证=\"34052419800101001X\"; if(身份证.length()!=18){ System.out.println(\"你输入的身份证不是18位的\"); } else{ System.out.println(\"你输入的身份证是18位的\"); } System.out.println(\"区号为\"+身份证.substring(0,6)); System.out.println(\"年\"+身份证.substring(6,10)+\"月\"+身份证.substring(10,12)+\"日\"+身份证.substring(12,14));

System.out.println(\"顺序码\"+身份证.substring(14,17)); int a[]=new int[18]; for(int i=0;i<17;i++){ a[i]=Integer.parseInt(身份证.substring(i, i+1)); }

12－17

if(a[16]%2==0){ System.out.println(\"你是女生\"); } else{ System.out.println(\"你是男生\"); } int b[]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2}; char c[]={'1','0','x','9','8','7','6','5','4','3','2'}; int ct=0; for(int i=0;i<17;i++){ ct=ct+a[i]*b[i]; } ct=ct%11; System.out.println(\"你的身份证的最后一位是\"+c[ct]); } }

money

class money{

public static void main (String args[]) { int i,j,l,d; int c=146; i=c/100;

j=(c%100)/20; d=(c%10)/5; l=(c%10)-5*d;

System.out.println(\"1元\"+i+\"个\"); System.out.println(\"2角\"+j+\"个\"); System.out.println(\"5分\"+d+\"个\"); System.out.println(\"1分\"+l+\"个\"); } }

2、编写一个Java程序，完成以下功能：

（1）声明一个名为s的String对象，并使它的内容是“My name is Carrol”； （2）打印整个字符串； （3）打印字符串的长度；

（4）打印字符串的第一个字符； （5）打印最后一个字符；

（6）打印字符串的每一个单词。

3、编写程序计算下列数学表达式的值 (1) sin(30°)

(2) 2.73的向上取整、向下取整、四舍五入值

13－17

(3) 36的平方、平方根

4、观察下列程序运行结果 package p1; public class T5{

public static void main(String a[]){ String s1=\"\"; T5 t1=new T5();

System.out.println(\"本类名=\"+t1.getClass().getName());

System.out.println(\"父类名=\"+t1.getClass().getSuperclass().getName()); System.out.println(\"包名=\"+t1.getClass().getPackage().getName()); System.out.println(\"操作系统=\"+System.getProperty(\"os.name\"));

System.out.println(\"java版本=\"+System.getProperty(\"java.vm.version\")); System.out.println(\"内存总量=\"+Runtime.getRuntime().totalMemory()); System.out.println(\"剩余内存=\"+Runtime.getRuntime().freeMemory()); }}

一、 使用try…catch语句处理异常

(1) 程序功能：在程序中主动产生一个ArithmeticException 类型被0 除的异常， 并用catch 语

句捕获这个异常。最后通过Exception 类的对象e 的方法getMessage 给出异常的具体类型并显示出来。 (2) 程序源代码如下。

public class EXP_6_1{

public static void main(String[] arg3) {

System.out.println(\"这是一个异常处理的例子\\n\"); try {

int i=10; i /=0; }

catch (Exception e) {

System.out.println(\"异常是：\"+e.getMessage()); }

finally {

System.out.println(\"finally语句被执行\"); } } } 二、 多线程练习 三、 线程同步问题 参考示例如下：

14－17

public class Account{ int balance;

final int Max=500; public Account(){ balance=0;

System.out.println(\"初始总资产为：\"+balance+\"仓库最多能存放\"+Max+\"元\"); }

public synchronized void withdraw(int money){ while(balance<=money){ try{

System.out.println(\"金额不够，需要等待\"); wait(); }

catch(Exception e){

System.out.println(e.getMessage()); } }

balance=balance-money;

System.out.println(\"已经取得了\"+money+\"元\");

System.out.println(\"现在仓库中有\"+balance+\"元\"); notify(); }

public synchronized void deposite(int money){ while(balance+money>Max){ try{

System.out.println(\"仓库装不下，需要等待\"); wait(); }

catch(Exception e){

System.out.println(e.getMessage()); } }

balance=balance+money;

System.out.println(\"已经存入了\"+money+\"元\");

System.out.println(\"现在仓库中有\"+balance+\"元\"); notify(); } }

public class WithdrawThread extends Thread { Account account;

public WithdrawThread(Account account){

15－17

this.account=account; }

public void run(){

for(int i=0;i<10;i++){

account.withdraw((int)(Math.random()*100)); try {

sleep(1000);

} catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }

public class DepositThread extends Thread { Account account;

public DepositThread(Account account){ this.account=account; }

public void run(){

for(int i=0;i<10;i++){

account.deposite((int)(Math.random()*100)); try {

sleep(1000);

} catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }

public class Ex6_3 {

public static void main(String[] args) { Account account=new Account();

WithdrawThread withdraw=new WithdrawThread(account); DepositThread deposite=new DepositThread(account); withdraw.start(); deposite.start(); }

16－17

}

17－17