final修饰符与多态

知识点
一、final 最终的
可以修饰属性、方法、类
1、final修饰的属性，表示常量，初始化以后值不能改变。final修饰
引用数据类型的变量，引用地址不能改变。
2、final修饰类，不能被继承。比如：String
3、final修饰方法，不能被重写

 public class FinalDemo {
     public static final String NAME="张三";//静态常量
     public static void main(String[] args) {
         final int n=100;//常量
         //n=200；//final修饰的常量，复值以后不能改变
         final Object obj=new Object();//所有类的父类
 //        o=new Object();
     }

 public  class Foo {
    public final void   function(){
        System.out.println("方法被调用");
    }

 public class TestFoo extends Foo/*extends Stringextends Foo*/{
     //经过final修饰的方法不能被重写也无法继承
     /*@Override
     public void function() {
     }*/

     public static void main(String[] args) {
          Foo foo=new Foo();
          foo.function();
     }

二、多态
多态：同一个引用类型，使用不同的实例而执行不同操作 。
父类引用指向子类对象。
多态步骤：
使用多态实现思路
编写具有继承关系的父类和子类
子类重写父类方法
使用父类的引用指向子类的对象
多态语法：
向上转型
Pet pet = new Dog();
实现多态的两种形式：
使用父类作为方法形参实现多态
使用父类作为方法返回值实现多态

 package day20190304;

 /**
  * 狗类，继承Pet类
  *
  * @author Administrator
  *
  */
 public class Dog extends Pet {
     private String strain;

     public Dog() {}

     public Dog(String name, int health, int love, String strain) {
         super(name, health, love);
         this.strain = strain;
     }

     public String getStrain() {
         return strain;
     }

     public void setStrain(String strain) {
         this.strain = strain;
     }

     public String printInfo() {
         return getName() + " " + getHealth() + " "
     + getLove() + " " + strain;
     }

     @Override
     public void eat() {
         setHealth(this.getHealth()+3);
         System.out.println("吃饱了，健康值增长为"+getHealth());
     }
     /**
      * 狗接飞盘
      */
     public  void  catchingFlyDisc(){
         this.setLove(this.getLove()+5);
         this.setHealth(this.getHealth()-10);
         System.out.println("玩一会，健康值减少10，亲密度增加5");
     }
 }

 package day20190304;

 /**
  * 企鹅类，继承Pet类
  *
  * @author Administrator
  *
  */
 public class Penguin extends Pet {
     private String sex;

     public Penguin() {
     }

     public Penguin(String name, int health, int love, String sex) {
         super(name, health, love);
         this.sex = sex;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     @Override
     public String printInfo() {
         return getName()+" "+getHealth()+" "
       +getLove()+" "+sex;
     }

     @Override
     public void eat() {
         setHealth(this.getHealth()+5);
         System.out.println("吃饱了，健康值增长为"+getHealth());
     }
     /**
      * 企鹅游泳
      */
     public  void  swimming(){
         this.setLove(this.getLove()+5);
         this.setHealth(this.getHealth()-10);
         System.out.println("玩一会，健康值减少10，亲密度增加5");
     }
 }

 package day20190304;

 /**
  * 父类，宠物类
  *
  * @author Administrator
  *抽象类
  */
 public abstract class Pet {
     private String name;
     private int health;
     private int love;

     protected Pet() {
     }

     protected Pet(String name, int health, int love) {
         this.name = name;
         this.health = health;
         this.love = love;
     }

     public String getName() {
         return name;
     }

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

     public int getHealth() {
         return health;
     }

     public void setHealth(int health) {
         this.health = health;
     }

     public int getLove() {
         return love;
     }

     public void setLove(int love) {
         this.love = love;
     }
     /**
      * 显示所有信息
      * @return
      */
     public  abstract  String  printInfo();
     /**
      * 宠物吃东西
      */
     public  abstract  void  eat();
 }

 package day20190304;

 /**
  * 主人类
  *
  * @author Administrator
  *
  */
 public class Master {
     /**
      * 给宠物喂食
      *
      * @param pet
      */
     public void feed(Pet pet) {
         pet.eat();
     }

     /**
      * 和宠物玩耍
      *
      * @param pet
      */
     public void play(Pet pet) {
         // System.out.println(pet instanceof Penguin);
         if (pet instanceof Penguin) {//判读是否为企鹅类型
             Penguin penguin = (Penguin) pet;
             penguin.swimming();
         } else if (pet instanceof Dog) {
             // 将父类对象还原为子类对象，强制类型转换
             Dog dog = (Dog) pet;
             dog.catchingFlyDisc();// 调用狗自己的方法
         }
     }

     /*
      * public Pet getPet(String petNo){ return new Dog(); }使用多态优化返回值类型
      */
 }

 package day20190304;

 public class TestPet {

     public static void main(String[] args) {
         // 父类引用指向子类对象空间
         // Pet pet=new Dog();
         Dog dog = new Dog("来福", 80, 80, "田园犬");
         Penguin penguin = new Penguin("球球", 80, 80, "Q仔");
         // 主人对象
         Master master = new Master();
         master.play(dog);// 和宠物玩耍
         master.play(penguin);

         master.feed(dog);// 给宠物喂食

         // System.out.println(dog.printInfo());

     }

 }