java的抽象类和接口

前言

总结一下抽象类和接口的区别，算是复习一下基础知识吧

例子

接口

接口	接口实现类	接口测试类
Talk	TalkMan	TestAbstract

Talk：

/*
 * 1. 接口只能被public修饰，可是显示的使用private或者protected但是会报错
 * 2. 接口的成员必须被static final 修饰
 * 3. 接口方法默认而且必须被abstract修饰,而且接口中不能有非抽象方法
 * 3. 不能被直接实例化，必须被子类实现,而且子类必须实现接口的所有方法
 * */
package Abstract_Interface;

public interface Talk {
    public static final String PROPERTY="InterfaceMember";
    public abstract void methodOne();
    public abstract void methodTwo();
}

TalkMan：

package Abstract_Interface;

public class TalkMan implements Talk{

    public static final String TALKMA_STRING="TalkManClass";
    public void methodOne() {
        // TODO Auto-generated method stub
        System.out.println("子类实现接口方法one");
    }

    public void methodTwo() {
        // TODO Auto-generated method stub
        System.out.println("子类实现接口方法two");
    }
    public void Sing(){
        System.out.println("实现接口的子类自己的方法，接口中不存在该方法");
    }

}

TestAbstract:

package Abstract_Interface;

public class TestInterface {
    public static void main(String[] args) {
        /*不能实例化，非要实例化，必须是一个匿名内部类，
         * 而且必须重写接口的方法
         */
        Talk talk = new Talk() {

            public void methodTwo() {
                // TODO Auto-generated method stub
                System.out.println("匿名内部类的实现接口方法One");
            }

            public void methodOne() {
                // TODO Auto-generated method stub
                System.out.println("匿名内部类的实现接口方法Two");
            }
        };
        talk.methodOne();
        talk.methodTwo();
        /*
         * 测试接口的实现
         * */
        Talk talk2 = new TalkMan();
        talk2.methodOne();
        talk2.methodTwo();
        System.out.println(talk2.PROPERTY);

    }
}
//匿名内部类的实现接口方法Two
//匿名内部类的实现接口方法One
//子类实现接口方法one
//子类实现接口方法two
//InterfaceMember

//-----测试输出-----
//抽象匿名类-cry
//猫仔哭...
//猫仔跳...
//猫仔哭...
//猫仔跳...
//这是抽象类的非抽象方法
//10

抽象类

抽象类	抽象类实现	抽象类测试类
Animal	Cat	TestInterface

Animal:

/*
 * 1. 抽象类只能被public修饰，可以有static和final成员
 * 2. 抽象类可以有非抽象方法，但是只要有抽象方法，该类必须是抽象类
 * 3. 抽象类的抽象方法方法只能被public或者protected修饰
 * 4. 抽象类不能被实例化，必须交给子类来完成，但可以实现抽象类的匿名类
 * 5. 继承抽象类的子类必须重写父类(抽象类)所有抽象方法
 * */
package Abstract_Interface;

public abstract class Animal {
    //可以有自己的成员
    public final static int Aa=10;
    //抽象方法
    public abstract void cry();
    protected abstract void jump();
    //非抽象方法
    public void methodOne(){
        System.out.println("这是抽象类的非抽象方法");
    }
}

Cat:

package Abstract_Interface;

public class Cat extends Animal{

    public static int age=3;
    @Override
    public void cry() {
        // TODO Auto-generated method stub
        System.out.println("猫仔哭...");
    }

    @Override
    protected void jump() {
        // TODO Auto-generated method stub
        System.out.println("猫仔跳...");
    }
    public void catEat(){
        System.out.println("猫在吃东西，子类自己的方法");
    }
}

TestInterface:

/*
 * 测试抽象类和其子类
 * */
package Abstract_Interface;

public class TestAbstract {

    public static void main(String[] args) {
        /* 抽象类不能被实例化，new出来的只能是匿名内部类的形式，而且必须
         * 重写所有的抽象方法
         */
        Animal a =new Animal() {

            @Override
            protected void jump() {
                System.out.println("抽象匿名类-jump");

            }

            @Override
            public void cry() {
                // TODO Auto-generated method stub
                System.out.println("抽象匿名类-cry");
            }
        };
        a.cry();//正确调用
        /*
         * 测试子类
         * */
        Cat cat = new Cat();
        cat.cry();
        cat.jump();//正确调用
        cat.catEat();
        /*
         * 测试抽象类的方法调用和成员访问
         * */
        Animal animal = new Cat();
        animal.cry();
        animal.jump();
        animal.methodOne();//用父类抽象类的非抽象方法
        System.out.println(animal.Aa);//父类抽象类的成员变量

        //输出
        //匿名内部类的实现接口方法Two
        //匿名内部类的实现接口方法One
        //子类实现接口方法one
        //子类实现接口方法two
        //InterfaceMember
    }
}

总结

比较	抽象类	接口
修饰符	只能被public修饰	只能被public修饰
成员	可以有static和final成员	必须被static final修饰
方法	抽象类可以有非抽象方法，但是只要有抽象方法，该类必须是抽象类； 抽象类的抽象方法方法只能被public或者protected修饰	接口方法默认而且必须被abstract修饰,而且接口中不能有非抽象方法
能否实例化	抽象类不能被直接实例化，必须交给子类来完成，但可以实现抽象类的匿名类	接口不能被直接实例化，必须被子类实现，但可以实现抽象类的匿名类
子类特点	继承抽象类的子类必须重写父类(抽象类)所有抽象方法,子类可以调用父类的成员变量和费抽象类方法	子类必须实现接口的所有方法