前言：
记录本人在学习JAVA的一点心得体会，且用于复盘和学习。又是被Java折磨的一天QAQ。好了，不多说直接上题。
7-1 jmu-Java-03面向对象基础-05-覆盖
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。
提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:
1
3
zhang 10 true
zhang 10 true
zhang 10 false
输出样例:
default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]import java.util.Arrays;
import java.util.Scanner;
class PersonOverride{
private String name ;
private int age ;
private boolean gender ;
public PersonOverride(){
this("default",1,true);
}
public PersonOverride(String name,int age,boolean gender){
this.name =name;
this.age=age;
this.gender=gender;
}
public String toString(){
return name+"-"+age+"-"+gender;
}
//难点哦；
public boolean equals(PersonOverride x){
if(this.name.equals(x.name)&&this.age==x.age&&this.gender==x.gender){
return true;
}else return false;
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin=new Scanner( System.in );
int n1=cin.nextInt();
PersonOverride persons1[]=new PersonOverride[n1];
for(int i=0;i<n1;i++){
persons1[i] = new PersonOverride();
}
int n2=cin.nextInt();
PersonOverride temp[] = new PersonOverride[n2];
PersonOverride presons2[] = new PersonOverride[n2];
int k=0;
for(int i=0;i<n2;i++){
temp[i]=new PersonOverride(cin.next(),cin.nextInt(),cin.nextBoolean());
boolean flag=true;
for(int j=0;j<i;j++){
if(temp[i].equals(temp[j])){
flag=false;
break;
}
}
if(flag==true){
presons2[k]=temp[i];
k++;
}
}
for(int i=0;i<persons1.length;i++){
System.out.println(persons1[i].toString());
}
for(int i=0;i<k;i++){
System.out.println(presons2[i]);
}
System.out.println(k);
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
7-2 图形继承（分数 10）
作者 段喜龙 单位 南昌航空大学
编写程序，实现图形类的继承，并定义相应类对象并进行测试。
- 类Shape，无属性，有一个返回0.0的求图形面积的公有方法
public double getArea();//求图形面积 - 类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积
- 类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积
- 类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法
public double getVolume();//求球体积 - 类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法
public double getVolume();//求立方体体积 - 注意：
- 每个类均有构造方法，且构造方法内必须输出如下内容：
Constructing 类名 - 每个类属性均为私有，且必须有getter和setter方法（可用Eclipse自动生成）
- 输出的数值均保留两位小数
主方法内，主要实现四个功能（1-4）：
从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积；
从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积；
从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积；
从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；
假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format
输入格式:
共四种合法输入
- 1 圆半径
- 2 矩形宽、长
- 3 球半径
- 4 立方体宽、长、高
输出格式:
按照以上需求提示依次输出
输入样例1:
在这里给出一组输入。例如：
1 1.0
输出样例1:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Circle
Circle's area:3.14
输入样例2:
在这里给出一组输入。例如：
4 3.6 2.1 0.01211
输出样例2:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Rectangle
Constructing Box
Box's surface area:15.26
Box's volume:0.09
输入样例3:
在这里给出一组输入。例如：
2 -2.3 5.110
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
import java.util.*;
class Shape{
public Shape() {
System.out.println("Constructing Shape");
}
public double getArea() {
return 0.0;
}
}
class Circle extends Shape{
private double radius;
public Circle() {
System.out.println("Constructing Circle");
}
public double getArea() {
return Math.PI*radius*radius;
}
//就是简单获取到Shape里面的radius，因为题目要求是private类型，
//我看他给出的意见是protect ，原来写的，不过问题不大
//void setRadius 要传参，别忘了
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
class Rectangle extends Shape{
private double width;
private double length;
public Rectangle() {
System.out.println("Constructing Rectangle");
}
public double getArea() {
return width*length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width=width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length=length;
}
}
class Ball extends Circle{
public Ball() {
System.out.println("Constructing Ball");
}
public double getArea() {
return 4.0*super.getArea();
}
//在子类Ball中，我们重写了父类(circle)的getArea方法，
//如果在重写的getArea方法中我们去调用了父类(circle)的相同方法，
//必须要通过super关键字显示的指明出来。
//如果不指出super的话，出来的结果就是circle里面的getArea里面的结果
//看懂，掌声
public double getVolume() {
double l=getRadius();
//因为父类(circle)里面有，不需要重新定义，我们直接拿下好吧
return Math.PI*l*l*l*4/3.0;
}
}
class Box extends Rectangle{
private double height;
public Box() {
System.out.println("Constructing Box");
}
public double getArea(){
double length=getLength();
double width=getWidth();
return 2*(width*length+length*height+height*width);
}
public double getVolume() {
return super.getArea()*height;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height=height;
}
}
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
int k=cin.nextInt();
switch(k) {
case 1:
//创建一个圆的对象
double r0= cin.nextDouble();
// double r;
// r=cin.nextDouble();
if(r0<0) {
System.out.println("Wrong Format");
}
else {
Circle c1= new Circle();
c1.setRadius(r0);
System.out.printf("Circle's area:%.2f\n",c1.getArea());
}
break;
case 2:
//创建一个矩形对象
double w1= cin.nextDouble();
double l1= cin.nextDouble();
if(w1<=0||l1<=0) {
System.out.println("Wrong Format");
}
else {
Rectangle R1= new Rectangle();
R1.setWidth(w1);
R1.setLength(l1);
System.out.printf("Rectangle's area:%.2f\n",R1.getArea());
}
break;
case 3:
double r=cin.nextDouble();
if(r<=0) {
System.out.println("Wrong Format");
}
else {
Ball B1=new Ball();
B1.setRadius(r);
System.out.printf("Ball's surface area:%.2f\n",B1.getArea());
System.out.printf("Ball's volume:%.2f\n",B1.getVolume());
}
break;
case 4:
double w2= cin.nextDouble();
double l2= cin.nextDouble();
double h2= cin.nextDouble();
if(w2<=0||l2<=0||h2<=0) {
System.out.println("Wrong Format");
}
else {
Box BX1=new Box();
BX1.setHeight(h2);
BX1.setLength(l2);
BX1.setWidth(w2);
System.out.printf("Box's surface area:%.2f\n",BX1.getArea());
System.out.printf("Box's volume:%.2f\n",BX1.getVolume());
}
break;
default :
System.out.println("Wrong Format");
cin.close();//记得关，好习惯
}
}
}
7-3 Shape类-2
分数 10
定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数
定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
在main函数中，分别构造三个Shape类的变量，分别指向一个Square、Rectangle、Circle对象，并输出他们的周长、面积.
输入格式:
正方形类的边长
长方形类的长宽
圆类的半径
输出格式:
正方形的周长、面积
长方形的周长、面积
圆形的周长、面积
输入样例:
在这里给出一组输入。例如：
1
1 2
2
输出样例:
在这里给出相应的输出。例如：
4.00 1.00
6.00 2.00
12.57 12.57import java.util.*;
abstract class Shape {
public abstract double getPerimeter();
public abstract double getArea();
}
//这一步可能编译器会报错说你的class不能继承抽象类
//但是没关系，加一个重写的标志就可以了， @Override
//代码可以抄，但是一定要自己手打一遍
class Square extends Shape{
double len;
public Square() {
}
public Square(double len) {
this.len= len;
}
public double getPerimeter() {
return 4*this.len;
}
public double getArea() {
return this.len*this.len;
}
}
class Rectangle extends Square{
double broad;
public Rectangle(double len,double broad) {
super(len);
this.broad=broad;
}
public double getPerimeter() {
return 2*this.len+2*this.broad;
}
public double getArea() {
return this.len*this.broad;
}
}
class Circle extends Shape{
double r;
public Circle(double r) {
this.r=r;
}
public double getPerimeter() {
return 2*Math.PI*r;
}
public double getArea() {
return Math.PI*this.r*this.r;
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin=new Scanner(System.in);
double l1=cin.nextDouble();
double l2=cin.nextDouble();
double w2=cin.nextDouble();
double r3=cin.nextDouble();
//输出正方形的数据
Square s1=new Square(l1);
System.out.printf("%.2f ",s1.getPerimeter());
System.out.printf("%.2f\n",s1.getArea());
//输出长方形的数据；
Rectangle R1=new Rectangle(l2,w2);
System.out.printf("%.2f ",R1.getPerimeter());
System.out.printf("%.2f\n",R1.getArea());
//输出圆形的数据
Circle c1=new Circle(r3);
System.out.printf("%.2f ",c1.getPerimeter());
System.out.printf("%.2f\n",c1.getArea());
cin.close();
}
}
7-4 jmu-Java-03面向对象基础-04-形状-继承
前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
- 你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
- 是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape题解
import java.util.*;
abstract class Shape{
final static double PI =3.14;
public abstract double sumAllPerimeter();
public abstract double sumAllArea();
}
class Rectangle extends Shape{
int width;
int length;
public Rectangle() {
}
public Rectangle(int width,int length) {
this.width=width;
this.length=length;
}
public double sumAllArea() {
return width*length;
}
public double sumAllPerimeter() {
return 2*(width+length);
}
public String toString() {
return "Rectangle [" + "width=" + width + ", length=" + length + ']';
}
}
class Circle extends Shape{
int radius;
public Circle() {
}
public Circle(int radius) {
this.radius=radius;
}
public double sumAllArea(){
return PI*radius*radius;
}
public double sumAllPerimeter() {
return 2*PI*radius;
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Shape[] shape=new Shape[n];
for(int i=0;i<n;i++) {
String a=cin.next();
if(a.equals("rect")) {
int w=cin.nextInt();
int l=cin.nextInt();
shape[i]=new Rectangle(w,l);
}else if(a.equals("cir")) {
int r= cin.nextInt();
shape[i]=new Circle(r);
}
}
System.out.println(sumAllPerimeter(shape));
System.out.println(sumAllArea(shape));
String temp = "[";
for (int i = 0; i < n; i++) {
temp += shape[i];
temp += (i < n-1) ? ", " : "]";
}
System.out.println(temp);
for (Shape i : shape) {
System.out.println(i.getClass()+","+i.getClass().getSuperclass());
}
}
static double sumAllPerimeter(Shape[] shape) {
double sum = 0.0;
for (Shape i : shape) {
sum += i.sumAllPerimeter();
}
return sum;
}
static double sumAllArea(Shape[] shape) {
double sum = 0.0;
for (Shape i : shape) {
sum += i.sumAllArea();
}
return sum;
}
}另一种写法
import java.util.*;
abstract class Shape{
final static double PI=3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
class Rectangle extends Shape {
int width,length;
public Rectangle(int width ,int length) {
this.width = width;
this.length = length;
}
public double getArea() {
return width*length;
}
public double getPerimeter() {
return 2*(width+length);
}
public String toString() {
return "Rectangle [" + "width=" + width + ", length=" + length + ']';
}
}
class Circle extends Shape{
int radius;
public Circle(){
}
public Circle(int r) {
this.radius = r;
}
public double getArea() {
return PI*this.radius*this.radius;
}
public double getPerimeter() {
return 2*PI*this.radius;
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Shape[] a=new Shape[n];
for(int i=0;i<n;i++) {
String y=cin.next();
if(y.equals("rect")) {
int w=cin.nextInt();
int l=cin.nextInt();
a[i]=new Rectangle(w,l);
} else if(y.equals("cir")) {
int r = cin.nextInt();
a[i] = new Circle(r);
}
}
System.out.println(sumAllPerimeter(a));
System.out.println(sumAllArea(a));
System.out.println(Arrays.toString(a));
for(int i=0;i<a.length;i++) {
System.out.println(a[i].getClass()+","+a[i].getClass().getSuperclass());
}
cin.close();
}
private static double sumAllPerimeter(Shape a[]) {
double t=0;
for(int i=0;i<a.length;i++) {
if(a[i] instanceof Rectangle) {
t=t+((Rectangle)a[i]).getPerimeter();
} else if(a[i] instanceof Circle) {
t=t+((Circle)a[i]).getPerimeter();
}
}
return t;
}
private static double sumAllArea(Shape a[]) {
double t=0;
for(int i=0;i<a.length;i++) {
if(a[i] instanceof Rectangle) {
t=t+((Rectangle)a[i]).getArea();
} else if(a[i] instanceof Circle) {
t=t+((Circle)a[i]).getArea();
}
}
return t;
}
}7-5 设计一个Shape及其子类Ova
编写一个完整的Java Application 程序。包含类Shape、类Oval、类ShapeTest，具体要求如下：
(1)编写一个抽象类Shape表示形状对象，包含以下成员
①属性：
PI：double型常数，值为3.1415926；
②方法：
- double area(), 抽象方法；
- double perimeter()，抽象方法；
(2)编写一个Shape类的子类Oval，表示椭圆对象，包含以下成员
①属性： - a：私有，double型，长轴半径；
- b：私有，double型，短轴半径；
②方法： - Oval(double a，double b), 构造方法,用参数设置椭圆的长轴半径和短轴半径
- Oval(),构造方法，将椭圆的长轴半径和短轴半径都初始化为0。
- double area()，重写Shape类中的area方法，返回椭圆的面积( )
- double perimeter()，重写Shape类中的perimeter方法，返回椭圆的周长( )
- public String toString( )，将把当前椭圆对象的转换成字符串形式，例如长轴半径为10.0，短轴半径为5，返回字符串"Oval(a:10.0,b:5.0)"。
（3）编写公共类Main,实现如下功能 - 输入长轴半径和短轴半径，并创建一个椭圆对象；
- 分别用area和perimeter方法，求出以上椭圆的面积和宽度并输出，输出过程中要求使用到toString方法，输出格式如下：
输入格式:
输入长轴半径和短轴半径
输出格式:
输出椭圆的面积和周长。
输入样例:
8 6
输出样例:
在这里给出相应的输出。例如：
The area of Oval(a:8.0,b:6.0) is 150.79644480000002
The perimeterof Oval(a:8.0,b:6.0) is 44.42882862370954
import java.util.*;
abstract class Shape{
double PI =3.1415926;
abstract double area();
abstract double perimeter();
}
class Oval extends Shape{
private double a,b;
Oval(double a,double b){
this.a=a;
this.b=b;
}
Oval(){
a=b=0;
}
double area() {
return PI*a*b;
}
double perimeter() {
return 2*PI*Math.sqrt( ( a * a + b * b ) / 2 );
}
@Override
public String toString() {
return "Oval(a:" + a + ",b:" + b + ")";
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin=new Scanner(System.in);
double lr=cin.nextDouble();
double dr=cin.nextDouble();
Oval O1= new Oval(lr,dr);
System.out.println("The area of "+O1.toString()+" is "+O1.area());
System.out.println("The perimeterof "+O1.toString()+" is "+O1.perimeter());
cin.close();
}
}
7-6 接口--四则计算器
- 利用接口做参数，写个计算器，能完成加减乘除运算。
- 定义一个接口ICompute含有一个方法int computer(int n, int m)。
- 定义Add类实现接口ICompute，实现computer方法，求m，n之和
- 定义Sub类实现接口ICompute，实现computer方法，求n-m之差
- 定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。
输入格式:
输入在一行中给出2个整数
输出格式:
输出两个数的和、差
输入样例:
在这里给出一组输入。例如：
6 7
输出样例:
在这里给出相应的输出。例如：
13
-1import java.util.*;
interface Computer{
int computer(int n,int m);
}
//接口的意思，差不多类似于一个公用的方法，这个方法呢就是
//这个题里面Add和Sub都用到的Computer这个接口
//就避免了重复书写这个构造的方法。当然也可以多个接口合并并一个
//例如现在又一个ABCD接口，把它接到一个总的接口E，
//其他的就implents E就可以了
class Add implements Computer{
public int computer(int n,int m) {
return n+m;
}
}
class Sub implements Computer{
public int computer(int n,int m) {
return n-m;
}
}
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner cin=new Scanner (System.in);
int a =cin.nextInt();
int b =cin.nextInt();
Add A=new Add();
Sub S=new Sub();
int c=A.computer(a,b);
int d=S.computer(a,b);
System.out.println(c);
System.out.println(d);
cin.close();
}
}
7-7 USB接口的定义
定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：
1.接口名字为USB，里面包括两个抽象方法：
void work（）；描述可以工作
void stop(); 描述停止工作
2.完成类Mouse，实现接口USB，实现两个方法：
work方法输出“我点点点”；
stop方法输出 “我不能点了”；
3.完成类UPan，实现接口USB，实现两个方法：
work方法输出“我存存存”；
stop方法输出 “我走了”；
4测试类Main中，main方法中
定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法
定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。
输入格式:
输出格式:
输出方法调用的结果
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
我点点点
我不能点了
我存存存
我走了
我点点点
我不能点了import java.util.*;
interface USB{
void work();
void stop();
}
class Mouse implements USB{
public void work(){//要写public
System.out.println("我点点点");
}
public void stop(){
System.out.println("我不能点了");
}
}
class UPan implements USB{
public void work(){
System.out.println("我存存存");
}
public void stop(){
System.out.println("我走了");
}
}
public class Main {
public static void main(String[] args) {
Mouse usb1=new Mouse();
usb1.work();
usb1.stop();
USB usbs[]=new USB[2];
usbs[0]=new UPan();
usbs[0].work();
usbs[0].stop();
usbs[1]=new Mouse();
usbs[1].work();
usbs[1].stop();
}
}