在这里就不介绍两者定义是怎么回事了，直接上代码
抽象类：
                class A
                {
                        void show()
                        {
                                sop("show A");
                        }
                }

                class B
                {
                        void show()
                        {
                                sop("show B");
                        }
                }

                方法体不一样，方法声明一样，这样的话，把方法声明进行抽取，定义到一个类中，
                将来，让子类自己去实现方法体的内容。那么，这个没有方法体的方法就是抽象方法。
                类中有抽象方法，那么类就是抽象类。
abstract class C
                {
                        void method(){};
                        abstract void show();
                }

                class A extends C
                {
                        void show()
                        {
                                sop("show A");
                        }
                }

                class B extends C
                {
                        void show()
                        {
                                sop("show B");
                        }
                }

                class D extends C
                {
                        //void show(){sop("show d")}
                }

                强制要求子类必须实现某些功能。
                抽象类中可以有非抽象方法。

                接口：
                abstract class C
                {
                        abstract void show();
                }
                当一个抽象类中的方法都是抽象的时候，java提供了另外一种表现形式，接口。
               
                interface C
                {
                        public abstract void show();
                }

                class A implements C
                {
                        public void show()
                        {
                                sop("show A");
                        }
                }

                class B implements C
                {
                        public void show()
                        {
                                sop("show B");
                        }
                }

抽象类和接口的区别：
                        A:抽象类：
                                成员变量：既可以是变量，也可以是常量。
                                成员方法：既可以是抽象的，也可以是非抽象的。
                                构造方法：给子类实例化使用。
                          接口：
                                成员变量：只能是常量。默认修饰符 public static final
                                成员方法：只能是抽象的。默认修饰符 public abstract
                                针对接口，建议，所有的默认修饰符自己手动给出。
                        B:类和类的关系：
                                单继承，可以多层继承。
                          类和接口的关系：
                                实现关系，可以单实现，也可以多实现。
                                并且还可以在继承一个类的同时，实现多个接口。
                          接口和接口的关系：
                                继承关系，可以单继承，也可以多继承。
                        C:接口的出现避免了单继承的局限性。
                        D:继承体系中最上层的抽象类是整个体系的共性内容。
                          继承体系中最上层的接口是体系的扩展功能。
                        E:类被继承体现的是"is a"的关系。
                          接口被实现体现的是"like a"的关系。

在这里就不介绍两者定义是怎么回事了，直接上代码
抽象类：
                class A
                {
                        void show()
                        {
                                sop("show A");
                        }
                }

                class B
                {
                        void show()
                        {
                                sop("show B");
                        }
                }

                方法体不一样，方法声明一样，这样的话，把方法声明进行抽取，定义到一个类中，
                将来，让子类自己去实现方法体的内容。那么，这个没有方法体的方法就是抽象方法。
                类中有抽象方法，那么类就是抽象类。
abstract class C
                {
                        void method(){};
                        abstract void show();
                }

                class A extends C
                {
                        void show()
                        {
                                sop("show A");
                        }
                }

                class B extends C
                {
                        void show()
                        {
                                sop("show B");
                        }
                }

                class D extends C
                {
                        //void show(){sop("show d")}
                }

                强制要求子类必须实现某些功能。
                抽象类中可以有非抽象方法。

                接口：
                abstract class C
                {
                        abstract void show();
                }
                当一个抽象类中的方法都是抽象的时候，java提供了另外一种表现形式，接口。
               
                interface C
                {
                        public abstract void show();
                }

                class A implements C
                {
                        public void show()
                        {
                                sop("show A");
                        }
                }

                class B implements C
                {
                        public void show()
                        {
                                sop("show B");
                        }
                }

抽象类和接口的区别：
                        A:抽象类：
                                成员变量：既可以是变量，也可以是常量。
                                成员方法：既可以是抽象的，也可以是非抽象的。
                                构造方法：给子类实例化使用。
                          接口：
                                成员变量：只能是常量。默认修饰符 public static final
                                成员方法：只能是抽象的。默认修饰符 public abstract
                                针对接口，建议，所有的默认修饰符自己手动给出。
                        B:类和类的关系：
                                单继承，可以多层继承。
                          类和接口的关系：
                                实现关系，可以单实现，也可以多实现。
                                并且还可以在继承一个类的同时，实现多个接口。
                          接口和接口的关系：
                                继承关系，可以单继承，也可以多继承。
                        C:接口的出现避免了单继承的局限性。
                        D:继承体系中最上层的抽象类是整个体系的共性内容。
                          继承体系中最上层的接口是体系的扩展功能。
                        E:类被继承体现的是"is a"的关系。
                          接口被实现体现的是"like a"的关系。