java 综合

身份证：18位判断数，15位的转换成18位，把地区码提出来SourceString把年月日提取出来，输出你是男生还是女生，判断校验码是否正确 公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码（最后一位如果为奇数，代表男生，偶数代表女生）和一位数字校验码。

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位的乘积和是189，然后用189除以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));

              }

              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+"个");

}

}

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

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

 

 

 

 

 

（控制结构）（if...else 语句）构造多分支，判断某一年是否为闰年。闰年的条件是符合下面二者之一：一 能被4 整除，但不能被100 整除；二能被400 整除。

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+" 年不是闰年");

｝

｝

（switch 语句）在不同温度时显示不同的解释说明。

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+"℃ 太热了!开空调。");

}

}

}

（for 循环语句练习）按5 度的增量打印出一个从摄氏温度到华氏温度的转换表。

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);

}

}

}

运行结果：摄氏温度  华氏温度

0         32

5         41

10          50

15            59

20            68

25            77

30            86

35            95

40            104

（do…while 循环语句）求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

输出完成（耗时0秒）- 正常终止

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 {

              /**

        * @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));

                     }

                     }

}

3. 通过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;

}

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

{

System.out.println(xm+", "+xh);

}

}

创建将被继承的类

class shiyan2 extends shiyan{

protected String xy;

protected String xi;

public static void main(String args[]){

shiyan p1 = new shiyan();

p1.setdata("李四",12321) ;

p1.print();

shiyan2 s1 = new shiyan2() ;

s1.setdata("张三",12345); //调用父类的成员方法

s1.xy="成都信息工程学院"; //访问本类的成员变量

s1.xi="计算机系"; //访问本类的成员变量

s1.print();

System.out.print(s1.xm+", "+s1.xy+", "+s1.xi);

}

}

运行结果：

李四，12321

张三，12345

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

输出完成（耗时0秒）- 正常终止

4．程序功能：说明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);

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 + "," + super.y + "] [" +

x + "," + y + "] 直线长度：" + this.length();

}

}

public class shiyan4{

public static void main(String args[]) {

Line line=new Line(50, 50);

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

}

}

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

          输出完成（耗时0秒）- 正常终止

通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override），方法覆盖为子类提供了修改父类成员方法的能力。编写覆盖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

输出完成（耗时0秒）- 正常终止

Sy4:下面给出一个根据雇员类型利用多态性完成工资单计算的程序。定义一个抽象类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");

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;

              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",1000);

      PieceWorker p=new PieceWorker("damon",2.5,200);

      HourlyWorker h=new HourlyWorker("Karen",13.75,40);

//使用子类分别实例化

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 {

         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("成龙",200f,25f);

    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

          在调用changeSpeed(80)后，车速变为：80.0

          在调用stop（）后，车速变为：0.0