java中的问题解决
为实现对多种社团成员的统一管理，特设计相应的类及接口，如UML图所示，现需要实现相应的类和接口的定义。
首先，设计名为OrganizationMember的类，表示所有类型社团成员共同的父类，其拥有：
(1) 名为name的类型为String的私有域，代表社团成员姓名。
(2) 名为organization类型为String的私有域，代表社团名称。
(3) 带参的构造方法，参数有两个，第一个参数名为name类型为String，第二个参数名为organization类型为String，用于分别为类的两个属性赋值。
(4) 重写的公有方法toString()，返回值为String。返回字符串结构为："姓名" + name + "\n" + "组织" + organization
设计名为Work的接口，拥有：
(1)名为Work()的无参抽象方法，返回值为String。表示正在从事什么活动。
设计名为BasketballMember的类，继承OrganizationMember类，实现Work接口中的方法，表示篮球社成员，拥有：
(1)名为grade的类型为int的私有域，表示成员的水平，取值只能在类常量FRESHMAN, JUNIOR, SENIOR其中三选一。
(2)类常量FRESHMAN, JUNIOR, SENIOR为int类型的，取值分别为1, 2, 3。
(3)带参构造方法，包含3个参数，分别名为name（String类型）、organization（String类型）、grade（int类型），分别为父类的2个私有属性、本类的1个私有属性赋值。如grade超出类常量固定范围，则强制置为0。
(4)重写toString函数，返回值为String。返回字符串格式为："水平" + grade。
(5)实现接口Work中的方法work，返回字符串“参与篮球比赛”。
设计名为RobotMember的类，继承OrganizationMember类，实现Work接口中的方法，表示机器人社团成员，拥有：
(1)名为level的类型为int的私有域，表示成员的水平，取值只能在类常量LOW, HIGH其中二选一。
(2)类常量LOW, HIGH为int类型的，取值分别为1, 2。
(3)带参构造方法，包含3个参数，分别名为name（String类型）、organization（String类型）、level（int类型），分别为父类的2个私有属性、本类的1个私有属性赋值。如level超出类常量固定范围，则强制置为0。
(4)重写toString函数，返回值为String。返回字符串格式为："等级" + grade。
(5)实现接口Work中的方法work，返回字符串“参与机器人比赛”。
试题输入输出】
需要编写测试类TestOrganizationMember，从标准输入中分别输入篮球社某成员信息以及机器人社团某成员信息，并分别打印输出。
特别注意：篮球社成员的grade数值需要在FRESHMEN, JUNIOR, SENIOR这几个范围内选择；机器人社团成员的level数值则只能在LOW, HIGH这两个取值范围内选择。若输入值超出范围，则强制将grade或者level置为0。
测试程序（关键代码）如下：
Scanner input = new Scanner(System.in);
String name1=input.next();
String organization1=input.next();
int grade=input.nextInt();
String name2=input.next();
String organization2=input.next();
int level=input.nextInt();
BasketballMember basketballMember1 = new BasketballMember(name1,organization1,grade);
System.out.println(basketballMember1 + basketballMember1.work());
RobotMember robotMember1 = new RobotMember(name2,organization2,level);
System.out.println(robotMember1 + robotMember1.work());
输入输出效果如下：
import java.util.Scanner;
public class TestOrganizationMember {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name1=input.next();
String organization1=input.next();
int grade=input.nextInt();
String name2=input.next();
String organization2=input.next();
int level=input.nextInt();
BasketballMember basketballMember1 = new BasketballMember(name1,organization1,grade);
System.out.println(basketballMember1 + basketballMember1.work());
RobotMember robotMember1 = new RobotMember(name2,organization2,level);
System.out.println(robotMember1 + robotMember1.work());
}
}
class OrganizationMember{
private String name;
private String organization;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public OrganizationMember(String name, String organization) {
this.name = name;
this.organization = organization;
}
public String toString(){
return "姓名" + name + "\n" + "组织" + organization;
}
}
interface Work{
String work();
}
class BasketballMember extends OrganizationMember implements Work {
private int grade;
final int FRESHMAN = 1;
final int JUNIOR = 2;
final int SENIOR = 3;
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public BasketballMember(String name, String organization, int grade) {
super(name, organization);
if (grade != 1 && grade != 2 && grade != 3) {
this.grade = 0;
} else
this.grade = grade;
}
public String toString(){
return super.toString()+"水平" + grade+"\n";
}
public String work(){
return "参与篮球比赛"+"\n";
}
}
class RobotMember extends OrganizationMember implements Work{
private int level;
final int LOW=1;
final int High=2;
public int getLevel() {
return level;
}
public RobotMember(String name, String organization, int level) {
super(name, organization);
if(level!=1&&level!=2)
this.level=0;
else
this.level = level;
}
public void setLevel(int level) {
this.level = level;
}
public String toString(){
return super.toString()+"等级" + level+"\n";
}
public String work(){
return "参与机器人比赛"+"\n";
}
}
public class Test {
public static void main(String[] args) {
}
}
class P{
public boolean isp(int number){
int t=number;
int m1=number%10;
t-=m1;
t=t/10;
int m2=t%10;
t-=m2;
int m3=t%10;
t-=m3;
int m4=t%10;
t-=m4;
int m5=t%10;
if(number==m1*10000+m2*1000+m3*100+m4*10+m5)
return true;
else
return false;
}
}
设计一个名为Circle的类表示圆形，这个类包括：
(1)一个名为int类型的静态变量numberOfCircle，记录创建的圆形的个数；
(2)一个名为radius的double型私有数据域，表示圆形的半径。默认值为1。
(3)创建默认圆形的无参构造方法。
(4)一个创建radius为指定值的圆形的有参构造方法，特别的，当参数小于0时，该方法抛出一个异常（Exception），但并不在内部处理。
(5)为数据域radius设置访问器和修改器（即set和get函数）。特别的，对于修改器，当参数小于0时，该方法抛出一个异常（Exception），但并不在内部处理。
(6)一个名为getArea()的方法返回圆形的面积。
(7)一个名为getPerimeter()的方法返回圆形的周长。
(8)一个名为getNumberOfCircle()的静态方法，获取已经创建的圆形对象的个数。
注意：在本题相关计算中，假设“圆周率”为3.14；计算面积公式为“圆周率半径半径”；计算周长公式为“2圆周率半径”
【试题输入输出】
编写一个名为TestCircle的测试类，实现测试程序，首先输入两个圆形半径数值。接着，使用Circle的无参构造方法，创建一个Circle对象，再利用修改器修改其属性，再依次输出其半径、面积、周长、当前圆形对象个数。然后，使用有参构造方法，实例化一个对象，再依次输出其半径、面积、周长、当前圆形对象个数。在测试程序中处理类的构造方法或修改器修改属性过程中可能产生的异常，并按照下面的样例输出结果：
import java.util.Scanner;
public class TestPalindrome {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int m=scanner.nextInt();
System.out.println(m);
}
}
class Palindrome{
private int numer;
public int getNumer() {
return numer;
}
public void setNumer(int numer) {
this.numer = numer;
}
public boolean isPalindrome(int number){
int t=number;
int m1=number%10;
t-=m1;
t=t/10;
int m2=t%10;
t-=m2;
int m3=t%10;
t-=m3;
int m4=t%10;
t-=m4;
int m5=t%10;
if(number==m1*10000+m2*1000+m3*100+m4*10+m5)
return true;
else
return false;
}
}
import java.util.Scanner;
public class TestCircle {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
Circle c1=new Circle();
try {
c1.setRadius(input.nextDouble());
System.out.println(c1);
} catch (Exception e) {
e.printStackTrace();
}
try {
Circle c2=new Circle(input.nextDouble());
System.out.println(c2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Circle extends Exception{
static int numberOfCircle;
private double radius=1;
public Circle(double radius) throws Exception {
if (radius < 0)
throw new Exception("illegal radius");
else {
this.radius = radius;
numberOfCircle++;
}
}
public Circle() {
numberOfCircle++;
}
public static int getNumberOfCircle() {
return numberOfCircle;
}
public static void setNumberOfCircle(int numberOfCircle) {
Circle.numberOfCircle = numberOfCircle;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) throws Exception {
if(radius<0)
throw new Exception("illegal radius");
else
this.radius = radius;
}
public double getArea(){
return 3.14*radius*radius;
}
public double getPerimeter(){
return 2*3.14*radius;
}
public static int getNumberOfCirclr(){
return numberOfCircle;
}
public String toString(){
return "半径为"+radius+"\n面积为"+getArea()+"\n周长为"+getPerimeter()+"\n圆形对象个数为"+getNumberOfCircle();
}
}
本题主要编写一个用于判断回文数的类，同时编写一个测试类对其进行测试，具体要求如下。
设计并实现一个名为Palindrome的类，需要包括：
(1) 一个名为isPalindrome的实例方法，参数为一个int型的变量number，返回值为boolean类型，该方法可判断数字number是否为“回文”数。如果是回文数，则返回true，其它情况则返回false，方法头参考如下格式：
public boolean isPalindrome(int number)
(2) 为简化问题，假设输入的回文数固定为5位数整数（即数值上大于9999、小于100000），如23432或者11111。
编写一个测试类TestPalindrome，用于测试Palindrome类的isPalindrome方法，具体要求如下：
（1）由用户输入一个五位的整数，然后确定它是否回文数字。
import java.util.Scanner;
public class TestPalindrome {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
Palindrome x=new Palindrome();
x.setNumer(scanner.nextInt());
if(x.isPalindrome(x.getNumer()))
System.out.println(x.getNumer()+"是一个回文数");
else
System.out.println(x.getNumer()+"不是一个回文数");
}
}
class Palindrome {
private int numer;
public int getNumer() {
return numer;
}
public void setNumer(int numer) {
this.numer = numer;
}
public boolean isPalindrome(int number) {
int t = number;
int m1 = number % 10;
t -= m1;
t = t / 10;
int m2 = t % 10;
t -= m2;
int m3 = t % 10;
t -= m3;
int m4 = t % 10;
t -= m4;
int m5 = t % 10;
if (number == m1 * 10000 + m2 * 1000 + m3 * 100 + m4 * 10 + m5)
return true;
else
return false;
}
}
import java.util.Scanner;
public class TestPalindrome {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
Palindrome x=new Palindrome();
x.setNumer(scanner.nextInt());
if(x.isPalindrome(x.getNumer()))
System.out.println(x.getNumer()+"是一个回文数");
else
System.out.println(x.getNumer()+"不是一个回文数");
}
}
class Palindrome {
private int numer;
public int getNumer() {
return numer;
}
public void setNumer(int numer) {
this.numer = numer;
}
public boolean isPalindrome(int number) {
int t = number;
int m1 = number % 10;
t -= m1;
t = t / 10;
int m2 = t % 10;
t -= m2;
t = t / 10;
int m3 = t % 10;
t -= m3;
t = t / 10;
int m4 = t % 10;
t -= m4;
t = t / 10;
int m5 = t % 10;
if (number == m1 * 10000 + m2 * 1000 + m3 * 100 + m4 * 10 + m5)
return true;
else
return false;
}
}
回文数的话有简单的办法
public class Palindrome{
public boolean isPalindrome(int number){
if(number < 10000 || number > 99999){
return false;
}
//将字符串反转跟原字符串比较，如果一样的话就是回文数
String numStr = "" + number;
return new StringBuilder(numStr).reverse().toString().equals(numStr);
}
}