7-1 sdut-oop-1 简单的复数运算
设计一个类Complex，用于封装对复数的下列操作：
成员变量：实部real，虚部image，均为整数变量；
构造方法：无参构造方法、有参构造方法（参数2个）
成员方法：含两个复数的加、减、乘操作。
复数相加举例： （1+2i）+（3+4i）= 4 + 6i
复数相减举例： （1+2i）－（3+4i）= －2 － 2i
复数相乘举例： （1+2i）*（3+4i）= －5 + 10i
要求：对复数进行连环算术运算。
提示：如果用PYTHON语言实现，不必设计Complex类，可以使用内置的复数数据类型，完成复数的算术运算。
输入格式:
输入有多行。
第一行有两个整数，代表复数X的实部和虚部。
后续各行的第一个和第二个数表示复数Y的实部和虚部，第三个数表示操作符op： 1——复数X和Y相加；2——复数X和Y相减；3——复数X和Y相乘。
当输入0 0 0时，结束运算，输出结果。
输出格式:
输出一行。
第一行有两个整数，代表复数的实部和虚部，实部和虚部之间用1个空格分开。
输入样例:
1 1
3 4 2
5 2 1
2 -1 3
0 2 2
0 0 0
输出样例:
5 -7
实现代码：
import java.util.Scanner;
class Complex{
int real;
int image;
public Complex(){
}
public Complex(int real,int image){
this.image=image;
this.real=real;
}
public void add(Complex other)
{
int r=real+other.real;
int i=image+other.image;
this.real=r;
this.image=i;
}
public void sub(Complex other)
{
int r=real-other.real;
int i=image-other.image;
this.real=r;
this.image=i;
}
public void div(Complex other)
{
int r=real*other.real-image*other.image;
int i=image*other.real+other.image*real;
this.real=r;
this.image=i;
}
public String Print()
{
return this.real+" "+this.image;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int m=Scan.nextInt();
int n=Scan.nextInt();
Complex cc=new Complex(m,n);//初始的复数
while(Scan.hasNext())
{
int a=Scan.nextInt();
int b=Scan.nextInt();
int c=Scan.nextInt();
if(a==0&&b==0&&c==0)
{
System.out.println(cc.Print());
break;
}
Complex other=new Complex(a,b);
if(c==1) cc.add(other);
else if(c==2) cc.sub(other);
else if(c==3) cc.div(other);
}
}
}
7-2 sdut-oop-2 Shift Dot(类和对象）
给出平面直角坐标系中的一点，并顺序给出n个向量，求该点根据给定的n个向量位移后的位置。
设计点类Point，内含：
（1）整型属性x和y，表示点的横坐标和纵坐标；
（2）带参构造方法，便于使用初始值构造该类对象；
（3）点移动的方法move(x1,y1)，其 中x1和y1表示移动的向量，该方法返回移动后的新的点对象；
（4）展示点对象的字符串方法toString()，以“(横坐标,纵坐标）”的形式。
输入格式:
多组输入。
第一行是三个整数x，y，n，表示点的坐标（x，y），和向量的个数n。
接下来n行，每行两个数xi，yi，表示第i个向量。
题目中所有数据不会超出整型范围。
输出格式:
对于每组输入，输出一行，形式为："(x,y)"，表示点的最终点位置的横坐标和纵坐标。
输入样例:
0 0 1
2 3
0 0 2
1 2
2 3
输出样例:
(2,3)
(3,5)
实现代码：
import java.util.Scanner;
class Point{
int x;
int y;
public Point(int x,int y)
{
this.x=x;
this.y=y;
}
public void move(int x1,int y1)
{
this.x=this.x+x1;
this.y=this.y+y1;
}
public String toString()
{
return "("+x+","+y+")";
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
while(Scan.hasNext())
{
int x=Scan.nextInt();
int y=Scan.nextInt();
Point cc=new Point(x,y);
int n=Scan.nextInt();
for(int i=0;i<n;i++)
{
int x1=Scan.nextInt();
int y1=Scan.nextInt();
cc.move(x1,y1);
}
System.out.println(cc.toString());
}
}
}
7-3 sdut-oop-3 输出人的信息（程序改错）
下述代码有错，请参照程序的输出修改程序。
public class Main {
public static void main(String[] args) {
Person[] p = new Person[3];
p[0].name = "zhangsan";
p[0].age = 18;
p[1].name = "lisi";
p[1].age = 20;
p[2].name = "wangwu";
p[2].age = 22;
for (int i = 0; i < p.length; i++) {
System.out.println(p[i]);
}
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
输入格式:
无输入。
输出格式:
Person类对象的属性name和age，中间用1个空格分隔。
输入样例:
输出样例:
zhangsan 18
lisi 20
wangwu 22
实现代码：
public class Main {
public static void main(String[] args) {
Person[] p = new Person[3];
for(int i=0;i<3;i++)
{
p[i]=new Person();
}
p[0].setName("zhangsan");
p[0].setAge(18);
p[1].setName("lisi");
p[1].setAge(20);
p[2].setName("wangwu");
p[2].setAge(22);
for (int i = 0; i < p.length; i++) {
System.out.println(p[i].toString());
}
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person()
{
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public String toString()
{
return name+" "+age;
}
}
7-4 sdut-oop-4-求圆的面积（类与对象）
按要求完成程序的编写。
1、定义圆类Circle，其中包括：
（1）成员变量：private int radius
（2）无参构造方法 ，给radius赋值为2，并输出信息："This is a constructor with no para."；
（2）有参构造方法 ，接收用户给的radius赋值，并输出"This is a constructor with para."（如果给的半径小于等于0,则赋默认值为2）；
（3）为radius添加set方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2；
（4）为radius半径添加get方法，返回用户输入的半径；
（5）求圆面积方法getArea(), π使用Math.PI代替；
（6）定义toString方法，public String toString( )方法体为：
return "Circle [radius=" + radius + "]";
2、定义Main类，在main方法中，完成下列操作：
（1）定义并创建Circle类对象c1，输出c1对象，求c1的面积并输出；
（2）定义并创建Circle类对象c2，输出c2对象，求c2的面积并输出；
（3）从键盘接收整数半径，赋值给c2的半径，输出c2对象，求c2的面积并输出；
（4）从键盘接收整数半径，用有参构造方法创建Circle类对象c3，输出c3对象，求c3的面积后输出。
输入格式:
输入有多行。每行包括一个整数的圆的半径。
输出格式:
按照题目要求，输出圆构造方法的输出信息、圆对象的字符中描述信息、及圆的面积（其中圆的面积保留2位小数）。上述信息各占一行。
输入样例:
4
5
输出样例:
This is a constructor with no para.
Circle [radius=2]
12.57
This is a constructor with no para.
Circle [radius=2]
12.57
Circle [radius=4]
50.27
This is a constructor with para.
Circle [radius=5]
78.54
实现代码：
import javax.swing.*;
import java.util.Scanner;
class Circle{
private int radius;
public Circle()
{
radius=2;
System.out.println("This is a constructor with no para.");
}
public 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 String getArea()
{
return String.format("%.2f",Math.PI*radius*radius) ;
}
public String toString()
{
return "Circle [radius=" + radius + "]";
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
Circle c1=new Circle();
System.out.println(c1.toString());
System.out.println(c1.getArea());
Circle c2=new Circle();
System.out.println(c2.toString());
System.out.println(c2.getArea());
int r2=Scan.nextInt();
c2.setRadius(r2);
System.out.println(c2.toString());
System.out.println(c2.getArea());
int r3=Scan.nextInt();
Circle c3=new Circle(r3);
System.out.println(c3.toString());
System.out.println(c3.getArea());
}
}
7-5 sdut-oop-9 计算长方形的周长和面积（类和对象）
设计一个长方形类Rect，计算长方形的周长与面积。
成员变量：整型、私有的数据成员length(长)、width(宽)；
构造方法如下：
（1）Rect(int length) —— 1个整数表示正方形的边长
（2）Rect(int length, int width)——2个整数分别表示长方形长和宽
成员方法：包含求面积和周长。（可适当添加其他方法）
要求：编写主函数，对Rect类进行测试，输出每个长方形的长、宽、周长和面积。
输入格式:
输入多组数据；
一行中若有1个整数，表示正方形的边长；
一行中若有2个整数（中间用空格间隔），表示长方形的长度、宽度。
若输入数据中有负数，则不表示任何图形，长、宽均为0。
输出格式:
每行测试数据对应一行输出，格式为：
长度 宽度 周长 面积（数据之间有1个空格分隔）
输入样例:
在这里给出一组输入。例如：
1
2 3
4 5
2
-2
-2 -3
输出样例:
在这里给出相应的输出。例如：
1 1 4 1
2 3 10 6
4 5 18 20
2 2 8 4
0 0 0 0
0 0 0 0
实现代码：
import java.util.Scanner;
class Rect{
private int length;
private int width;
public Rect(int length)
{
if(length<=0) this.length=0;
else this.length=length;
}
public Rect(int length,int width)
{
// if(length<=0) this.length=0;
// else this.length=length;
// if(width<=0) this.length=0;
// else this.width=width;
if(length<=0||width<=0)
{
this.length=this.width=0;
}
else
{
this.length=length;
this.width=width;
}
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getArea1()
{
return length*length;
}
public int getArea2()
{
return length*width;
}
public int zhou1()
{
return length*4;
}
public int zhou2()
{
return (length+width)*2;
}
public String toString1()
{
return length+" "+length+" "+zhou1()+" "+getArea1();
}
public String toString2()
{
return length+" "+width+" "+zhou2()+" "+getArea2();
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
while(Scan.hasNext())
{
String StrData=Scan.nextLine();
String []arrayData=StrData.split(" ");
int num= arrayData.length;
if(num==1)
{
int length=Integer.parseInt(arrayData[0]);
Rect rect=new Rect(length);
System.out.println(rect.toString1());
}
else if(num==2)
{
int length=Integer.parseInt(arrayData[0]);
int width=Integer.parseInt(arrayData[1]);
Rect rect=new Rect(length,width);
System.out.println(rect.toString2());
}
}
}
}
7-6 sdut-谁是最强的女汉子
众所周知，一年一度的女汉子大赛又来啦。由于最近女汉子比较流行，所以参加女汉子比赛的人数变得很多很多。所以赛事组找来了你，让你写一个程序找出谁是最强的女汉子。
大家都知道，越是不漂亮的女生就越容易成为女汉子（漂亮的怎么会成为汉子？）,而越是力量大的女生也越成为女汉子（毕竟女汉子还是比较有力量的）。
所以，就给女汉子两个属性，一个是漂亮值x，一个是力量值y。当然x的值越大，就代表这个女生就越漂亮。现在想让你求出来最不漂亮的女生有多少个，她们的力量和是多少。
输入格式:
先输入一个T，代表有T个人（T<10000）。
接下来T行，每行有两个数字x,y，分别代表这个女汉子的漂亮值和力量值（x,y<2*109) 。中间有1个空格分隔。
输出格式:
输出一行，有两个数字，分别代表最强的女汉子的数量，和她们的力量和。中间用1个空格分隔。
输入样例:
5
1 1
2 2
1 4
2 10
10 100
输出样例:
2 5
实现代码：
import java.util.Scanner;
class People{
int x;
int y;
public People()
{
}
public People(int x,int y)
{
this.x=x;
this.y=y;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int n=Scan.nextInt();
People []p=new People[n];
// for(int i=0;i<n;i++)
// {
// p[i]=new People();
// }
for(int i=0;i<n;i++)
{
int x=Scan.nextInt();
int y=Scan.nextInt();
p[i]=new People(x,y);
}
int Min=p[0].x;
int Sumy=p[0].y;
int num=1;
int num2=1;
for(int i=1;i<n;i++)
{
if(p[i].x<Min)
{
num++;
Min=p[i].x;
Sumy=p[i].y;
}
else if(p[i].x==Min)
{
num++;
num2++;
Sumy=Sumy+p[i].y;
}
}
if(num==1)
{
System.out.println(num+" "+Sumy);
}
else
{
System.out.println(num2+" "+Sumy);
}
}
}
7-7 sdut-oop-8 分数四则运算
定义类Fraction，在其中定义属性:numerator和denominator，分别表示分子和分母。
然定再定义两个分数的加、减、乘、除运算的方法。
在主类中输入2个分数，计算它们的四则运算结果。
提示：若用Python语言来实现，不必自行创建类，可直接使用 fractions模块处理分数的表示与运算。
输入格式:
第一行是整数N，表示待进行分数四则运算式子的数量。接下来包含N行输入。
每行数据是一个字符串，格式是"a/boc/d"。
其中a, b, c, d为数字（每个数字保证在int类型范围内，为正数并且不存在正号）。o是运算符"+"或者"-","*",""。
输出格式:
对于每一行分数四则运算，输出一行计算结果。
注意：结果应符合书写习惯，没有多余的符号、分子、分母，并且化简至最简分数形式。
输入样例:
5
1/100+3/100
1/4-1/2
1/3-1/3
1/2*2/1
1/2\\1/2
输出样例:
1/25
-1/4
0
1
1
实现代码：
import java.util.*;
class Fraction{
int numerator;
int denominator;
public Fraction(int fz,int fm)
{
this.numerator=fz;
this.denominator=fm;
}
public Fraction add(Fraction fs1)
{
int newFz=numerator*fs1.denominator+denominator*fs1.numerator;
int newFm=denominator*fs1.denominator;
return new Fraction(newFz,newFm);
}
public Fraction sub(Fraction fs1)
{
int newFz=numerator*fs1.denominator-denominator*fs1.numerator;
int newFm=denominator*fs1.denominator;
return new Fraction(newFz,newFm);
}
public Fraction mul(Fraction fs1)
{
int newFz=numerator*fs1.numerator;
int newFm=denominator*fs1.denominator;
return new Fraction(newFz,newFm);
}
public Fraction div(Fraction fs1)
{
int newFz=numerator*fs1.denominator;
int newFm=denominator*fs1.numerator;
return new Fraction(newFz,newFm);
}
public int gcd(int m,int n)
{
int r=0;
while((r=m%n)!=0)
{
m=n;
n=r;
}
return n;
}
public String toString() {
//分数的符号问题，分子整出分母，分数最简化形式
int gcd=gcd(numerator,denominator);//求分子分母的最大公约数
numerator=numerator/gcd;//化简分子
denominator=denominator/gcd;//化简分母
String str=numerator*denominator<0?"-":"";//分数的符号
if(numerator%denominator==0)//分子整除分母
{
str+=Math.abs(numerator/denominator);
}
else
{
str=str+Math.abs(numerator)+"/"+Math.abs(denominator);
}
return str;
}
}
public class Main {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int n=reader.nextInt();
for(int i=0;i<n;i++)
{
String expression = reader.next();
String[] digits=expression.split("\\\\D+");
int a=Integer.parseInt(digits[0]);
int b=Integer.parseInt(digits[1]);
int c=Integer.parseInt(digits[2]);
int d=Integer.parseInt(digits[3]);
Fraction fs1=new Fraction(a,b);
Fraction fs2=new Fraction(c,d);
String[] ops=expression.split("\\\\d+");
char op=ops[2].charAt(0);
switch(op)
{
case '+':
fs1=fs1.add(fs2);
break;
case '-':
fs1=fs1.sub(fs2);
break;
case '*':
fs1=fs1.mul(fs2);
break;
case '\\\\':
fs1=fs1.div(fs2);
break;
}
System.out.println(fs1);
}
}
}
7-8 sdut-分数加减法
编写一个程序，实现两个分数的加减法。
输入格式:
输入包含多行数据。
每行数据是一个字符串，格式是"a/boc/d"。
其中a, b, c, d是一个0-9的整数。o是运算符"+"或者"-"。
输出格式:
对于输入数据的每一行输出两个分数的运算结果。
注意：结果应符合书写习惯，没有多余的符号、分子、分母，并且化简至最简分数。
输入样例:
在这里给出一组输入。例如：
1/8+3/8
1/4-1/2
1/3-1/3
输出样例:
在这里给出相应的输出。例如：
1/2
-1/4
0
实现代码：
import java.util.Scanner;
class Fs{
int gys(int a,int b)
{
int Min=Math.min(Math.abs(a),Math.abs(b));
for(int i=Min;i>=1;i–)
{
if(a%i==0&&b%i==0)
{
return i;
}
}
return 1;
}
int Fz;
int Fm;
public Fs(){
}
public Fs(int Fz,int Fm)
{
this.Fz=Fz;
this.Fm=Fm;
}
public Fs jia(Fs other)
{
int ffz=Fz*other.Fm+Fm*other.Fz;
int ffm=Fm*other.Fm;
return new Fs(ffz/gys(ffz,ffm),ffm/gys(ffz,ffm));
}
public Fs jian(Fs other)
{
int ffz=Fz*other.Fm-Fm*other.Fz;
int ffm=Fm*other.Fm;
return new Fs(ffz/gys(ffz,ffm),ffm/gys(ffz,ffm));
}
public String toString()
{
String Str;
if(Fz*Fm<0) Str="-";
else Str="";
if(Fz%Fm==0) Str=Str+Math.abs(Fz/Fm);
else Str=Str+Math.abs(Fz)+"/"+Math.abs(Fm);
return Str;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
// int n=Scan.nextInt();
// for(int i=0;i<n;i++)
while(Scan.hasNext())
{
String s=Scan.next();
String ss1[]=s.split("\\\\D+");
String ss2[]=s.split("\\\\d+");
int a= Integer.parseInt(ss1[0]);
int b= Integer.parseInt(ss1[1]);
int c= Integer.parseInt(ss1[2]);
int d= Integer.parseInt(ss1[3]);
Fs fs1=new Fs(a,b);
Fs fs2=new Fs(c,d);
char op=ss2[2].charAt(0);
switch(op)
{
case '+':
fs1=fs1.jia(fs2);
break;
case '-':
fs1=fs1.jian(fs2);
break;
}
System.out.println(fs1.toString());
}
}
}
7-9 sdut-Time类的定义与使用
设计一个时间类Time。它拥有：
私有数据成员：hour(时)、minute(分)、second(秒)；
公开的成员函数：
setHour(int)设置数据成员hour的值（采用12小时制），非法的输入默认为12；
setMinue(int)设置数据成员minute的值，非法输入默认为0；
setSecond(int)设置数据成员second的值，非法输入默认为0；
setTime(int，int，int)设置时、分、秒三个数据成员的值；
showTime()显示时间对象的值。
在主函数main()中调用相应成员函数，使得时间对象的值能从键盘接收，并正确显示。
提示：时、分、秒均按2位数值形式显示 。
输入格式:
输入3个整数，用一个空格间隔。
输出格式:
输出 时、分、秒的值，中间用“:”间隔。
输入样例1:
10 11 12
输出样例1:
10:11:12
输入样例2:
58 23 85
输出样例2:
12:23:00
实现代码：
import java.util.Scanner;
class Time{
private int hour;//时
private int minute;//分
private int second;//秒
public Time(){
}
public Time(int hour,int minute,int second)
{
this.hour=hour;
this.minute=minute;
this.second=second;
}
public int getHour() {
return hour;
}
public void setHour(int hour) {
if(hour<0||hour>12) this.hour=12;
else this.hour = hour;
}
public int getMinute() {
return minute;
}
public void setMinute(int minute) {
if(minute<0||minute>60) this.minute=0;
else this.minute = minute;
}
public int getSecond() {
return second;
}
public void setSecond(int second) {
if(second<0||second>60) this.second=0;
else this.second = second;
}
public void setTime(int hour,int minute,int second)
{
setHour(hour);
setMinute(minute);
setSecond(second);
}
public String showTime()
{
return hour+":"+minute+":"+second;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int a=Scan.nextInt();
int b=Scan.nextInt();
int c=Scan.nextInt();
Time t=new Time(a,b,c);
t.setTime(a,b,c);
// System.out.println(t.showTime());
int h=t.getHour();
int m=t.getMinute();
int s=t.getSecond();
System.out.printf("%02d:%02d:%02d",h,m,s);
}
}
7-10 定义商品类，封装成员变量，输出对象
定义一个商品类。创建对象并按指定格式输出它。
商品类要求：
（1）成员变量：商品编号（String） 、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价
测试类要求：
按指定的格式 输入商品信息，调用构造方法生成对象，并输出它。
例：输入：WJ002 记事本 5.5
输出：WJ002,记事本,5.5
输入商品的信息，每个属性值之间用1个空格分隔。
输出 格式，商品的每个属性值之间用逗号分隔。
输入样例:
WJ002 记事本 5.5
输出样例:
WJ002,记事本,5.5
实现代码：
import java.util.Scanner;
class Shop{
private String Id;//编号
private String Name;//名称
private double Money;//单价
public Shop(){
}
public Shop(String Id,String Name,double Money)
{
this.Id=Id;
this.Name=Name;
this.Money=Money;
}
public String getId() {
return Id;
}
public void setId(String id) {
Id = id;
}
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public double getMoney() {
return Money;
}
public void setMoney(double money) {
Money = money;
}
public void Setwx(String Id,String Name,double Money)
{
setId(Id);
setName(Name);
setMoney(Money);
}
public String toString()
{
return Id+","+Name+","+Money;
}
}
public class Main {
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
String Id=Scan.next();
String Name=Scan.next();
double Money=Scan.nextDouble();
Shop s=new Shop(Id,Name,Money);
s.Setwx(Id,Name,Money);
System.out.println(s.toString());
}
}
7-11 声明图书类，记录图书总册数，利用静态变量赋值。
声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
输出格式:
请输出每本图书对应的书名，书号，书价以及总图书数。
输出样例:
书名：Java程序设计, 书号：1, 书价：34.5
书名：数据结构, 书号：2, 书价：44.8
书名：C++程序设计, 书号：3, 书价：35.0
图书总册数为：3
实现代码：
class Book{
String name;
static int id;
double price;
int num = 0;
static int count = 0;
public Book(String name,double price){
this.name = name;
this.price = price;
this.id = num++;
count++;
}
public String toString(){
id++;
return "书名："+name+", 书号："+Book.id+", 书价："+price;
}
}
public class Main {
public static void main(String[] args) {
Book a[] = new Book[3];
a[0]=new Book("Java程序设计",34.5);
a[1]=new Book("数据结构",44.8);
a[2]=new Book("C++程序设计",35.0);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}System.out.println("图书总册数为："+Book.count);
}
}
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(String xm,int nl)
{name=xm;
age=nl;
}
void display() {
System.out.println("this person is "+name+",her age is "+age);
}
}
public class Main{
public static void main(String []args){
Person p1=new Person("lili",19);
Person p2=new Person("lucy",20);
p1.display();
p2.display();
}
}
7-13 计算年龄
定义一个Birthday类，其成员变量有3个整形变量（出生的年月日）：year,month,day；提供构造方法对这3个成员变量进行初始化；提供成员变量的get、set方法；成员函数有getAge(),功能是实现计算到2017年12月25日时该Birthday对象的年龄。编写程序测试这个类。
输入格式:
输入出生的年、月、日（注：输入的年月日以换行隔开）
输出格式:
计算得到年龄
输入样例:
在这里给出一组输入。例如：
1995
12
23
输出样例:
在这里给出相应的输出。例如：
age=22
实现代码：
import java.util.Scanner;
class Birthday{
private int year;
private int month;
private int day;
public Birthday(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public static void getAge(int year,int month,int day){
int age=0;
age = 2017-year;
if(month==12 && day>=25){
age–;
}
System.out.println("age="+age);
}
}
public class Main {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
int year=scan.nextInt();
int month=scan.nextInt();
int day=scan.nextInt();
Birthday.getAge(year,month,day);
}
}
