java练习5
java5
- 7-1Ring类设计
- 7-2 圆柱体类设计
- 7-3 正方形类
- 7-4 Circle类
- 7-5 学生类设计
- 7-7 jmu-Java-03面向对象基础-03-形状
- 7-8 学生类-构造函数
- 7-9 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
- 7-10 统计商品总价
- 7-11 定义商品类，封装成员变量，输出对象
- 7-12 定义类与创建对象
- 7-13 点
- 7-14 设计一个BankAccount类
- 7-15 时间类
7-1Ring类设计
7-1 Ring类设计
编写一个圆环类Ring的Java程序。
a定义圆环类的2个数据成员，分别是内半径innerRadius，外半径outerRadius，这些属性通过get和set方法进行封装。
b 定义圆环类有参构造方法Ring(int innerRadius,int outerRadius),在有参构造方法中加入System.out.println(“constructor”);
c完成无参构造方法Ring(),要求在无参构造方法中使用this调用有参构造方法给两个半径赋值（外半径赋值3，内半径赋值1）
d 圆环类中定义 public int getArea（）方法可以返回其面积。面积求出后强制转换为整型值返回，π使用Math.PI表示。
在Main类中先生成一个圆环类对象，这个圆环的两个半径通过键盘读入，调用求面积方法求出面积后，输出面积。
然后再次定义一个圆环对象，调用无参构造方法，调用求面积方法求出面积后，输出面积。
输入格式:
输入在一行中先给出内半径，再给出外半径。
输出格式:
在一行中输出圆环的面积。
import java.util.Scanner;
class Ring{
int innerRadius;
int outerRadiu;
public int getInnerRadius() {
return innerRadius;
}
public void setInnerRadius(int innerRadius) {
this.innerRadius = innerRadius;
}
public int getOuterRadiu() {
return outerRadiu;
}
public void setOuterRadiu(int outerRadiu) {
this.outerRadiu = outerRadiu;
}
Ring(){
this.innerRadius = 1;
this.outerRadiu = 3;
System.out.println("constructor");
}
Ring(int innerRadius2,int outerRadius){
this.innerRadius = innerRadius2;
this.outerRadiu = outerRadius;
System.out.println("constructor");
}
public int getArea(){
return (int)((this.outerRadiu*this.outerRadiu-this.innerRadius*this.innerRadius)*Math.PI);
}
}
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int innerRadius = scan.nextInt();
int outerRadius = scan.nextInt();
Ring p = new Ring(innerRadius,outerRadius);
System.out.println(p.getArea());
Ring p1 = new Ring();
System.out.println(p1.getArea());
}
}
7-2 圆柱体类设计
定义一个圆柱类Cylinder
里面包含私有属性 private int radius（半径）,height(高）
为属性完成其setter getter方法
完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println(“Constructor with para”);
完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println(“Constructor no para”);
完成求体积方法 public int getVolumn(){} 求圆柱体积,π使用Math.PI
定义测试类Main，在main方法中，按照顺序要求完成下列操作
从键盘接收两个数，第一个为半径，第二个为高，并利用刚才输出两个数创建圆柱体对象c1,求c1的体积并输出。
使用无参构造方法 创建第二个圆柱体对象c2，求c2的体积并输出。
输入格式:
在一行中输入半径 和高。
输出格式:
对每一个圆柱体输出它的体积
import java.util.Scanner;
class Cylinder{
private int radius;
private int height;
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
Cylinder(){
this.radius = 2;
this.height = 1;
System.out.println("Constructor no para");
}
Cylinder(int radius,int height){
this.radius = radius;
this.height = height;
System.out.println("Constructor with para");
}
public int getVolumn(){
return (int)(this.radius*this.radius*Math.PI*this.height);
}
}
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int radius = scan.nextInt();
int height = scan.nextInt();
Cylinder c1 = new Cylinder(radius,height);
System.out.println(c1.getVolumn());
System.out.println("Constructor with para");
Cylinder c2 = new Cylinder();
System.out.println(c2.getVolumn());
}
}
7-3 正方形类
定义一个正方形类square，在次类中包括写内容：
定义成员变量边长private int edge;
定义方法：包括构造方法，setter getter方法，求面积方法等，要求如下所示：
定义正方形类的构造方法：在构造方法中给edge赋值为2，并添加System.out.println(“this is constructor method”);
为成员变量edge设置set方法，用来接收用户给edge的值，如果用户给的值<=0,则设置edge值为1
为成员变量edge设置get方法，用来返回edge的值
完成求面积方法，得到正方形的面积：public int getArea()
定义类Main，并在main方法中， 1.首先创建正方形对象s1，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
2.创建正方形对象s2,并通过键盘输入s2对象的边的值，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
输入格式:
输入在一行中给出边的值。
输出格式:
输出s1对象的边、输出s1对象的面积 输出s2对象的边、s2对象的面积
import java.util.Scanner;
class square{
private int edge;
square(){
edge=2;
System.out.println("this is constructor method");
}
void setEdge(int edge){
if(edge<=0){this.edge=1;}
else{this.edge=edge;}
}
int getEdge(){
return edge;
}
public int getArea(){
return edge*edge;
}
}
public class Main{
public static void main(String args[]){
square s1=new square();
System.out.println("s1:edge="+s1.getEdge());
System.out.println("s1:area="+s1.getArea());
square s2=new square();
Scanner sc=new Scanner(System.in);
s2.setEdge(sc.nextInt());
System.out.println("s2:edge="+s2.getEdge());
System.out.println("s2:area="+s2.getArea());
}
}
7-4 Circle类
a 定义圆类Circle，其中包括：
成员变量定义 private int radius
方法定义 包括下列要求
定义无参构造方法 ，给radius赋值为2，并添加语句System.out.println(“this is a constructor”);
定义有参构造方法 ，接收用户给给radius赋值，如果用户输入半径为<=0,则让半径的值为2，并添加语句System.out.println(“this is a constructor with para”);
为radius半径添加setter方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2
为radius半径添加getter方法，返回用户输入的半径
定义求面积方法public int gerArea(),π使用Math.PI代替，面积的结果强制转换为int返回
定义toString方法，public String toString( )方法体为：
return “Circle [radius=” + radius + “]”;
b定义Main类，在main方法中，完成下列操作
.定义并创建Circle的第一个对象c1，并使用println方法输出c1
求c1的面积并输出
定义并创建Circle的第一个对象c2，并使用println方法输出c2
从键盘接收整数半径，并赋值给c2的半径，使用println方法输出c2
求c2的面积并输出
从键盘接收整数半径，并创建Circle的第三个对象c3，并将用户输入整数半径通过有参构造方法传递给出c3，使用println方法输出c3
求c3的面积并输出
输入格式:
从键盘输入一个整数半径
输出格式:
分别输出c1和c2对象的信息
import java.util.Scanner;
class Circle{
private int radius;
Circle(){
radius = 2;
System.out.println("this is a constructor");
}
Circle(int radius){
if(radius <= 0){this.radius=2;}
else{this.radius=radius;}
System.out.println("this is a constructor with para");
}
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
if(radius <= 0){this.radius=2;}
else{this.radius=radius;}
}
public int getArea(){
return (int)(this.radius*this.radius*Math.PI);
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
public class Main{
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
Circle c1=new Circle();
System.out.println("Circle [radius="+c1.getRadius()+"]");
System.out.println("c1:area="+c1.getArea());
Circle c2=new Circle();
System.out.println("Circle [radius="+c2.getRadius()+"]");
c2.setRadius(sc.nextInt());
System.out.println("Circle [radius="+c2.getRadius()+"]");
System.out.println("c2:area="+c2.getArea());
Circle c3=new Circle(sc.nextInt());
System.out.println("Circle [radius="+c3.getRadius()+"]");
System.out.println("c3:area="+c3.getArea());
}
}
7-5 学生类设计
设计一个类Student，并在Main类中生成Student类对象进行测试
1.对于Student类，设计私有属性name和age，并为每一个成员变量name和age设计其setXXX（）和getXXX（）方法,并对于setAge方法，如果age被赋值为<=6,则age值为7，其他为参数值。
2.对于Student类，设计无参构造方法，在构造方法中为age赋值为7，name赋值为“无名" 并添加语句System.out.println(“无参构造方法”)；
3.设计方法public void display(),方法中显示该学生的姓名和年龄，显示格式为name：无名，age：8
Main类的main方法中，创建1个学生对象，然后调用display方法显示学生信息，接着通过键盘输入1个学生的姓名和年龄，调用display方法去显示学生信息。
输入格式:
在一行内输入学生的姓名和年龄
输出格式:
对每一组输入，输出学生的姓名和年龄。
import java.util.Scanner;
class Student{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age <= 6){this.age=7;}
else{this.age = age;}
}
Student(){
this.name = "无名";
this.age = 7;
System.out.println("无参构造方法");
}
public void display(){
System.out.println("name:"+this.name+",age:"+this.age);
}
}
public class Main{
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
Student s=new Student();
s.display();
s.setName(sc.next());
s.setAge(sc.nextInt());
s.display();
}
}
7-7 jmu-Java-03面向对象基础-03-形状
- 定义长方形类与圆形类Circle 长方形类-类名：Rectangle，private属性：int width,length
圆形类-类名：Circle，private属性:int radius
编写构造函数：
带参构造函数:Rectangle(width, length),Circle(radius)
编写方法：
public int getPerimeter()，求周长。
public int getArea()，求面积。
toString方法，使用Eclipse自动生成。
注意：
计算圆形的面积与周长，使用Math.PI。
求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。
2. main方法
输入2行长与宽，创建两个Rectangle对象放入相应的数组。
输入2行半径，创建两个Circle对象放入相应的数组。
输出1：上面2个数组中的所有对象的周长加总。
输出2：上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。
输入样例:
1 2
3 4
7
1
输出样例:
69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
Rectangle[] rectangle=new Rectangle[2];
rectangle[0]=new Rectangle(in.nextInt(),in.nextInt());
rectangle[1]=new Rectangle(in.nextInt(),in.nextInt());
Circle[] circles=new Circle[2];
circles[0]=new Circle(in.nextInt());
circles[1]=new Circle(in.nextInt());
System.out.println(rectangle[0].getPerimeter()+rectangle[1].getPerimeter()+
circles[0].getPerimeter()+circles[1].getPerimeter());
System.out.println(rectangle[0].getArea()+rectangle[1].getArea()+
circles[0].getArea()+circles[1].getArea());
System.out.println(Arrays.deepToString(rectangle));
System.out.println(Arrays.deepToString(circles));
}
}
class Rectangle{
private int width;
private int length;
Rectangle(){}
Rectangle(int width,int length){
this.length = length;
this.width = width;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getPerimeter(){
return ((this.length+this.width)*2);
}
public int getArea(){
return (this.length*this.width);
}
@Override
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
}
class Circle{
private int radius;
Circle(){}
Circle(int radius){
this.radius =radius;
}
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
public int getPerimeter(){
return (int)(2*this.radius*Math.PI);
}
public int getArea(){
return (int)(this.radius*this.radius*Math.PI);
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
7-8 学生类-构造函数
定义一个有关学生的Student类，内含类成员变量： String name、String sex、int age，所有的变量必须为私有(private)。
1.编写有参构造函数： 能对name,sex,age赋值。
2.覆盖toString函数：
按照格式：类名 [name=, sex=, age=]输出。使用idea自动生成,然后在修改成该输出格式
3.对每个属性生成setter/getter方法
4.main方法中
•输入1行name age sex , 调用上面的有参构造函数新建对象。
输入样例:
tom 15 male
输出样例:
Student [name='tom', sex='male', age=15]
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String name=sc.next();
int age=Integer.valueOf(sc.next());
String sx=sc.next();
Student student = new Student(name, sx, age);
System.out.print(student);
}
}
class Student{
private String name;
private String sex;
private int age;
Student(){}
Student(String name,String sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
String str= "Student [name='" + name + "', sex='" + sex + "', age=" + age + "]";
return str;
}
}
7-9 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
统计一行字符串中的英文字母个数、空格个数、数字个数、其他字符个数
输入格式:
通过键盘输入一行字符(任意字符）
输出格式:
统计一行字符串中的中英文字母个数、空格个数、数字个数、其他字符个数
输入样例:
rwrwewre2345asdJSJQI%^&(& *&sdf YY( 2342-k'
输出样例:
字母个数：22
数字个数：8
空格个数：5
其他字符个数：10
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
sc.close();
char[] chars = str.toCharArray();
int letter=0,num=0,blank=0,other=0;
for(int i=0;i<chars.length;i++) {
if((chars[i]>='A' && chars[i]<='Z') || (chars[i]>='a' && chars[i]<='z')){
letter++;
}else if(chars[i]>=47 && chars[i]<=57) {
num++;
}else if(chars[i]==32) {
blank++;
}else {
other++;
}
}
System.out.println("字母个数："+letter);
System.out.println("数字个数："+num);
System.out.println("空格个数："+blank);
System.out.println("其他字符个数："+other);
}
}
7-10 统计商品总价
消费者购买超市5件商品，输入商品名和价格，输出购买的商品信息，并输出应付的总价。
要求：定义Goods类及其成员变量和方法。
（1）定义Goods类：成员变量有 name, price
（2）定义Goods类的带两个参数的构造方法。
（3）定义Goods类的toString()方法，getPrice()方法。
主程序如下：
class Main{
public static void main(String args[]){
Goods ga[] =new Goods[5];
Scanner sc = new Scanner(System.in);
for(int i =0;i<5;i++){
ga[i]= new Goods(sc.next(),sc.nextDouble());
}
double shouldPay = 0;
for(Goods g:ga){
shouldPay += g.getPrice();
System.out.println(g.toString());
}
System.out.println("should pay:"+shouldPay);
}
}
输入格式:
输入5行数据，每行一个商品信息，包括商品名和价格，以一个空格分隔。 例： book 5.5 pencil 1.2 pen 8.0 ruler 2.5 eraser 1.0
输出格式:
输入信息有6行，前5行是商品信息，每行包括商品名和价格，以一个逗号分隔。 第6行为商品的应付总价，格式是：should pay:总价 例： book,5.5 pencil,1.2 pen,8.0 ruler,2.5 eraser,1.0 should pay:18.2
输入样例:
book 5.5
pencil 1.2
pen 8.0
ruler 2.5
eraser 1.0
输出样例:
在这里给出相应的输出。例如：
book,5.5
pencil,1.2
pen,8.0
ruler,2.5
eraser,1.0
should pay:18.2
import java.util.Scanner;
class Main{
public static void main(String args[]){
Goods ga[] =new Goods[5];
Scanner sc = new Scanner(System.in);
for(int i =0;i<5;i++){
ga[i]= new Goods(sc.next(),sc.nextDouble());
}
double shouldPay = 0;
for(Goods g:ga){
shouldPay += g.getPrice();
System.out.println(g.toString());
}
System.out.println("should pay:"+shouldPay);
}
}
class Goods{
String name;
double price;
Goods(){}
Goods(String name,double price){
this.name = name;
this.price = price;
}
public double getPrice() {
return price;
}
@Override
public String toString() {
return name + "," + price;
}
}
7-11 定义商品类，封装成员变量，输出对象
定义一个商品类。创建对象并按指定格式输出它。 商品类要求：
（1）成员变量：商品编号（String） 、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价
测试类要求：
按指定的格式 输入商品信息，调用构造方法生成对象，并输出它。
例：输入：WJ002 记事本 5.5
输出：WJ002,记事本,5.5
输入商品的信息，每个属性值之间用1个空格分隔。 输出 格式，商品的每个属性值之间用逗号分隔。
输入格式:
WJ002 记事本 5.5
输出格式:
WJ002,记事本,5.5
输入样例:
WJ002 记事本 5.5
输出样例:
WJ002,记事本,5.5
import java.util.Scanner;
class Product{
private String num ;
private String name;
private double price;
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
Product(String num,String name,double price){
this.num = num;
this.name = name;
this.price = price;
}
@Override
public String toString() {
return num + "," + name + "," + price;
}
}
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String num = scan.next();
String name = scan.next();
double price = scan.nextDouble();
Product p = new Product(num,name,price);
System.out.println(p.toString());
}
}
7-12 定义类与创建对象
定义一个类Person,定义name和age属性，定义有参的构造方法对name和age进行初始化。在测试类中创建该类的2个对象，姓名、年龄分别为lili、19和lucy、20，在屏幕打印出2个对象的姓名和年龄。
输入格式:
本题目无输入
输出格式:
在一行中输出一个人的姓名和年龄
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
this person is lili,her age is 19
this person is lucy,her age is 20
class Person {
String name;
int age;
Person(){}//person() person类的无参构造方法(自动生成为声明其它构造函数）
Person(String name,int age){
this.name = name;
this.age = age;
}
void display(){
System.out.println("this person is "+this.name+",her age is "+this.age);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();//Person() Person类的无参构造方法自动生成
Person p2 = new Person("lili",19);
Person p3 = new Person("lucy",20);
p2.display();
p3.display();
}
}
7-13 点
点是最简单的形，是几何图形最基本的组成部分。要求设计一个点类Point类，Point类包括：
坐标成员变量 int x,int y
成员变量x,y的setter gette方法，以及ToString方法
带参无参构造方法
重写hashcode和equals方法，判断两个点是否相同
实现接口Comparable，可以比较两个点的大小，比较规则是若第一个点x大，则第一个点大，第一个点x小则第一个点小，若相同，比较y，根据y值判断大小。
实现方法 int distance(Point p2),求两个点的距离（开平方根使用方法Math.sqrt()）
测试类中main方法中，要求如下：
通过键盘输入2个点坐标，创建2个点对象
输出第一个点的信息（调用ToString方法），
比较他们的大小，如果第一点大于等于第二个点，输出true否则输出false
求这两个点的距离并输出。
输入格式
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
输入两行，每行为一个点的坐标
输入样例:
在这里给出一组输入。例如：
4 6
6 7
4 5
3 2
输出样例:
在这里给出相应的输出。例如：
Point [x=4, y=6]
false
2
Point [x=4, y=5]
true
3
import java.util.Scanner;
class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
Point p1 = new Point(in.nextInt(),in.nextInt());
Point p2 = new Point(in.nextInt(),in.nextInt());
System.out.println(p1.toString());
Comparable x = new Com();
System.out.println(x.comparable(p1, p2));
distance(p1,p2);
}
public static void distance(Point p1,Point p2) {
int a=(int)Math.sqrt(Math.abs(p1.getX()-p2.getX())*Math.abs(p1.getX()-p2.getX())+Math.abs(p1.getY()-p2.getY())*Math.abs(p1.getY()-p2.getY()));
System.out.println(a);
}
}
interface Comparable{
boolean comparable(Point p1,Point p2);
}
class Com implements Comparable{
@Override
public boolean comparable(Point p1,Point p2) {
boolean fh = true;
if(p1.getX()<p2.getX()) {
fh = false;
}
if(p1.getX()==p2.x) {
if(p1.getY()<p2.getY()) {
fh = false;
}
}
return fh;
}
}
class Point {
int x;
int y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
Point(){}
Point(int x,int y){
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Point other = (Point) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
7-14 设计一个BankAccount类
设计一个BankAccount类，这个类包括：
（1）一个int型的balance表时账户余额。
（2）一个无参构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。
（4）一个getBlance（）方法，返回账户余额。
（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。
（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。
设计一个Main类进行测试，分别输入账户余额、提取额度以及存款额度，并分别输出账户余额。
输入格式:
依次输入账户余额、提取额度、存款额度
输出格式:
依次输出初始账户余额、提取amount额度后的账户余额、存入amount后的账户余额
输入样例:
在这里给出一组输入。例如：
700
70
7
输出样例:
在这里给出相应的输出。例如：
700
630
637
import java.util.Scanner;
class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
BankAccount n = new BankAccount(sc.nextInt());
System.out.println(n.getBalance());
System.out.println(n.withdraw(sc.nextInt()));
System.out.println(n.deposit(sc.nextInt()));
}
}
class BankAccount{
int balance;
BankAccount(){
this.balance = 0;
}
BankAccount(int balance){
this.balance = balance;
}
public int getBalance() {
return balance;
}
public int withdraw(int amount) {
this.balance = this.balance - amount;
return this.balance;
}
public int deposit(int amount) {
this.balance = this.balance + amount;
return this.balance;
}
}
7-15 时间类
设计一个名为Time 的类。这个类包含：
表示时间的数据域hour、minute 和second。
一个以当前时间创建Time 对象的无参构造方法（数据域的值表示当前时间）。
一个构造Time 对象的构造方法，这个对象有一个特定的时间值，这个值是以毫秒表示的、从1970 年1 月丨日午夜开始现在流逝的时间段（数据域的值表示这个时间）。
一个构造带特定的小时、分钟和秒的Time 对象的构造方法。
三个数据域hour、minute 和second 各自的get 方法。
— 个名为setTime(long elapseTime)的方法使用流逝的时间给对象设置一个新时间。例如，如果流逝的时间为555550000 毫秒，則转换为10 小时、10 分钟、10 秒。
编写一个测试程序，创建两个Time 对象（使用new Time() 和new Time(555550000)), 然后显示它们的小时、分钟和秒.
输入格式:
输入毫秒
输出格式:
按照小时、分钟、秒显示
输入样例:
在这里给出一组输入。例如：
555550000
输出样例:
在这里给出相应的输出。例如：
Hour: 10 Minute: 19 Second: 10
public class Main {
public static void main(String[] args) {
Time time=new Time();
Time tim1=new Time(555550000);
System.out.println("Hour: "+tim1.getHour()+" Minute: "+tim1.getMinute()+" Second: "+tim1.getSecond());
}
}
class Time{
long hour;
long minute;
long second;
long time;
Time(){
time = System.currentTimeMillis() + 8 * 60 * 60 * 1000;
//current得到的时间为格林威治时间,与北京时间即系统时间相差八小时
hour = time / 1000 / 3600 % 24;
//得到小时
minute = time / 1000 % 3600 / 60;
//得到分钟
second = time / 1000 % 3600 % 60;}
Time(long time){
// TODO implement here
hour = time / 1000 / 3600 % 24;
//得到小时
minute = time / 1000 % 3600 / 60;
//得到分钟
second = time / 1000 % 3600 % 60;
//得到秒
}
Time(long hour, long minute, long second){
this.hour = hour;
this.minute = minute;
this.second = second;
}
public long getHour() {
return hour;
}
public void setHour(long hour) {
this.hour = hour;
}
public long getMinute() {
return minute;
}
public void setMinute(long minute) {
this.minute = minute;
}
public long getSecond() {
return second;
}
public void setSecond(long second) {
this.second = second;
}
public void setTime(long elapseTime) {
// TODO implement here
time = elapseTime;
}
}