java复习----Java多态

Java多态
多态的概念：
允许不同类的对象对同一消息作出不同响应。

编译时多态：设计时多态（方法重载）

运行时多态：程序运行时动态决定调用哪个方法。

必要的条件：
满足继承的关系
父类引用指向子类对象

实例代码：
父类：（动物类）
package cn.lqandzy.bean;
/**

• @author : 慕祈
• @date 创建时间：2018年2月12日 下午12:37:05
• @version 1.0
• @parameter
• @since

• @return
  */
  public class Animal {
  private String name;
  private int month;

  public int getMonth() {
  return month;
  }
  public void setMonth(int month) {
  this.month = month;
  }
  public void eat(){
  System.out.println("吃东西");
  }
  public String getName() {
  return name;
  }
  public void setName(String name) {
  this.name = name;
  }

  public Animal() {
  System.out.println("我是父类的无参构造方法");
  }
  public Animal(String name, int month) {
  super();
  this.name = name;
  this.month = month;
  }

}

子类（猫）
package cn.lqandzy.bean;

/**

• @author : 慕祈
• @date 创建时间：2018年2月7日 下午1:44:11
• @version 1.0
• @parameter
• @since

• @return
  */
  public class Cat extends Animal{
  private String weight;

  public Cat() {
  System.out.println("我是子类的无参构造方法");
  }

  public Cat(String name,int month,String weight) {
  super(name,month);
  setWeight(weight);
  }

  public String getWeight() {
  return weight;
  }
  public void setWeight(String weight) {
  this.weight = weight;
  }

  @Override
  public void eat() {
  System.out.println("猫吃鱼");
  }

  @Override
  public int getMonth() {
  System.out.println("猫的年龄");
  return this.getMonth();
  }

  public void run(){
  System.out.println("猫跑步");
  }
  }

子类（狗）：
package cn.lqandzy.bean;
/**

• @author : 慕祈
• @date 创建时间：2018年2月12日 下午1:05:21
• @version 1.0
• @parameter
• @since

• @return
  */
  public class Dog extends Animal {
  private int sex;

  public int getSex() {
  return sex;
  }
  public void setSex(int sex) {
  this.sex = sex;
  }
  public Dog(String name, int month, int sex) {
  super(name, month);
  setSex(sex);
  }
  public Dog() {
  super();
  }

  public void sleep(){
  System.out.println("狗睡觉");
  }
  @Override
  public void eat() {
  System.out.println("狗吃肉");
  }
  @Override
  public int getMonth() {
  System.out.println("猫的年龄");
  return this.getMonth();
  }
  }

向上转型：
父类引用指向子类实例
public static void main(String[] args) {
Animal animal=new Animal();
//向上转型
Animal animal1=new Cat();
Animal animal2=new Dog();
animal.eat();
animal1.eat();
animal2.eat();
animal.getMonth();
animal1.getMonth();
animal2.getMonth();
}

向下转型：
Cat cat=(Cat) animal1;
Dog dog=(Dog) animal2;
cat.eat();
dog.eat();

animal1原本就是cat的实例，所以强转不会报错。若对象的实例不想听，仍强转，就会出现类型转换错误。

InstanceOf:
我们可以借助这个关键字来判断对象是否是某一个类的实例。

System.out.println(animal1 instanceof Cat);
返回结果为true，说明animal1这个对象是cat这个类的实例。
此关键字可以加强强转的安全性

静态方法不能比子类重写
public static void say(){
System.out.println("说");
}

案例：
主人类：（根据喂养不同宠物做不同的动作。）
public class Master {
/* 喂宠物

• 如果是猫：完球
• 如果是狗：睡觉
  */
  public void feed(Animal animal){
  if(animal instanceof Cat){
  System.out.println("玩球");
  }
  if(animal instanceof Dog){
  System.out.println("睡觉");
  }
  }

}

测试类：

可以看到测试类feed中，穿进去的cat与dog实例进行的向上转型，在feed里进行判断实例为何，然后进行方法的逻辑调用。
这样的好处是，如果之后宠物有多少种，我只要一个方法就可以满足需求。

抽象类：
以下代码在编译上没有问题，但在程序逻辑上没有真正意义。
Animal animal=new Animal("花花",1);
animal.eat();
因为每一种动物都有吃的行为，但是这个实例没有指向任何一种动物，也就不存在任何意义，那么，有什么方法能提醒别人在写程序时不写这种编译没问题，但没有实际意义的代码呢。那就是抽象类。
我们在animal上加上abstract关键字
public abstract class Animal {

这样这个类就变成了抽象类。抽象类无法进行实例化

但是可以通过向上转型使用抽象类。

抽象方法：
不允许包含方法体，子类必须重写抽象方法。否则，子类也要是抽象类
public abstract void eat();

如果想在一个类中支持多种类型（继承只能继承一个），那么就需要使用接口。

抽象方法与常量

接口中的默认方法与静态方法
类实现接口后默认方法与静态可以不实现

如果接口中的有变量x，父类也有变量x，子类必须重写x，否则无法知道调用哪个x，从而报错。
如果是父类与接口都包含同名方法，优先使用父类的方法。
关于1.8接口的知识，可以参考这个传送门：
http://blog.csdn.net/aitangyong/article/details/54134385
接口的继承：
接口的继承比较特殊，可以实现多继承。

引用文字