java接口类和抽象题目实战

  1. 1. 题目
  2. 2. 第一种解决方法
    1. 2.1. 创建整体求形状方法的接口
    2. 2.2. 在接口中定义方法和常量PI
    3. 2.3. 通过类对接口中的所有方法进行实现
    4. 2.4. 最后在main方法中对方法进行引用和打印值
    5. 2.5. 下面是完整的代码
  3. 3. 第二种解决方法
    1. 3.1. 抽象类就不能去实例化对象
    2. 3.2. 继承以后定义构造函数
    3. 3.3. 定义完以后对类的功能进行拓展
    4. 3.4. 下面是完整的代码

此文章只是我本人自己的学习经验,所以有错误的可以指出来。仅供参考和学习交流。

题目

1、定义形状接口,包含两个求形状的面积的方法getArea和求周长的方法getGirth,和一个常量PI=3.14159.

任务:

定义圆形类,实现形状接口。通过构造方法赋值,求半径为3.5的圆的面积和周长。

定义长方形类,实现形状接口。通过构造方法赋值,求长为5,高为6的矩形的面积和周长。

定义梯形类,实现形状接口。通过构造方法赋值,求上底为3.2,下底为4.8,高为2.2的梯形的面积。

首先我们来看这个题目,非常形象的把接口,抽象,继承等几个概念给具体化出来。

在java中我们要用到面向对象的思想,所以,通过这几个对象来了解并做出相对框架是不难的,只要熟练掌握题目中所需要用到的关键字和函数的应用,就基本上一目了然,十分简单。

这个题我准备用两种方法去解决它。

第一种解决方法

首先,需要包含求形状的面积方法,求形状的面积的方法getArea和求周长的方法getGirth,和一个常量PI=3.14159。

通过上面的条件我们来创建一个接口,接口里面在创建2个方法getArea、getGirth和一个共有的静态常量PI(也就是在接口定义一个常量)。

创建整体求形状方法的接口

1
interface Shape{}

在接口中定义方法和常量PI

1
2
3
public abstract double getArea();
public abstract double getGirth();
public static final double PI = 3.14159;

其中abstract public和public abstract通过这两个去定义方法都是不会报错的,我通过网上的资料得出,顺序不会影响方法的变换,详细和错误可以在下面评论区指出我一下。

定义常量中public final static 和 public static final 都表示共有的静态常量,但是一般推荐使用public static final来对常量进行表示,所以这个两个也是一样都可以运行不会报错,并且就算不加public static final直接使用属性去对对象进行赋值也是可以的。

public static final其中public表示的是公用的权限,static表示静态,而final表示该常量只能被赋值一次,不能改变。

通过类对接口中的所有方法进行实现

题目需要圆形、矩形和梯形并且需要构造方法进行赋值,所以创建图形的类去对接口进行实现,在类中定义构造方法然后进行赋值。

由于接口中的方法都是抽象方法,因此不能通过实例化对象的方式来调用接口中的方法,所以需要定义一个类然后由implements关键字实现接口中的所有方法。

1
class circular implements shape{}

在circular类中创建构造方法

1
2
3
4
5
6
7
8
9
10
11
12
double r ;	//给r对象创建属性
public circular(double r){ //创建构造方法
this.r=r; //给r进行赋值操作
}
public double getArea(){
double Area = PI*(r*r); //在 getArea方法中创建圆形面积公式
return Area; //返回Area的值
}
public double getGirth(){
double Girth= 2*PI*r; //在getGirth方法中创建圆形周长的公式
return Girth; //返回Girth的值
}

最后在main方法中对方法进行引用和打印值

1
2
3
4
5
6
7
public class Shape_impl {
public static void main(String[] args) {
circular getcircular = new circular(3.5); //对circular类进行实例化
System.out.println("圆形的面积为:"+getcircular.getArea());
System.out.println("圆形的周长为:"+getcircular.getGirth());
}
}

有的人可能会说它不是抽象类的吗,所以不是不能被实例化吗?

首先circular类它只是通过implements来对接口的方法进行实现,所以它不是一个抽象类,可以进行实例化操作。

最后矩形和梯形的基本和上面中圆形使用的方法一样,所以就不做具体的说明了。

下面是完整的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package shape_packet;


interface Shape{
abstract public double getArea();
abstract public double getGirth();
public static final double PI=3.14159;
}
class circular implements Shape {
double r;
public circular(double r) {
this.r = r;
}
public double getArea() {
double Area = PI*(r*r);
return Area;
}
public double getGirth() {
double Gieth = 2*PI*r;
return Gieth;
}
}
class rectangle implements Shape{
int logn,hight;
public rectangle(int logn,int hight) {
this.logn= logn;
this.hight= hight;
}
public double getArea() {
int Area = logn*hight;
return Area;
}
public double getGirth() {
int Girth = (logn*2)+(hight*2);
return Girth;
}
}
class trapezoid implements Shape{
double upper,land,height;
public trapezoid (double upper,double land,double height) {
this.upper=upper;
this.land=land;
this.height=height;
}
public double getArea() {
double Area = (upper+land)*height/2;
return Area;
}
public double getGirth() {
return 0;
}
}
public class Shape_impl {
public static void main(String[] args) {
circular getcircular = new circular(3.5);
rectangle getrectangle = new rectangle(5,6);
trapezoid gettrapezoid = new trapezoid(3.2,4.8,2.2);
System.out.println("圆形的面积为:"+getcircular.getArea());
System.out.println("圆形的周长为:"+getcircular.getGirth());
System.out.println("矩形的面积为:"+getrectangle.getArea());
System.out.println("矩形的周长为:"+getrectangle.getGirth());
System.out.println("梯形的面积为:"+gettrapezoid.getArea());
}
}

第二种解决方法

开始时是和第一种方法类似,只是把形状的类改为了抽象类的方法去进行解决。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
abstract class circular implements Shape {
double r;
public circular(double r) {
this.r = r;
}
public double getArea() {
double Area = PI*(r*r);
return Area;
}
public double getGirth() {
double Gieth = 2*PI*r;
return Gieth;
}
}

首先这一步是通过抽象化这个类去实现的,和上面的方法不一样,上面没有进行抽象化类的概念。

抽象类就不能去实例化对象

1
circular getcircular = new circular(3.5);//第二方法不能用这种方法去调用类中的构造方法

抽象化以后,如果不能实例化去调用那么如何解决这个问题?那就是去继承抽象类在对继承的类进行功能的拓展。

1
class circular2 extends circular{}

继承以后定义构造函数

1
2
3
public circular2(double r) {
super(r); //访问抽象类的构造方法
}

定义完以后对类的功能进行拓展

1
2
3
4
void printA() {
System.out.println("圆的周长:"+super.getGirth()+"圆的面积:"+super.getArea()+"圆的半径:"
+ super.r);
}

通过void(空值)定义的函数名printA去对面积等数值进行打印

之后通过main方法去对circular2类进行实例化操作,然后引用printA对circular2类中的方法进行实现,并且打印数值。

1
2
3
4
5
6
public class Shape_impl {
public static void main(String[] args) {
circular2 cir2 =new circular2(3.5);
cir2.printA();
}
}

后面基本都是一样的操作。

下面是完整的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package shape_packet1;

interface Shape{
abstract public double getArea();
abstract public double getGirth();
public static final double PI=3.14159;
}

abstract class circular implements Shape {
double r;
public circular(double r) {
this.r = r;
}
public double getArea() {
double Area = PI*(r*r);
return Area;
}
public double getGirth() {
double Gieth = 2*PI*r;
return Gieth;
}
}
class circular2 extends circular{

public circular2(double r) {
super(r);
}

void printA() {
System.out.println("圆的周长:"+super.getGirth()+"圆的面积:"+super.getArea()+"圆的半径:"
+ super.r);
}


}
abstract class rectangle implements Shape{
int logn,hight;
public rectangle(int logn,int hight) {
this.logn= logn;
this.hight= hight;
}
public double getArea() {
int Area = logn*hight;
return Area;
}
public double getGirth() {
int Girth = (logn*2)+(hight*2);
return Girth;
}
}
class rectangle2 extends rectangle{

public rectangle2(int logn, int hight) {
super(logn, hight);
}
void printB() {
System.out.println("矩形的面积:"+super.getArea()+"矩形的周长:"+super.getGirth());
}
}
abstract class trapezoid implements Shape{
double upper,land,height;
public trapezoid (double upper,double land,double height) {
this.upper=upper;
this.land=land;
this.height=height;
}
public double getArea() {
double Area = (upper+land)*height/2;
return Area;
}
public double getGirth() {
return 0;
}
}
class trapezoid2 extends trapezoid{

public trapezoid2(double upper, double land, double height) {
super(upper, land, height);
}
void printC(){
System.out.println("梯形的面积:"+super.getArea());
}
}
public class Shape_impl {
public static void main(String[] args) {
circular2 cir2 =new circular2(3.5);
cir2.printA();
rectangle2 rec2 = new rectangle2(5,6);
rec2.printB();
trapezoid2 tra2 = new trapezoid2(3.2,4.8,2.2);
tra2.printC();
}
}