多态其实挺好理解的就是一种薛定谔的参数,他的本质是父类可以引用子类的参数来达到一种多形态的样子,举个例子
package com.polymorphism;
public class Animal
{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Cat extends Animal
{
private String name;
public Cat(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Dog extends Animal
{
private String name;
public Dog(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.polymorphism;
public class Food {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Fish extends Food
{
private String name;
public Fish(String name) {
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
}
class Bones extends Food
{
private String name;
public Bones(String name) {
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
}
package com.polymorphism;
public class Master {
private String name;
public Master(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String feed(Animal animal, Food food)
{
return "主人"+getName()+"给"+animal.getName()+"喂"+food.getName();
}
}
package com.polymorphism;
public class poly01 {
public static void main(String[] args)
{
Dog dog = new Dog("大黄");
Bones bones = new Bones("猪骨");
Cat cat = new Cat("小狗");
Fish fish = new Fish("大鲤鱼");
Master master = new Master("离不开");
Pig pig = new Pig("佩奇");
Rice rice = new Rice("东北大米");
System.out.println(master.feed(dog,bones));
System.out.println("======================");
System.out.println(master.feed(cat,fish));
System.out.println("======================");
System.out.println(master.feed(pig,rice));
注意我这里时传的是父类,但这个方法会随着我传入参数调不同的值给出不同效果,这就是多态。
多态的类型
还有向上转型(对子类来说)和向下转型(从向上转回到向下)我不是很明白——为什么不直接new呢?
向上转型前提是有继承关系的
父类的引用指向了子类的运行类型,可以调子类的重写方法,但能调特有的方法,你想呀,我在创建一个鸟对象,写一个特有的飞行,你觉的多态能调用吗?我不可能说传个dog,来调用飞行吧?这非常不合理。
向下转型时子类 xx = (子类)父类引用,其实这些都是看的右边的类型升高还是降低,
注意的点
一—只能改父类引用的地址,里面的对象是改不了的,就相当于你只能改变他家门牌号,但是你无法是他们的水晶爆炸呀,
二-向下转型你只能时他只能你转为合适类,就像你String无法变成int类那是一样的,这下面的先向上转的animal他的运行本质时一直毛,现在我使他转成狗,肯定使不合适的,但是这个错误只有在运行使才会说calss ex
package com.Debug;
public class Text {
public static void main(String[] args)
{
Animal animal = new Cat();
System.out.println(animal.name);//out animal
animal.run();//
// animal.sayspring();报错了
Cat cat = (Cat)animal;
System.out.println(cat.name);//cat
cat.sayspring();
Dog dog = (Dog)animal;
}
}
class Animal
{
public String name = "animal";
public void run()
{
System.out.println("animal is running");
}
}
class Cat extends Animal
{
public String name = "cat";
public void run()
{
System.out.println("cat is running");
}
public void sayspring()
{
System.out.println("cat is fXXk");
}
}
class Dog extends Animal
{
private String name ="dog";
public void run()
{
System.out.println("dog is running");
}
public void eatbonus()
{
System.out.println("dog is eating bonus");
}
}
三—向下转型后,属于回归本质当然你可以使用他的所有,你如果创建一个父类,强行把他转为子类也会报错,所有向上转完向下转。
动态绑定机制就是当(多态的前提下)调用对象是,编译类型左边看属性,运行类型看右边及方法,他的意思是只要运行类型有的方法,你在后面调用时一定调的是运行类型的方法,属性你就不可以那么理解,哪里声明哪里用
举个例子
package com.kaige;
public class Sum {
int i = 10;
public int get()
{
return get1();//请问这个get1是谁;
}
public int get1()
{
return i+20;
}
}
class Sum1 extends Sum
{
int i = 100;
/* public int get()//如果我把get删去,他就会找父类的get
{
return i+10;
}*/
public int get1()
{
return i+20;
}
}
package com.kaige;
public class Text
{
public static void main(String[] args)
{
Sum1 sum1 = new Sum1();
System.out.println(sum1.get());
System.out.println(sum1.get1());
}
}
如果我不注销掉get方法所有人都会知道他调用的是sum1的方法,答案使
110
120
但是现在我调用了父类的get方法,它里面的get1方法是谁的呢?
答案就是还是子类的get方法因为,动态绑定机制——当调用对象方法使就会发生绑定,如果使对象有的,哪怕父类有重写的方法也会调对象。课属性就是那里声明哪里用。
多态的应用
简单来说就是创建父类数组,然后根据你的需求来确定你要哪种子类,要父类也行
应用就是看我的idea里的polyarr,会用就行,不过初始化会麻烦一点点,也没啥好注意的。
我们常用instanceof来判断两个类的关系
具体用法如下
persons[k] instanceof Person;//会用就行
多态参数就是前面说的薛定谔的参数,跟第一个例子差不多。