JAVA子类作为实参父类作为形参_java 多态 实参形参

多态：

概述：

多态是继 封装性，继承性，面向对象的第三大特性

定义：

多态：是指同一行为具有多个不同的表现形式.

生活中：比如跑的动作：猫，狗，大象，跑起来的动作都是不一样的

飞的动作：昆虫，鸟类，人造飞机，飞起来的动作都是不一样的

可见同一行为通过不同的事物，可以表现出不同的形态.

多态描述的就是这样的一种状态

前提：

1.继承或实现【二选其一】

2.父类的引用指向子类的对象【格式体现】

3.方法的重写【意义：不重写无意义】

表现：多态表现得格式：

父类类型 变量名 = new 子类对象；

变量名.方法名();

备注：父类类型指的是子类对象继承的父类类型，或者实现的父接口类型.

public class Fu{

public void method(){

System.out.println("父类的method方法");

}

}

//1.继承

public class Zi extends Fu{

//2.重写

@Override

public void method(){

System.out.println("子类重写后的method方法");

}

}

public class TestPolymorphismDemo01{

public static void main(String[] args){

//多态格式

/*

父类类型 变量名 = new 子类对象；

变量名.方法名();

*/

//3.父类引用指向子类的对象

Fu fu = new Zi();

fu.method();//本质调用的是子类当中重新给之后的method方法

}

}

如果在使用多态方式调用方法时，首先检查父类当中是否有该方法，

如果没有则编译直接报错，如果有执行的是子类重写后的方法

好处：

在实际开发中，父类类型作为方法的 形式参数(不同于实际参数)，传递子类对象(实参)给方法，

进行方法的调用更能体现出多态的扩展性和便利性

代码如下：

//定义一个抽象的父类

public abstract class Animal{

//定义一个抽象的方法

public abstract void eat();

}

//定义子类

public class Cat extends Animal{

@Override

public void eat(){

System.out.println("猫吃鱼");

}

}

public class Dog extends Animal{

@Override

public void eat(){

System.out.println("啃骨头");

}

}

public class TestPolyDemo03 {

public static void main(String[] args) {

//根据不同的对象来表现不同的吃的内容

Cat c = new Cat();

//showCatEat(c);//猫吃鱼

Dog d = new Dog();

//showCatEat(dog);

showAnimalEat(c);

showAnimalEat(d);

}

/*public static void showCatEat(Cat cat){

cat.eat();

}

public static void showDogEat(Dog dog){

dog.eat();

}*/

/*

以上两个方法可以用多态进行简化 可以用showAnimalEat来替代

*/

public static void showAnimalEat(Animal animal){

animal.eat();

}

}

说明：由于多态特性的支持，showAnimalEat方法中的Animal类型，是Dog和Cat的父类类型，

父类类型接收子类对象，当然可以把cat对象和dog对象传递给方法.

当程序执行过程中.执行eat方法实际执行的是各自子类对象重写之后的eat方法

不仅仅可以做到替代，在扩展性方面，无论之后出现多个子类，都不用编写showXxxEat()方法了

直接使用showAnimalEat()方法了

好处：体现在 可以使程序编写更简单，并且具有良好的扩展性.

访问类中的成员变量有两种方式(多态前提)

1.直接通过对象名访问成员变量：看等号左边是谁，优先用谁，如果没有继续往上找

2.间接的通过成员方法访问成员变量：看该方法属于谁，优先用谁，如果没有继续往上找

//定义一个父类

public class Fu{

int num = 10;

//成员方法

public void showNum(){

System.out.println(num);

}

}

//子类

public class Zi extends Fu {

int num = 20;

@Override

public void showNum(){

System.out.println(num);

}

}

//测试类

public class TestPolyFieldDemo01 {

public static void main(String[] args){

//多态的表示形式

//父类类型 变量名 = new 子类对象；

//变量名.成员变量名

Fu fu = new Zi();

System.out.println(fu.num);

fu.showNum();//10  20

}

}

引用数据类型的转型

多态的转型：分为向上转型和向下转型两种情况：

向上转型：

向上转型：多态本身就是子类类型向父类类型 向上壮转型的过程，这个过程是默认的

当一个父类引用指向了一个子类对象时，便是向上转型.

使用格式:

父类类型 变量名 = new 子类类型();

比如Animal animal = new Cat();

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的：

一个已经向上转型的子类对象，将父类的引用又转为子类的引用，可以使用强制类型转换

使用格式：

子类类型 变量名 = (子类类型)父类变量名;

比如：Cat cat = (Cat) animal;

转型异常：

在进行向下转换的过程中，一不小心就会出现java.lang.ClassCastException类型转换异常

为了避免这种类型转换异常的发生，java就提供了 【instanceof】 关键字，给引用变量做类型的校验

格式如下：

变量名 instanceof 数据类型

如果变量属于该数据类型则返回true

如果变量不属于该数据类型则返回false

所以在转换前，我们最好先进行引用变量的类型判断，

代码如下：

public class Test{

public static void main(Stirng[] args){

//向上转形

Animal animal = new Cat();

//向下转型

if(animal instanceof Cat){

//表明你就是一只猫

Cat cat = (Cat)animal;

cat.eat();//吃鱼

cat.catchMouse();//逮老鼠

}else if(animal instanceof Dog){

//表名你就是一只狗

Dog dog = (Dog)animal;

dog.lookDoor();

}

}

}

实参与形参

main

int num = 10;//局部变量

TestPolymorphismDemo02.method(num)//指的是实参

public static void method(int num){int num 指的是形参

System.out.println(num);

}