抽象类和接口、多态的理解

标题一、抽象类

抽象类必须使用abstract关键字来修饰，并且定义方法时不需要实现方法体。当一个类中包含抽象方法时，那么该类也是必须使用abstract关键字来修饰，而这种类被称为抽象类。
抽象类及抽象方法定义的基本语法格式如下：
//定义抽象类
[修饰符] abstract class 类名{
//定义抽象类方法
[修饰符] abstract 方法返回值类型 方法名([参数列表]);
//其他方法或属性
}
注意：抽象方法的类必须是抽象类，抽象类中可以不包含任何的抽样方法。抽象类是不能被实例化，因为抽象类中可能包含抽样方法。抽样方法没有方法体，不可被调用。如果想要调用抽象类中的抽样方法，需要创建一个子类，在子类中实现抽象类中的抽样方法。
例子：

//定义一个抽象类Animal
abstract class Animal{
    //定义一个抽象方法shout()
    public abstract void shout();
}
//定义一个Dog类继承Animal类
class Dog1 extends Animal{
    //实现抽象方法shout（），编写方法体
    public void shout(){
        System.out.println("汪汪.........");
    }
}
//定义测试类
public class Example12 {
    public static void main(String[] args) {
        Dog1 dog=new Dog1();//创建Dog类的实例对象
        dog.shout();
    }
}

运行结果：

标题二、接口

接口是一种特殊的抽象类，他不能包含普通的方法，内部的方法都是抽象方法，将抽象进行得更彻底。
在JDK8中，对接口重新定义，接口除了抽象方法外，还有默认方法和静态方法（也叫类方法），默认方法用default修饰，静态方法使用static修饰，而且这两种方法都允许有方法体。
与定义类不同的是，在接口定义时，不再用class关键字，而是要用interface关键字来声明。接口的定义基本语法格式如下：
[修饰符] interface 接口名[extends 父接口1，父接口2，…]
[public] [static] [final] 常量类型 常量名=常量值；
[public] [abstract] 方法返回值类型 方法名（[参数列表]）；
[public] default方法返回值类型 方法名（[参数列表]）{
//默认方法的方法体
}
[public] static方法返回值类型 方法名（[参数列表]）{
//静态方法的方法体
}
在上面的语法格式中，"[ ]"中的内容都是可选的，修饰符可以用public或者直接省略（省略时默认采用包权限访问控制符）。“extends父接口1，父接口2，…”表示定义一个接口可以同时继承多个父接口，这也是为了解决类的单继承。在接口的内部可以定义多个常量和抽象方法，定义常量时必须进行初始化赋值，定义默认方法和静态方法时，可以有方法体。
从接口定义的语法格式可以看出，接口包含三类方法：抽象方法，默认方法，静态方法，其中静态方法可以通过接口名.方法名调用，而默认方法和抽象方法都只能通过接口实现类的实例化对象来调用。
例子：

//定义一个Animal接口
interface Animal{
    int ID=1;//定义全局常量
    void breathe();//定义抽象方法breathe

    //定义默认方法
    default void getType(String type) {
        System.out.println("该动物属于："+type);
    }

    //定义一个静态方法
    static int getID(){
        return Animal.ID;
    }
}
//定义一个Dog类实现LandAnimal接口
 interface LandAnimal extends Animal{
        void run();  //定义抽象方法run()

    }
    //Dog类实现LandAnimal接口
class Dog1 implements LandAnimal{
    //实现breathe()方法
        public void breathe(){
            System.out.println("狗在呼吸");
        }
        //实现run（）；方法

        @Override
        public void run() {
            System.out.println("狗在陆地上奔跑");
        }

        @Override
        public void getType(String type) {

        }
    }
//定义测试类
public class Example12 {
    public static void main(String[] args) {
        System.out.println(Animal.getID());//通过接口名来调用类方法
        Dog1 dog=new Dog1();
        System.out.println(dog.ID);//在实现类中获取接口全局常量
        dog.breathe();//调用dog对象的breathe（）方法
        dog.getType("犬科");//调用dog对象接口中的默认方法
        dog.run();//调用dog对象run（）方法
    }
}

总结：

1. 在JDK8之前，接口中的方法都必须是抽象的，并且方法不能有方法体，调用抽象方法时，必须通过接口的实现类的对象才能实现方法。JDK8开始接口中除了有抽象方法，还有默认方法和静态方法，默认方法和静态方法都有方法体，其中静态方法可以通过接口.方法名来调用。
2. 当一个类实现接口时，如果是抽象类，只需实现接口中的部分抽象方法即可，否则要实现接口中的全部抽象方法。
3. 一个类可以通过implements关键字同时实现多个接口，被实现的多个接口之间用英文逗号(,)隔开。
4. 接口之间可以通过extends关键字实现继承，并且一个接口可以继承多个接口，接口间用英文逗号隔开。
5. 一个类在继承一个类的同时还可以实现接口，此时，extends关键字必须在implements关键字之前。例如
   class A extends B implements C{//先继承再实现
   }

标题三、多态

在Java中，多态是指不同的类的对象调用同一种方法所呈现出的多种行为。简单来说就是在一个类中定义的属性和方法被其它类继承或重写，当把子类对象赋值给父类引用变量时，相同的引用类型的变量调用同一种方法呈现出不同的形态。通过多态，消除了类之间的耦合关系，大大提高程序的可扩展性和可维护性。
Java中的多态就是父类引用指向子类对象体现。
例子：

//定义一个抽象类Animal
abstract class Animal {
    abstract void shout();
}
class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("喵喵......");
    }
}
class Dog1 extends Animal{
    public void shout(){
        System.out.println("汪汪....");
    }
}
//定义测试类
public class Example12 {
    public static void main(String[] args) {
        Animal an1=new Cat();
        Animal an2=new Dog1();
        an1.shout();
        an2.shout();
    }
}

对象类型转换：
当子类对象当作父类使用时不需要任何显示声明，注意不能通过父类调用子类的特有方法。

//定义一个抽象类Animal
abstract class Animal {
    abstract void shout();
}
class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("喵喵......");
    }
    //定义Cat类特有的东西抓老鼠catchMouse
    public void catchMouse(){
        System.out.println("小猫抓老鼠...");
    }
}

//定义测试类
public class Example12 {
    public static void main(String[] args) {
        Animal an1=new Cat();
        Cat cat=(Cat)an1;//将Animal类型转为Cat
        cat.shout();
        cat.catchMouse();
    }
}

Java提供了一个关键字instanceof，判断是否为某一个类（或接口）的实例或者子类实例：
对象（或者对象引用变量）instanceof类（或者接口）
例子：
Animal an1=new Dog();
if(an1 instanceof Cat){
Cat cat=(Cat)an1;
cat.shout();
}else{
System.out.println(“不能转型”);
}