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());

    }

}