在JAVA中，定义一个接口，接口中有四个抽象方法：求面积方法、求周长方法、显示面积方法及显示周长方法。

1、 定义一个shape接口，接口中有4个抽象方法：求面积area()、求周长perimeter()、显示面积showarea()及显~

class shape{
public:
shape(.....){...};
~shape(){};
virtual float area()=0;
virtual float perimeter()=0;
float showarea(){return area};
float showperim(){return perimeter};
private:
.......
};
省略号的部分自己填

//呵呵，我也是刚刚才学这个OOP程设计的
//规划的不当，就不要见怪咯，我只是按照我的思想分析
//首先用面向对象的语方分析问题，这里有三个对象
//客户端是一个对象
//计算面积和周长是一个对象
//长方形是一个对象
public class Client{
public static void main(String []args){
ICalculate cal=new Calculate();
MyRectangle rect=new MyRectangle(10,5);
System.out.println(rect+"周长为："+cal.calcuGirth(rect));
System.out.println(rect+"面积为："+cal.calcuArea(rect));
rect=new MyRectangle(30,50);
System.out.println(rect+"周长为："+cal.calcuGirth(rect));
System.out.println(rect+"面积为："+cal.calcuArea(rect));

}
}
interface ICalculate{
int calcuArea(MyRectangle rect);
int calcuGirth(MyRectangle rect);
}
class Calculate implements ICalculate{
//计算面积的方法
public int calcuArea(MyRectangle rect){
int result=rect.getWidth()*rect.getHeight();
return result;
}
//计算周长的方法
public int calcuGirth(MyRectangle rect){
int result=(rect.getWidth()+rect.getHeight())*2;
return result;
}
}
class MyRectangle{
private int width;
private int height;
public MyRectangle(int width ,int height){
this.width=width;
this.height=height;
}
public int getWidth(){
return width;
}
public void setWidth(int width){
this.width=width;
}
public void setHeight(int height){
this.height=height;
}
public int getHeight(){
return height;
}
public String toString(){
return super.toString()+"[width="+width+",height="+height+"]";
}
}

使用java多态RIIT运行时类型识别，对象的好处是使我们能替换对象，而接口的好处是让我们更好的替换对象，这个接口应该是 形状 Shape ，形状没有具体的概念应该为抽象类或者接口，而圆形，长方形为具体的形状

public class MainTest{

public static void main(String[] args) {

Shape circle=new Circle(20),rect=new Rectangle(100.0,50.0);
circle.showArea();
rect.showArea();

}

}

interface Shape{
public double getArea();//求面积
public double getGirth();//求周长
public void showArea();
public void showGirth();
}

class Circle implements Shape{

private double r;
public double getR() {
return r;
}

public void setR(double r) {
this.r = r;
}

public Circle(){}
public Circle(double r){
this.r=r;
}
//求面积
public double getArea() {
return Math.PI*this.r*this.r;

}

//求周长
public double getGirth() {
return 2*this.r*Math.PI;

}

public void showArea() {
System.out.println("圆面积："+this.getArea());
}

public void showGirth() {
System.out.println("圆周长："+this.getGirth());
}

}

//定义长方形
class Rectangle implements Shape{
private double w,h;//长方形的宽和高
public double getW() {
return w;
}

public void setW(double w) {
this.w = w;
}

public double getH() {
return h;
}

public void setH(double h) {
this.h = h;
}

//构造函数
public Rectangle(){
}
//构造函数
public Rectangle(double w,double h){
this.w=w;
this.h=h;
}
public double getArea() {
return this.w*this.h;
}

public double getGirth() {
return 2*(this.w+this.h);

}

public void showArea() {
System.out.println("长方形面积"+this.getArea());
}

public void showGirth() {
System.out.println("长方形周长"+this.getGirth());
}
}

/***用继承的方法****/
public class A{//已知一个类A，要想在其他地方访问A里的对象
protected String a = "A类中的a字串";
}
public class B extends A{
public void prt(){
System.out.println(a);//直接访问父类中的protected对象
}
}

/****用接口的方法****/
public interface C{
String c = "C接口类中的c字串";
}
public class D implements C{
public void prt(){
System.out.println(c);//通过实现C接口类，来直接访问C类中所有对象，C必须是接口
}
}

/****用get方法****/
public class E{
private String e = "E接口类中的e字串";
public String getE(){
return this.e;
}
}
public class F{
public void prt(){
E instance = new E();//创建一个E类对象
System.out.println(instance.getE());//通过实现C接口类，来直接访问C类中所有对象，C必须是接口
}
}

public interface Graphics {
public double circum();
public double area();
}

public class Circle implements Graphics {
public double r;
public double getR() {
return r;
}

public void setR(double r) {
this.r = r;
}

public double area() {
return Math.PI*this.r*this.r;
}

public double circum() {
return 2*this.r*Math.PI;
}

}
public class Rectangle implements Graphics {
public double a;
public double b;

public double getA() {
return a;
}

public void setA(double a) {
this.a = a;
}

public double getB() {
return b;
}

public void setB(double b) {
this.b = b;
}

public double area() {
return this.a*this.b;
}

public double circum() {
return 2*(this.a+this.b);
}

}
public class Test {
public static void main(String[] args) {
Circle c = new Circle();
c.r = 2.0;
System.out.println("圆周长："+c.circum()+" 圆面积："+c.area());
Rectangle re = new Rectangle();
re.a = 2;
re.b = 4;
System.out.println("矩形周长："+re.circum()+" 矩形面积："+re.area());
}
}

interface Shape {
public double getarea();

public double getPerimeter();

public void printArea();

public void printPerimeter();
}

class Rectangle implements Shape {

private double width;

private double height;

public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}

public double getarea() {
return width * height;
}

public double getPerimeter() {
return 2 * (width + height);
}

public void printArea() {
System.out.println("Area for rectangle with width = " + width + ", height = " + height + " is: "+ getarea());
}

public void printPerimeter() {
System.out.println("Perimeter for rectangle with width = " + width + ", height = " + height + " is: "+ getPerimeter());
}
}

class Circle implements Shape {
private double radius;

public Circle(double r) {
this.radius = r;
}

public double getarea() {
return Math.PI * radius * radius;
}

public double getPerimeter() {
return 2 * Math.PI * radius;
}

public void printArea() {
System.out.println("Area for circle with r = " + radius + " is: " + getarea());
}

public void printPerimeter() {
System.out.println("Perimeter for circle with r = " + radius + " is: " + getPerimeter());
}

}

public class aa1 {
public static void main(String args[]) {
Shape circle = new Circle(2);

circle.printArea();
circle.printPerimeter();

Shape rectangle = new Rectangle(3, 12);
rectangle.printArea();
rectangle.printPerimeter();

}
}

----------------
Area for circle with r = 2.0 is: 12.566370614359172
Perimeter for circle with r = 2.0 is: 12.566370614359172
Area for rectangle with width = 3.0, height = 12.0 is: 36.0
Perimeter for rectangle with width = 3.0, height = 12.0 is: 30.0

你是要代码？

---

和顺县18733196884： Java中 声明一个接口lion,接口中定义一个int型常量num(值为10)和一个 - ？
纪胖蛭龙： lion接口:12345 publicinterfacelion { publicintnum = 10;publicintget(); } 接口实现类loim:12345 publicclassloim implementslion { publicintget() { 专returnnum; } } 测试类:123456 publicclassTest { publicstaticvoidmain(String[] args) { loim loim = newloim(); System.out.println(loim.get()); } } 测试结果:10

和顺县18733196884： java怎样定义接口 - ？
纪胖蛭龙： 例如,定义一个用于计算的接口,在该接口中定义了一个常量PI和两个方法,具体代码如下:[java] view plaincopy public interface CalInterface {final float PI=3.14159f;//定义用于表示圆周率的常量PIfloat getArea(float r);//定义一个用于计算面...

和顺县18733196884： java中如何实现接口以及接口中需要注意的 - ？
纪胖蛭龙： 首先用interface声明一个接口,注意接口不是类,我们习惯上可以认为他是一个抽象的类,因为它不能实现方法体,只有方法的定义.然后我们可以写一个类去实现这个接口例如:public class Text implements IUSBable 这样就说明你的这个类中还实现你接口中说定义的方法,不然会报错的! 我的概念就是接口类似于生活中的水龙头,只要你这个人有实现这个接口(水龙头)的方法,那么你就可以用这个水龙头,这个比喻虽然不是那么这样从另一方面说明了接口拥有的可扩展性,假如以后程序升级我只要将接口中的方法增加或修改一下! 这种概念性的东西是要自己多体会的,最好联系生活中的实例来理解,这样会事半工倍!

和顺县18733196884： java中,定义了一个接口,接着创建一个类去实现接口. - ？
纪胖蛭龙： 不可以,必须实现所有方法,即使是一个什么都没做的{}也算实现.因为接口本来就是一个为了实现多态而存在的,可以说是所有实现这个接口的类的共同点.你在通过接口调用某个实现了该接口的类对象的时候根本就不知道调用了哪个类实现的对象,如果接口可以不必完全实现全部接口方法.那么有一个类没有实现该方法,但是通过调用接口而调用了这个类的对象,又调用了没有被实现的方法会怎么样?调用了一个不存在的方法?所以必须实现所有接口方法.

和顺县18733196884： 什么叫做接口定义!在java中 - ？
纪胖蛭龙： 一提到接口,我们会想到,对接. 我在学习中理解到的接口,就是定义了一个抽象类 在里面有很多的为实现的方法 比如 interface port(){void getName(){};void getAge(){}; } 然后有一个或者多个类去实现它,实现不同的功能

和顺县18733196884： JAVA中 接口是什么? 接口的回调是什么? - ？
纪胖蛭龙： Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能). 两种含义:一,Java接口,Java语言中存在的结...

和顺县18733196884： java 类中定义接口怎么实现 - ？
纪胖蛭龙：用implement关键字,例如: interface A{void aMethod(); } class B implement A{void aMethod(){//方法具体实现} }

和顺县18733196884： java 接口中定义另一个接口 - ？
纪胖蛭龙： 我之前看《设计模式》时看到有这样用的,在管理者模式以及后面的装饰模式中都这么用,主要是减少系统之间的耦合性,使得功能变化时不需要修改代码或者只修改少量代码就能解决问题

和顺县18733196884： 在JAVA 中接口的定义,使用接口的有点是什么? - ？
纪胖蛭龙： java其实是单继承,但现实情况之中存在着多继承这种现象(举个例子吧 大熊猫是一只动物 从动物继承 同时它也是一只值钱的东西,假如你有另外一个类叫值钱的东西,那么大熊猫也应该从它继承,可是你不能这么写呀 你说class DaXiongMao...

和顺县18733196884： JAVA中,接口是什么 - ？
纪胖蛭龙： 接口就是接口,接口只能用来实现,跟类不一样!它的写法是•Public interface接口名称{},另外接口和类的区别:1•接口不可以被实例化;2•实现类百必须实现接口的所有方法;•3实现类可以实现多度个接口回;4接口中的变量都是静态的常量;另外接口不能实现接口,但是接口可以继承接口;•接口中的成员都有固定修饰符:–常量:public static final –方法:public abstract方法名; 类使用接口方法: Public class T implements接口名{} 接口是一种约定,体现在类名和注释上; 接口是一种能力,答体现在接口中的方法,约束能力,约束方法的功能; 暂时想到的就这么多了.希望能帮到你!