Java---多态与接口

多态，简单来说就是具有多种表示形态的能力。

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法， 具体实现会完全不同。 比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人 用刀叉吃饭，印度人用手吃饭。

多态的要点：

多态是方法的多态，与属性无关。多态的三个必要条件：继承，方法重写，父类引用指向子类父类引用指向子类对象后，用该父类引用调用子类的方法，此时多态就出现了

1.父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

2.向上转型后的父类引用变量只能调用它编译类型的方法，不能调用他运行时类型的方法。

   这时，我们就需要进行类型的强制转化，我们称向下转型。

3.在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类 型转换异常 ClassCastException。

package com.jxsxt.duotai;

public class Animal {
    public void shout(){
        System.out.println("叫了一声");
    }


}
class Dog extends Animal{
    @Override
    public void shout(){
        System.out.println("汪汪汪");
    }
      public void seeDoor(){
          System.out.println("看门");
      }
}

class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("别狗叫");


    }
public void cat(){
    System.out.println("猫抓老鼠");
}
}

class Mos extends Animal{
    @Override
    public void shout() {

    }
}

package com.jxsxt.duotai;

public class test {

    static void animalCry(Animal a) {
        a.shout();
    }
    public static void main(String[] args) {
        Dog d=new Dog();
        animalCry(d);
        animalCry(new Cat());

        //测试类型的转换
        Animal a=new Dog();//向上类型转换  自动

        Dog d2=(Dog) a;//强制类型转换，向下类型转换
        d2.seeDoor();

      

        if(a instanceof Dog){
            Dog d3=(Dog) a;
            d3.seeDoor();
        }else if(a instanceof Cat){
            Cat c4=(Cat) a;
            c4.cat();
        }

    }

}

1.使用abstract修饰的方法，没有方法体，只有声明。

2.定义的是一种“规范”，就是告诉子类必须要给抽象方法具体的实现。

包含抽象方法的类就是抽象类。

通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

抽象类的使用要点：

有抽象方法的类只能定义成抽象类 抽象类不能实例化，即不能用 new 来实例化抽象类 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例， 只能用来被子类调用 抽象类只能用来被继承抽象方法必须被子类继承

package com.jsxt.abstract1;

public abstract class Student {
    private  int id;
    private String name;

    abstract public void study();
    abstract public void exam();

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    Student (){};
}

package com.jsxt.abstract1;

public class Text {
    public static void main(String[] args) {
Student s=new SxtStu();
s.study();
s.exam();
    }
}

class SxtStu extends Student{

    @Override
    public void study() {
        System.out.println("wjh");
    }

    @Override
    public void exam() {
        System.out.println(100);
    }
}

接口是一种数据类型，使用interface关键字声明。接口就是一组规范（类比 法律），所有实现类都要遵守。

接口不是类，是一种引用数据类型。因为类是使用class声明的吗，而接口是使用interface关键字声明的。接口中不可以有构造方法。

声明格式：

[访问修饰符] interface 接口名 [extends   父接口1，父接口2]

{

常量定义；

方法定义；

} 

定义接口的详细说明：

访问修饰符：只能是public或默认接口名：和类名采用相同命名机制extends：接口可以多继承常量：接口中属性只能是常量，总是：public static final 修饰。方法：接口中的方法只能是：public abstract

要点：

子类通过implements来实现接口中的规范接口不能创建实例，但是可用于声明引用变量类型一个类实现了接口，必须实现接口中所有的方法，且方法只能是publicJDK1.8（不含 8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造 方法、普通方法。JDK1.8（含 8）后，接口中包含普通的静态方法、默认方法。

//接口
package com.bjsxt.jiekou;

public interface Volant {
    int MAX_HIGHT=100;

    void fly();

    void stop();
}

interface Honest{
    void helpOther();
}

package com.bjsxt.jiekou;

public class Superman implements  Volant,Honest
{
    @Override
    public void fly() {
        System.out.println("横行霸道");
    }

    @Override
    public void stop() {
        System.out.println("竖着停");
    }

    @Override
    public void helpOther() {
        System.out.println("哪里点到点哪里");
    }

    public static void main(String[] args) {
        Superman m1=new Superman();
        m1.fly();
        m1.helpOther();

    }
}