JavaSE多态随笔

多态

1. 解释说明编译时多态和运行时多态

编译时多态主要体现在方法重载上，在编译的时候就已经确定了方法如何调用。 运行时多态主要体现在方法重写上，因为只有在程序运行时才知道一个对象的引用到底指向堆内存中的 某一个具体对象，从而才能确定调用哪个对象的方法。

2. 解释说明 **instanceof **运算符的作用

instanceof 运算符的作用就是检测某个对象是否是某个类型的一个实例。主要用来进行向下转型（强 制类型转换），它能够确保向下转型的正确使用。 instanceof 运算符只能用在具有继承关系的类别中。

对象名 instanceof 类名;  //表示检测对象是否是指定类型的一个实例。返回值类型为boolean类型

3. 两个对象的哈希码相同，它们相等吗

不一定。因为Object类中的hashCode方法可以被重写，得出的结果是通过计算来的。因此出现同样的 哈希码时，可能使用的是不同的方式计算得出。那么哈希码相同时，对象不一定相等。但如果对象相 等，那么它们之间的哈希码一定相同。

Object类中的hashCode()方法返回的就是对象的内存地址。一旦重写hashCode()方法，那么Object 类中的hashCode()方法就是失效，此时的hashCode()方法返回的值不再是内存地址。

根据定义，如果两个对象相等，则它们的哈希码也必须相等，反之则不然。 重写了equals方法，就需要重写hashCode方法，才能满足上面的结论

面试题：请描述 == 和 equals 方法的区别

基本数据类型使用 == 比较的就是两个数据的字面量是否相等。引用数据类型使用 == 比较的是内存地 址。equals方法来自Object类，本身实现使用的就是 ==，此时它们之间没有区别。但是Object类中的 equals方法可能被重写，此时比较就需要看重写逻辑来进行。

4. Object类的finalize()方法有什么作用

Object类的finalize()方法主要是在垃圾回收器回收垃圾时调用，用于释放资源。

5.代码复现

编译时多态

package Calculator;
/**
 *计算任意两个数的和。
 */
public class Calculater {

    public double calculate(double a, double b) {
        return a + b;
    }
    public long calculate(long a, long b) {
        return a + b;
    }
}


package Calculator;

public class CalculaterTest {
    public static void main(String[] args) {
        Calculater c1 = new Calculater();
        long result1 = c1.calculate(1,2);
        System.out.println(result1);
        double result2 = c1.calculate(1.0,2);
        System.out.println(result2);
    }
}

运行时多态

package Hero;

/**
 * 王者荣耀中英雄都有名字，都会攻击
 * 物理英雄会发动物理攻击，法术英雄发动法术攻击。
 */
public abstract class Hero {
    protected String name;
    protected Hero(String name) {
        this.name = name;
    };
    public abstract void attack();
}

package Hero;

public class PhysicalHero extends Hero {
    public PhysicalHero(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println(name + "发动物理攻击");
    }

}

package Hero;

public class SpellHero extends Hero {
    public SpellHero(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println(name +"发动法术攻击");
    }
}

package Hero;

public class HeroTest {
    public static void main(String[] args) {
        PhysicalHero role1 = new PhysicalHero("李白");
        role1.attack();

        SpellHero role2 = new SpellHero("安琪拉");
        role2.attack();
    }
}

package animal2;
/**
 * 动物园中有老虎、熊猫、猴子等动物，每种动物吃的东西不一样，老虎吃肉，熊猫吃竹叶，猴子吃水
 * 果；动物管理员每天都会按时给这些动物喂食。
 * 分析：
 * 动物：吃东西
 * 老虎、熊猫、猴子都是动物
 * 动物管理员：喂食
 *动物园中现在又要引入一种新的动物狮子
 *如果动物园大量的引入动物，那么这个动物管理类就得添加多个相应的喂食方法。这很显然存在设计上
 *的缺陷，可以使用多态来优化。
 */
public abstract class Animal {
    public abstract void eat();
}


package animal2;

public class Tiger extends Animal{
    public Tiger(){

    }

    @Override
    public void eat() {
        System.out.println("Tigers eat meat");
    }
}


package animal2;

public class Panda extends Animal{
    @Override
    public void eat() {
        System.out.println("Pandas eat bamboo");
    }
}


package animal2;

public class Monkey extends Animal{

    @Override
    public void eat() {
        System.out.println("Monkeys eat banana");
    }
}


package animal2;

public class ZooKeeper {
    public void feed (Animal animal){
        animal.eat();
    }
}


package animal2;

public class ZookeeperTest {
    public static void main(String[] args) {
        ZooKeeper p1 = new ZooKeeper();
        p1.feed(new Tiger());
        p1.feed(new Panda());
        p1.feed(new Monkey());
        p1.feed(new Lion());
    }
}


package animal2;

public class Lion extends Animal{

    @Override
    public void eat() {
        System.out.println("Lions eat meat");
    }
}

package animal2;

public class Lion extends Animal{

    @Override
    public void eat() {
        System.out.println("Lions eat meat");
    }
    public void foraging(){
        System.out.println("Lions foraging");
    }
}


package animal2;

public class Monkey extends Animal{

    @Override
    public void eat() {
        System.out.println("Monkeys eat banana");
    }
    public void climbing(){
        System.out.println("Monkeys climbing");
    }
}



package animal2;

public class Panda extends Animal{
    @Override
    public void eat() {
        System.out.println("Pandas eat bamboo");
    }
    public void rolling() {
        System.out.println("Pandas rolling");
    }
}


package animal2;

public class Tiger extends Animal{
    public Tiger(){

    }

    @Override
    public void eat() {
        System.out.println("Tigers eat meat");
    }
    public void strolling(){
        System.out.println("Tigers strolling");
    }
}

package animal2;

public abstract class Animal {
    public abstract void eat();
}


package animal2;

import animal1.Dog;

public class ZooKeeper {
    public void feed (Animal animal) {
        animal.eat();

        if (animal instanceof Lion)
            ((Lion) animal).foraging();
        else if (animal instanceof Monkey)
            ((Monkey) animal).climbing();
        else if(animal instanceof Panda)
            ((Panda)animal).rolling();
        else if (animal instanceof Tiger)
            ((Tiger)animal).strolling();
    }
}


package animal2;

public class ZookeeperTest {
    public static void main(String[] args) {
        ZooKeeper p1 = new ZooKeeper();
        p1.feed(new Tiger());
        p1.feed(new Panda());
        p1.feed(new Monkey());
        p1.feed(new Lion());

    }
}