Java项目演示

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

题目

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(也就是在接口定义一个常量)。

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

interface Shape{}

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

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关键字实现接口中的所有方法。

class circular implements shape{}

在circular类中创建构造方法

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方法中对方法进行引用和打印值

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来对接口的方法进行实现，所以它不是一个抽象类，可以进行实例化操作。

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

下面是完整的代码

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());
	}
}

第二种解决方法

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

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;
	}
}

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

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

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

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

class circular2 extends circular{}

继承以后定义构造函数

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

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

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

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

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

public class Shape_impl {
	public static void main(String[] args) {
		circular2 cir2 =new circular2(3.5);
		cir2.printA();
    }
}

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

下面是完整的代码

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();
	}
}