乐清建网站哪家好建e网室内设计网模型楼梯

一 多态的概念

多态：就是一个事物的多种形态，这是建立在继承之下才有的概念，在Java中就是调用对象，不同的对象有不同的表示形态

多态的实现条件
1.在继承关系之下
2.子类重写父类中的方法
3.通过父类来调用被重写的方法

例如狗和猫都是动物，但是狗吃的是骨头 ，而猫吃的是小鱼干

class Animal {//父类public String name;int age;//父类构造方法public Animal(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"吃饭");}
}
class Cat extends Animal{public Cat(String name, int age) {super(name, age);//先要访问父类的构造方法}//重写父类的eat方法@Overridepublic void eat() {System.out.println(name+"吃小鱼干");}
}
class Dog extends Animal{public Dog(String name,int age){super(name,age);}//重写父类的eat方法@Override//注解public void eat(){System.out.println(name+"吃骨头");}
}
public class Test {public static void func(Animal animal){animal.eat();public static void main(String[] args) {//向上转型Animal animal = new Dog("旺财",1);Animal animal1 = new Cat("sansan",2);func(animal);func(animal1);}
}

运行结果如下

这里有父类Animal和子类Cat和Dog,这里通过父类创建对象，通过父类访问eat方法，但是访问的并不是父类中的方法，而是对应子类的方法，这就是多态

多态是在重写、向下转型和向上转型之下完成

二 重写

重写的概念

重写：简单来说就是子类对父类的方法进行重写，这里的重写参数列表相同，返回值可以相同和不同，不相同的话要有父子关系，和父类中被重写的方法的框架不变，里面的内容改变

重写规则
1.二者之间有继承关系，⼦类在重写⽗类的⽅法时，子类中方法返回值、参数列表、方法名称一样，返回类型⼀般必须与⽗类⽅法原型⼀致，返回类型可以不同，如果不同，返回值要有构造父子关系
2.子类中方法的访问权限高于或等于父类
访问权限：private < 默认 < protected < public
3.⽗类被static、private修饰的⽅法、构造⽅法都不能被重写
4.在重写的时候通常加上@Override注解不仅表示这里是重写，而且写了这个编译器会帮我们检验是否有重写语法错误，提高代码的语法准确性

class Animal {//父类public String name;int age;//父类构造方法public Animal(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"吃饭");}
}
class Cat extends Animal{public Cat(String name, int age) {super(name, age);//先要访问父类的构造方法}//重写父类的eat方法@Overridepublic void eat() {System.out.println(name+"吃小鱼干");}
}
class Dog extends Animal{public Dog(String name,int age){super(name,age);}//重写父类的eat方法@Override//注解public void eat(){System.out.println(name+"吃骨头");}
}

这里的Cat和Dog子类继承父类Animal，并且这里和父类都有一个eat成员方法，子类和父类的成员方法名称一样，参数列表也相同，返回类型也相同

重写与重构的区别

重构的话只是对参数列表要求不同，其他无太大要求，而重写的话，除了参数列表要求相同，其他也有要求
重构是类的多态的表现，而重写是父类和子类之间类多态的表现

运行时区别：
动态绑定(早绑定)：就是在编译时候，就根据用户传参确定调用具体的那个方法，这里的重构就是动态绑定
静态绑定(晚绑定)：就是在编译时候无法确定调用那个方法，运行的时候才知道调用那个方法,这里的重写就是静态绑定

三 向下转型和向上转型

向上转型

向上转型：就是实例化一个子类对象用父类来接收
可以运用到直接赋值、方法传参、返回类型

⽗类类型 对象名 = new ⼦类类型();

以上面的例子举例

//向上转型Animal animal = new Dog("旺财",1);Animal animal1 = new Cat("sansan",2);

这里就相当于使用小类型Dog和Cat子类的赋值给一个大类型Animal父类

那如何使用呢

class Animal {//父类public String name;int age;//父类构造方法public Animal(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"吃饭");}
}
class Cat extends Animal{public Cat(String name, int age) {super(name, age);//先要访问父类的构造方法}//重写父类的eat方法@Overridepublic void eat() {System.out.println(name+"吃小鱼干");}public void mew(){System.out.println("喵喵叫");}
}
class Dog extends Animal{public Dog(String name,int age){super(name,age);}//重写父类的eat方法@Override//注解public void eat(){System.out.println(name+"吃骨头");}public void bark(){System.out.println("汪汪叫");}
}
public class Test {
//传参时候向上转型public static void func(Animal animal){animal.eat();}public static void main(String[] args) {//直接赋值向上转型Animal animal = new Dog("旺财",1);Animal animal1 = new Cat("sansan",2);func(animal);//调用子类Dog的方法func(animal1);//调用子类Cat的方法}
}

运行结果如下

我们这里实例化的是子类对象，使用父类来接收的，并且在传参的时候形参也是用父类Animal来接收实参，那为什么这里是调用子类的方法，而不是父类的呢
是因为这里的重写是运行时绑定，这是的eat方法被重写了，所以调用子类的，如果子类没有重写就调用父类的方法，这样就可以只用一个方法可以调用子类重写父类的方法

那我们可以调用子类中特有的方法吗(调用父类中没有的方法）

从这里发现，这并不能找到子类中特有的方法，因为这里的类型时父类，向上转型的子类中不可以找子类中特有的方法
向上转型的缺点：不可以访问子类特有的方法

那如何解决这个缺陷呢，这时候就需要使用向下转型

向下转型

向下转型：由于上面的向上转型导致子类中的特有方法不可以被访问，这时候需要将父类引用还原成子类类型，这就是向下访问

我们结合上面的Animal Cat和Dog类

public class Test {public static void main(String[] args) {//向上转型Animal animal = new Dog("旺财",1);Animal animal1 = new Cat("sansan",2);//向下转型animal = (Dog)animal;animal1 = (Cat)animal1;//这里向下((Dog) animal).bark();((Cat) animal1).mew();}
}

运行结果如下

这样我们就可以访问子类中特有的方法了，这里要注意的是原本是Dog子类就返回Dog类型，不可以返回成Cat类，这肯定是不行的，可以发现这里的向下转型是有点不安全的，这就要引出instanceof 这个Java提供的关键字，如果需要向下转型使用这个
还是以上面的Animal、Cat、Dog类举例

public class Test {public static void func(Animal animal) {animal.eat();//animal.bark;//这是错误的//可以通过向下转型访问子类特有方法//如果为真进入向下转型访问if (animal instanceof Dog) {Dog dog = (Dog) animal;dog.bark();}if (animal instanceof Cat) {Cat cat = (Cat) animal;cat.mew();}}public static void main(String[] args) {//向上转型Animal animal = new Dog("旺财",1);Animal animal1 = new Cat("sansan",2);func(animal);func(animal1);}
}

四 多态的优缺点

优点

能够降低代码的"圈复杂度",避免使⽤⼤量的循环的语句
圈复杂度就是一段代码本身上并不难，但是这里如果里面有很多的分支和循环，这就让人感觉比较复杂
如果一段代码仅仅简单粗暴的使用条件语句和循环语句的话，这就导致圈复杂度就会太高，这时候就要想到重构

例如：

class Shape {public void draw(){System.out.println("画图形");}
}
class Tra extends Shape{@Overridepublic void draw(){System.out.println("画一个三角形");}
}
class Flower extends Shape{@Overridepublic void draw(){System.out.println("画一朵花");}
}
class Cycle extends Shape{@Overridepublic void draw(){System.out.println("画一个圆");}
}
public class Test {public static void main(String[] args) {Flower flower = new Flower();Tra tra = new Tra();Cycle cycle = new Cycle();//创建一个String类型数组，来进行存放打印String[] shapes = {"flower","tra","flower","tra","cycle"};//for_each进行这里的String数组的元素进行访问for (String shape :shapes) {if(shape.equals("flower")){flower.draw();}else if(shape.equals("cycle")){cycle.draw();}else if(shape.equals("tra")){tra.draw();}}}
}

这里我们呢是创建一个String数组，如果打印什么就进入那个对象的打印，使用equals来判断两个字符串是否相同

运行结果如下

可以看出上面的打印图案的代码有if-else语句好多，如果打印更多图形就还会有更多
这时候就要想到多态的思想

public class Test {public static void main(String[] args) {Tra tra = new Tra();Flower flower = new Flower();Cycle cycle = new Cycle();//向上转型Shape[] shapes = {flower,tra,flower,tra,cycle};for (Shape shape:shapes) {shape.draw();}}
}

这里是创建一个父类类型的数组，来存放子类对象，这里存在向上转型，这样使用for - each循环来便利整个数组，来进行进入对应子类方法

运行结果如下

使用多态可扩展展性也比较强，如果这里想打印一个新的图形，只需要继承Shape父类，在对其方法重写，在main方法中父类类型数组加上就行，这很简单，但是如果还是使用if - else语句，就变得复杂了

缺点

主要缺点就是在构造方法中访问 被重写的方法

class A{//父类的构造方法public A(){//触发动态绑定//访问的是子类的func方法func();}public void func(){System.out.println("A的func方法");}
}class B extends A{public int a = 10;//重写父类的方法@Overridepublic void func() {System.out.println("B的func方法 "+ a);}
}
public class Test {public static void main(String[] args) {B b = new B();}
}

运行结果如下

可以看出这里进入的是子类的func方法，但是这里的a为什么还是默认初始化呢，这就出现了顺序问题
1.这里实例化了一个子类对象B，父类有默认参数的构造方法，子类也会默认生成一个不带参数的构造方法
2.这里我们实例化后，就会先访问父类的构造方法
3.父类A的构造方法又访问这里被重写的func方法，所以访问的是子类B中func方法，但是之前这里并没有经历初始化a,直接经过父类进入方法，所以这里的a为0

使用时要注意：

要保证每个对象都可以简单的构造成功，因此尽量不要在构造方法中调用其他方法，尤其是被重写的方法，因为构造方法优先执行，构造方法访问一个方法，如果这个方法被重写了，发生动态绑定访问子类的方法，但此时的子类重写方法并没有构造完成就被使用了

到这里就结束了，希望对大家有所帮助，预知后事如何，请听下回分解