java的方法重写 ,多态和关键字 instanceof和final

Posted 406070989senlin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java的方法重写 ,多态和关键字 instanceof和final相关的知识,希望对你有一定的参考价值。

package cn.pen;
/*final 是一个java的关键字,用于修饰局部变量、属性、方法、类,表示最终的意思。
 final修饰类表示最终类,无法被继承。public final class Penguin{}
 final修饰符方法,方法就不能被重写。所以final修饰的是最终子类或最终类
 final 修饰属性,经常和static搭配使用,形成静态常量。静态常量不能被改变
 修饰变量final 修饰基本数据类型 ,表示a中的内容(值)不能被改变final int a = 10;
final 修饰引用数据类型,表示person中的内容(地址)不能被概念 final Person person = new Person();*/    

//子类 企鹅
public class Penguin extends Pet {
    private String gender;

    public static final String SEX_MALE = "Q仔";
    public static final String SEX_FEMALE = "Q妹";

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Penguin() {
        super();
    }

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

    @Override
    public void showInfo() {//方法重写
        super.showInfo();
        System.out.println(",我是一只" + this.getGender());
    }

    @Override
    public void eat() {//方法实现,完全重写
        System.out.println(super.getName() + "在吃鱼...");
        super.setHealth(super.getHealth() + 5);
    }
    public void swimming() {
        System.out.println("企鹅在游泳...");
        super.setHealth(super.getHealth() - 10);
        super.setLove(super.getLove() + 5);
    }


}

 

package cn.pen;
//主人类
public class Master {
    private String name;

    public String getName() {
        return name;
    }

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

    public Master() {
        super();
    }

    public Master(String name) {
        super();
        this.name = name;
    }
    //添加一种动物,就增加一条引用动物代码
    /*public void feed(Dog dog) {           //把子类Dog引用过来,提取Dog中的属性
        System.out.println(this.getName() + "正在喂:" + dog.getName());
        dog.eat();                    //再把Dog中eat方法引用过来           */
    
    
    
    //只需一条引用父类,就可以被所有动物使用
    //父类作为方法形参实现多态
/*    public void feed(Pet pet) {           //把父类Pet引用过来,Dog把自己赋给Pet,
        System.out.println(this.getName() + "正在喂:" + pet.getName());
        pet.eat();  }
        
   
   
   父类作为方法的返回值实现多态:* */
  public Pet adoptPet(int type) {    //从Test得到type,然后判断
        Pet pet = null;              //类型转换
        if(1 == type) {
            pet = new Dog();
        }else  {
            pet = new Penguin();
        }
        return pet;                 //得到返回值 ,返回给Test
    }
        
    public void play(Pet pet) {
        if(pet instanceof Dog) {
            Dog dog = (Dog) pet;
            dog.catchFlyDisc();
        }else if(pet instanceof Penguin) {
            Penguin penguin = (Penguin) pet;
            penguin.swimming();
        }
    }
    
 
}

package cn.pen;
//子类 狗
public class Dog extends Pet{
    private String strain;

    public String getStrain() {
        return strain;
    }

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

    public Dog() {
        super();
    }

    public Dog(String name, int health, int love, String strain) {
        super(name, health, love);
        this.setStrain(strain);
    }
    public void showInfo() {
        super.showInfo();//在继承的基础上部分重写,完全重写就不需要引入父类方法,自己全部重写
        System.out.println(",我是一只" + this.getStrain());
    }/*:方法的重写
    当子类从父类继承过来的方法不能满足自身需要时,子类可以根据自身情况进行方法重写(overwrite/override)
            方法重写建立在继承的基础上,没有继承,就没有重写! 子类根据自身情况,可以选择部分重写和完全重写
            重写的规则:1.方法名称相同2. 参数列表相同3. 子类的访问权限一定 >= 父类访问权限  4. 返回值和父类相同或者是其子类    
        何时使用继承: 符合 is – a 关系;学生 is a 人;老师 is a 人;
          继承实现代码重用
           当 多个子类拥有共同的属性和行为时,人为把共同的属性和方法提取到父类中,子类继承父类实现代码重用     
    */
    
    public void eat() {//方法实现(完全重写)
        System.out.println(super.getName() + "吃狗粮...");
        super.setHealth(super.getHealth() + 3);
        /*实现(implement):子类继承抽象父类时,一定要重写父类的抽象方法,此时父类的抽象方法没有方法体,也即没有实现;
         * 子类一定重写父类的抽象方法也即实现了父类的抽象方法。实现是一种特殊的重写。实现建立在重写的继承上。*/
        
        }
        
        //父类没有的方法
        public void catchFlyDisc(){
            System.out.println("狗狗在玩飞盘...");
            super.setHealth(super.getHealth() - 10);
            super.setLove(super.getLove() + 6);
    }

    
}

 

 
package cn.pen;
//父类:动物
public abstract class Pet {
//abstract(抽象)     抽象类:public abstract class 类名 {}    
//抽象类过于抽象,实例化后无语义 => 不能实例化
    private String name;
    private int health;
    private int love;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        if(health < 0) {
            this.health = 100;
            System.out.println("健康值不合法!");
        }else {            
            this.health = health;
        }
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public Pet() {
        this.health = 100;
        this.love = 0;
    }
    public Pet(String name, int health, int love) {
        
        this.name = name;
        this.health = health;
        this.love = love;
    }
    public void showInfo() {
        System.out.print("我的姓名:"+this.getName());
        System.out.print(",健康值:"+this.getHealth());
        System.out.print(",亲密度"+this.getLove());
    }//吃方法,动物都有吃的行为(方法);但不同的动物吃的方法不同,吃的东西不同,所以吃是个抽象方法
    public abstract void eat();
/*因为动物都有睡觉的行为(动物共有的),但是不同的动物 睡觉方法不同,比如:
 * 人继承于动物,鱼继承于动物。人有睡觉(闭眼睡)的方法,鱼有睡觉的方法,动物也有睡觉的方法
 * 虽然都是睡觉,但是睡觉方法却不同,所以说睡觉这个方法不能再父类实习,只有在具体到子类时才能实现
 * 此时可以把该方法定义成抽象方法。抽象方法却只能存在于抽象类,所以有抽象方法的类称为抽象类(abstract class)
 * 所以:如果一个方法过于抽象无法实现,需要把该方法声明为抽象方法。形式:public abstract void eat();
 * 注意:抽象方法一定位于抽象类中。
                    抽象方法没有方法体。
                     抽象类中的方法不一定都是抽象方法。
                     子类继承抽象类,一定要根据自身情况重写抽象类的抽象方法,除非子类也是抽象类。
 
 * */
}

 


package cn.pen; //执行类 import java.util.Scanner;
public class Test { public static void main(String[] args) { //Dog dog = new Dog("二狗",90,0,"土狗"); //把Dog的类引入进来 //Master master = new Master("王二小"); //在把主人类引用进来 //master.feed(dog); //把dog(Dog类的入口或钥匙)引入主人类的feed方法 //dog.showInfo(); //引出Dog类的showInfo方法 /*执行结果: * 王二小正在喂:二狗 二狗吃狗粮... 我的姓名:二狗,健康值:93,亲密度0,我是一只土狗*/ //每个动物都有吃,但吃的方法不同,造成的结果也就不同,但动物有很多种,我们不能每个动物子类都这样写一遍 //所以我们用到了:多态 /*多态 * * 软件设计原则—开闭原则 ,对拓展开放,对修改关闭。为什么要使用多态?对系统进行业务拓展,增加系统的可维护性。 可以理解为多种状态/多种形态 同一事物,由于条件不同,产生的结果不同 程序中的多态 同一引用类型,使用不同的实例而执行结果不同的。 同:同一个类型,一般指父类。 不同:不同的子类实例 不同:针对同一方法执行的结果不同 比如说睡觉,不同的动物睡觉方法不同,最后结果不同*/ /*在多态中存在两种类型转换,一种是自动类型转换,一种是强制类型转换。 在引用数据类型转换过程中, 自动类型转换也称向上类型转换。子类可以自动转换成父类。 多态的实现形式 * 父类类型 引用 子类对象(本质) Pet pet=null; //同一引用类型(父类) pet = new Dog("二狗",90,0,"土狗") ;// [ 自动类型转换] 父类类型引用子类对象,当调用eat方法时,执行的是被子类对象重写/实现的eat方法。 pet.eat(); // 呈现多态 结果:二狗吃狗粮... 王二小正在喂:二狗 * */ //父类作为方法形参实现多态 /*Pet pet=null; //同一引用类型(父类) pet=new Dog("二狗",100,0,"土狗"); // 父类引用 引用 子类对象 Master master = new Master("王二小"); master.feed(pet); // 呈现多态 pet.showInfo(); // 呈现多态 pet=new Penguin("大脚", 90, 50, Penguin.SEX_FEMALE); // 父类引用 引用 子类对象 master.feed(pet); // 父类引用 引用 子类对象 pet.showInfo(); // 呈现多态 同样的结果,但是我们只在主人类那只需写引用父类的代码就可以了 ,无需向上面那样每个动物都需在主人类那写一遍 * 现在没增加一种动物就只会多写一个类就可以了,无需再主人类那加一条方法;实现一个方法多种使用 结果: 王二小正在喂:二狗 二狗吃狗粮... 我的姓名:二狗,健康值:103,亲密度0,我是一只土狗 王二小正在喂:大脚 大脚在吃鱼... 我的姓名:大脚,健康值:95,亲密度50,我是一只Q妹 父类作为方法的返回值实现多态: */ System.out.println("欢迎光临sxt宠物店"); System.out.println("请选择领养的宠物 1.狗狗 2.企鹅 "); Scanner arr=new Scanner(System.in); int type=arr.nextInt(); //控台输入type Master master = new Master("王二小"); //引用Master类 Pet pet = master.adoptPet(type); //把type赋值给Master类adoptPet方法判断,得出来结果后赋给pet /*强制类型转换也称向下类型转换。父类可以强制转换成子类 * 子类类型 引用 = (子类)父类对象 * 一般而言,需要判断父类对象的真实类型,用instanceof关键字 * obj instanceOf 类/接口 判断obj是否是类/接口的实例
instanceof通常和强制类型转换结合使用
instanceof是判断是否能强制转换,能返回true * 如果要调用子类特有的方法时,一定要强制类型转换,通过instanceof鉴别具体类型
*/ if(pet instanceof Dog) { //得到从Master得到的返回值pet,然后判断是强制转换给Dog还是Penguin, Dog dog = (Dog) pet; //判断完之后再一个一个赋值 dog.setName("二狗"); dog.setHealth(90); dog.setLove(20); dog.setStrain("土狗"); }else if(pet instanceof Penguin) { Penguin penguin = (Penguin) pet; penguin.setName("大脚"); penguin.setHealth(90); penguin.setLove(20); penguin.setGender(Penguin.SEX_FEMALE); } master.play(pet); //再把被赋完值之后的pet引入Master的piay方法执行再返回结果 pet.showInfo(); } }

 

以上是关于java的方法重写 ,多态和关键字 instanceof和final的主要内容,如果未能解决你的问题,请参考以下文章

php 方法重写和多态的区别

Java——基础知识——多态对象类型转换

java基础疑难点总结之成员变量的继承,方法重载与重写的区别,多态与动态绑定

JAVA06 封装继承多态 总结(初级)

JAVA06 封装继承多态 总结(初级)

JAVA06 封装继承多态 总结(初级)