文章标题

抽象与接口

抽象和接口的区别

通过例题演示

（一）抽象类

1.抽象方法：不能够提供完整是实现的方法，即没有方法体的方法就抽象方法
方法体：即一对花括号，有花括号，里面没有内容，也是方法的实现
抽象方法声明的格式：访问修饰符 abstract 返回值类型 方法名();
例如：public abstract void run();//没有方法体
2.抽象类：只要带有abstract关键字声明的类就叫抽象类
格式：访问修饰符 abstract class 类名{}
注意（1）抽象类不能实例化对象（即抽象类不能和new关键字连用）
（2）抽象类声明的抽象方法是给子类提供一种规范，让子类去实现抽象方法
（3）含有抽象方法的类一定是抽象类，但抽象类中可以有普通方法和抽象方法
（4）子类继承父类，如果父类是一个抽象类,要么把子类声明为一个抽象类（不常用），要么在子类中实现父类中的所有抽象方法。

 1. //声明一个抽象类Person
    public abstract class Person{
        public int age;
        public String name;
        //声明一个抽象的方法
        public abstract void run();
        //声明一个普通的方法
        public void shui(){
            System.out.println("想要睡觉");
        }
    }
2.  //声明一个Child子类
    public class Child extends Person{
        //此处是run方法的实现
        public void run(){
            System.out.println("小孩子在摇摇晃晃的走路");
        }
        //此处是shui方法的重写
        public void shui(){
            System.out.println("中午了，小孩子准备午休");  
        }
    }
3.  //声明一个OldPerson子类
    public class OldPerson extends Person{
        //此处是run()方法的实现
        public void run（）{
            System.out.println("老人在步履蹒跚的走路");
        }
    }

4.//声明为一个QingZhuang青壮年的子类
    public class QingZhuang extends Person{
        //此处实现的是run方法
        public void run(){
            System.out.println("青年人在飞快的奔跑");
        }
    }
5.//声明为一个测试类
    public class TestPerson{
        public static void main(String []args){
            Preson per=new Child();
            per.run();
            per.shui();
            per=new OldPerson();
            per.run();
            per.shui();
            per=new QingZhuang();
            per.run();
            per.shui();
        }   
    }//以上代码验证了对象的多态性，（把子类对象赋给父类对象）对象长着相同的脸per，有着不同的行为

运行结果如下：

（二）接口

1. 接口interface：纯抽象类就叫接口。即接口当中所有的方法都是抽象方法
2. 纯抽象类：类中的所有方法都是抽象的叫做纯抽象类
3.声明一个接口，里面的所有方法都是抽象的，不用再为所有的方法加abstract关键字，接口当中所有的方法会默认的自动加上abstract关键字。 
4. 关键字implements实现：一个类实现一个接口有implement关键字
5. 结论1：如果一个类实现了一个接口，没有对接口当中的所有方法都实现，那么这个类还是抽象类
6. 结论2：（1）一个接口可以继承另一个接口（即接口之间可以相互继承）
（2）一个接口不可以继承一个抽象类
（3）一个抽象类不可以继承一个接口
（4）一个抽象类可以继承另一个抽象类（抽象之间可以相互继承）
（5）一个普通类可以继承一个抽象类
7.结论3：接口可以解单继承问题,java语言是一门单继承，多实现的语言
方法一：在java中可以让一个类单继承另一个类，再实现一个接口
例如：public class Dog extends  Person implements Animal{}
方法二：在java中可以同时用一个类同时去实现多个接口
例如:public class Dog implements Animal,Person{}

下面看说明例题
程序1：
public interface Person{//创建一个接口，名字叫Person
    //接口当中所有的方法都是抽象的方法，接口当中默认给方法加上abstract关键字
    public void say();//完全等价于public abstract void say();
}
程序2：
//一个接口继承了另一个接口
public interface Animal extends Person{
    public void run();//完全等价于public abstract void run();
    public void eat();//完全等价于public abstract void eat();
}
程序3：
//让一个类实现一个接口用implements关键字
public class Dog implements Animal{
    public void run(){//run方法的实现
        System.out.println("小狗在跑..");
    }
    public void eat(){//eat()方法的实现
        System.out.println("小狗在吃饭。。");
    }
    public void say(){
        System.out.println("小狗有灵性，会说话");
    }
}
    /*当Dog类实现实现一个接口Animal时，Dog类如果把接口Animal的
    的所有方法都实现了（包括Animal继承过来的方法），那么Dog类
    可以不是抽象类*/
}/*结论：如果一个类（例如Dog类）实现一个接口，没有对接口中所有
方法都实现（例如没有实现say方法），那么这个类（即Dog类）还是抽象类
(即必须在class之前添加关键字abstract,编译Dog类才可以通过)*/
程序4：
public class TestDog{
    public static void main(String []args){
        Dog go=new Dog();
        go.run();
        go.eat();
        go.say();
    }
}

运行结果如下

单继承问题的解决方法一

程序1：
//声明一个抽象的接口
public interface Animal{
    public void run();
    public void eat();
}
程序2：
//声明一个普通的类
public class Person{
    public void say(){
        System.out.println("说话，龙卷风");
    }
}
程序3：
//实现多继承
public class Dog extends Person implements Animal{
    public void run(){
        System.out.println("跑步");
    }
    public void eat(){//方法的实现
            System.out.println("吃饭");
    }
    //public void say(){//方法的实现
            //System.out.println("说话");
    //}
}
程序4：
public class TestDog{
    public static void main(String []args){
        Dog go=new Dog();
        go.run();
        go.eat();
        go.say();

    }
}

运行结果：

单继承问题的解决方法二

程序1：
public interface  Person{
    public  void say();
}
程序2：
public interface  Animal{
    public void run();
    public void eat();
}
程序3：
//接口可以解单继承问题,java语言是一门单继承，多实现的语言
//在Java中可以用一个类Dog同时去实现多个接口
public  class Dog  implements Animal, Person{
        public void run(){//方法的实现
            System.out.println("跑步");
        }
        public void eat(){//方法的实现
            System.out.println("吃饭");
        }
        public void say(){//方法的实现
            System.out.println("说话");
        }
}
程序4：
public class TestDog{
    public static void main(String []args){
        Dog go=new Dog();
        go.run();
        go.eat();
        go.say();

    }
}

运行结果如下