Java实现多态的三个要点（继承，重写，父类引用指向子类对象），并使用instanceof判断父类引用哪个子类对象

Posted 2023-04-02 katerdaisy

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java实现多态的三个要点（继承，重写，父类引用指向子类对象），并使用instanceof判断父类引用哪个子类对象相关的知识，希望对你有一定的参考价值。

class Hero
void attack()
System.out.println(“Heros are attack!”);

class Libai extends Hero//1.继承
void attack()//2.重写
System.out.println(“Libai is attacking”);

class Yase extends Hero//1.继承
void attack()//2.重写
System.out.println(“Yase is attacking”);

public class test3
public static void main(String args[])

    Hero hero1 = new Libai();//3.父类引用指向子类对象
    Hero hero2 = new Yase();//3.父类引用指向子类对象

    hero1.attack();
    hero2.attack();

    System.out.println("If hero1 is Libai? ----:"+ (hero1 instanceof Libai));
    System.out.println("If hero2 is Yase? ----:"+ (hero2 instanceof Yase));

继承多态及方法重写重载

1、多态：
- 多态指的是同一个方法的调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现完全不同。
- 多态的要点：
- - （1）多态是方法的多态，不是属性的多态（多态与属性无关）；
- - （2）多态的存在要有3个必要条件：继承、方法重写、父类引用指向子类对象；
- - （3）父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

/**
 * - - - （1）多态是方法的多态，不死属性的多态（多态与属性无关）；

 * - - - （2）多态的存在要有3个必要条件：继承、方法重写、父类引用指向子类对象；

 * - - - （3）父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了
 * 
 *
 */


public class TestPolm {
    public static void main(String[] args) {
        Animal a = new Animal();
        animalCry(a);
        Dog dog = new Dog();
        animalCry(dog);
        Cat cat = new Cat();
        animalCry(cat);
        Animal cat2 = new Cat();
        animalCry(cat2);
    }
    
    static void animalCry(Animal a){
        a.shut();
    }
}

class Animal{
    public void shut(){
        System.out.println("叫了一下！");
    }
}

class Dog extends Animal{//继承条件满足
    public void shut(){//方法重写条件满足
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal{//继承条件满足
    public void shut(){//方法重写条件满足
        System.out.println("喵喵喵");
    }
}

/**运行结果：
 * 叫了一下！
 * 汪汪汪
 * 喵喵喵
 * 喵喵喵
 */

2、继承使用要点：
- 父类也称作超类、基类等；
- java中只有单继承，没有C++那样的多继承。多继承会引起混乱，使得继承过于复杂，系统难于维护；
- java中类没有多继承，接口有多继承；
- 子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如，父类私有的属性和方法）；
- 如果定义一个类时，没有调用extends，则它的父类时：java.lang.Object。
3、instanceof运算符：
- instanceof是二元运算符，左边是对象，右边是类；当对象时右边类或子类所创建的对象时，返回true；否则，返回false。

public class Test{
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s instanceof Person);  //Student 继承自Person
        System.out.println(s instanceof Student);
    }
}

4、向上自动转型，向上强制转型：


public class TestPolm {
    public static void main(String[] args) {
        
        Animal cat = new Cat();//自动向上转型
        animalCry(cat);
        
        Cat cat2 = (Cat)cat; //强制向下转型
    }
    
    static void animalCry(Animal a){
        a.shut();
    }
}

class Animal{
    public void shut(){
        System.out.println("叫了一下！");
    }
}

class Dog extends Animal{//继承条件满足
    public void shut(){//方法重写条件满足
        System.out.println("汪汪汪");
    }
}

class Cat extends Animal{//继承条件满足
    public void shut(){//方法重写条件满足
        System.out.println("喵喵喵");
    }
}

5、父类的普通方法可以被继承和重写，不多作解释，如果子类继承父类，而且子类没有重写父类的方法，但是子类会有从父类继承过来的方法。
- 静态的方法可以被继承，但是不能重写。 如果父类中有一个静态的方法，子类也有一个与其方法名，参数类型，参数个数都一样的方法，并且也有static关键字修饰，那么该子类的方法会把原来继承过来的父类的方法隐藏，而不是重写。通俗的讲就是父类的方法和子类的方法是两个没有关系的方法，具体调用哪一个方法是看是哪个对象的引用；这种父子类方法也不在存在多态的性质。《Java编程思想》中这样提到“只有普通的方法调用可以是多态的”。下面代码为例：

public class StaticTest  
{  
    public static void main(String[] args)  
    {  
        M m = new N();  
        m.output();  
    }  
}  
  
class M  
{  
    public static void output()  
    {  
        System.out.println("M");  
    }  
}  
  
class N extends M  
{  
    public static void output()  
    {  
        System.out.println("N");  
    }  
}

上面执行的结果是“M”，也就是是M类型的引用调用的，如果修改main方法中的代码：

N n = new N();

n.output();

那么执行的结果是“N”，也就是N类型的引用调用的。

6、子类能继承父类的所有成员，使用反射可以看出子类是继承了父类的私有方法的(不管是否是final)，只是直接调用父类的私有方法是不可以的，但是利用反射的方式可以调用。字段同理。

7、方法的重写和重载：
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
- （1）方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
- （2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
- （3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
在面向对象编程中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
- （1)父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某
  方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
- （2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
- （3)子类函数的访问修饰权限不能少于父类的；
  
  需要重写方法是因为：父类的功能无法满足子类的需求。