java中抽象类和接口的相同和不同点介绍

package example;
 
import java.util.Date;
 
public abstract class GeometricObject {
	private String color="white";
	private boolean filled;
	private java.util.Date dateCreated;
	protected GeometricObject() {
		dateCreated=new java.util.Date();
	}//构建默认的几何对象
	protected GeometricObject(String color,boolean filled) {
		dateCreated=new java.util.Date();
		this.color=color;
		this.filled=filled;
	}
	public String getColor() {
		return color;
	}//返回颜色
	public void setColor(String color) {
		this.color=color;
	}//设置新的颜色
	public boolean getFilled() {
		return filled;
	}
	public void setFilled(boolean filled) {
		this.filled=filled;
	}
	public java.util.Date getDateCreated(){
		return dateCreated;
	}
	public abstract double getArea();//抽象方法定义得到面积
	public abstract double getPerimeter();//抽象方法得到周长
}

package example;
 
public class TestEdible {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Object[] objects= {new Tiger(),new Chicken(),new Apple()};
		//创建由Tiger，Chicken和Apple类型的三个对象构成的数组
		for(int i=0;i<objects.length;i++) {
			if(objects[i] instanceof Edible)
				System.out.println(((Edible)objects[i]).howToEat());
			if(objects[i] instanceof Animal) {
				System.out.println(((Animal)objects[i]).sound());
		}
		}//如果可食用，则调用howToEat方法，如果是动物，则调用sound方法
	}
 
}
abstract class Animal{
	private double weight;
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight=weight;
	}
	public abstract String sound();//返回动物的声音，是抽象方法，被具体的animal类实现
}
class Chicken extends Animal implements Edible{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
	}//实现了Edible接口。当一个类实现接口时，该类实现定义在接口中的所有方法。
	@Override
	public String sound() {
		return "Chicken: cock-a-doodle-doo";
	}
}
class Tiger extends Animal{
	@Override
	public String sound() {
		return "Tiger:RROOAARR";
	}
}
abstract class Fruit implements Edible{
}//Fruit类实现了Edible，但没有实现howToEat方法，所以它必须定义为abstract。
class Apple extends Fruit{
		@Override
		public String howToEat() {
			return "Apple:Make apple cider";
	}
}//Fruit的具体子类必须实现howToEat方法，所以Apple类实现了howToEat方法。

public interface T {
	public static final int K=1;
	public abstract void p();
}

public interface T {
	int K=1;
	void p();
}

public class NewClass extends BaseClass implements Interface1,...,InterfaceN{
}

public interface NewInterface extends Interface1,...,InterfaceN{
}

abstract class Animal{
    public  abstract String howToEat();
}//在Animal中定义howToEat方法
//Animal的两个子类定义如下
class Chicken extends Animal{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
    }
}
class Duck extends Animal{
	@Override
	public String howToEat() {
		return "Roast it";
    }
}
public static void main(String[] args) {
    Animal animal = new Chicken();
    eat(animal);
 
    Animal animal = new Duck();
    eat(animal);
}
public static void eat(Animal animal){
    System.out.println(animal.howToEat());
}

public class Demo{
public static void main(String[] args) {
    Edible stuff = new Chicken();
    eat(stuff);
 
    Edible stuff = new Broccoli();
    eat(stuff);
  }
public static void eat(Edible stuff){
    System.out.println(stuff.howToEat());
  }
}
interface Edible{
    public String howToEat();
}
class Chicken implements Edible{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
	}
}
class Broccoli implements Edible{
	@Override
	public String howToEat() {
		return "Broccoli: Stir-fty it";
	}
}