抽象类和接口

抽象类

public class Abst
{
    public static void main(String[] args)
    {
        Animal cat=new Cat("xiaohong",111);
        Animal dog=new Dog("xiaoming",222);
        cat.go();
        dog.go();
    }
}
abstract class Animal
{
    String name;
    int height;
    public abstract void go();
}
class Dog extends Animal
{
    public Dog(){

    }
    public Dog(String name,int height)
    {
        this.name=name;
        this.height=height;
    }
    public  void go()
    {
        System.out.println(name+" can run and it's height is "+height);
    }
}
class Cat extends Animal
{
    public Cat() {

    }
    public Cat(String name,int height)
    {
        this.name=name;
        this.height=height;
    }
    public void go()
    {
        System.out.println(name+" can and it's height is "+height);
    }
}

抽象类是用abstract所修饰的类
   	抽象方法一定存在于抽象类中，抽象类中不一定有抽象方法
    抽象类可以被继承，抽象类的子类必须重写抽象类中的所有抽象方法，否则编译出错
    抽象方法没有方法体，抽象方法是有子类重写来实现的
	abstract不能与 final,static,private 这些关键字组合
    抽象类定义语法abstract class 类名{···}

接口(interface)

public class Abs
{
    public static void s(Canswim x) {
        x.swim();
    }
    public static void f(Canfly x){
        x.fly();
    }
    public static void fi(ActionCharacter x) {
        x.fight();
    }
    public static void main(String[] args) {
        Hero hero=new Hero();
        s(hero);
        f(hero);
        fi(hero);
    }
}
interface Canswim{
    void swim();
}
interface Canfly{
    void fly();
}
class ActionCharacter{
    public void fight()
    {
        System.out.println("can fight!");
    }
}
class Hero extends ActionCharacter implements Canswim,Canfly{
    public void swim()
    {
        System.out.println("can swim!");
    }
    public void fly()
    {
        System.out.println("can fly!");
    }
}

接口只能由public和默认修饰
接口中的方法不能带有主体，因为其中的方法是抽象的
语法
    interface 接口名(){}
引用方法 class 类名 implements 接口名{……}
接口中的方法必须在接口其的类中实现，否则编译不通过