身份证: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=33+73+13,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 语句)在不同温度时显示不同的解释说明。
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