Java总结 多态和实现方法

• 什么是多态？

概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。

简单的说：就是用基类的引用指向子类的对象。

举个例子：

电脑上的F1按键，当不打开任何文件点击F!显示的是系统的帮助文档，当打开word文档点击F1显示的是word文档的帮助，同一个按钮但是能实现不同的处理方式。

• 为什么要用多态？

我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了代码重用。

而多态除了代码的复用性外，还可以解决项目中紧偶合的问题,提高程序的可扩展性.。

如果项目耦合度很高的情况下，维护代码时修改一个地方会牵连到很多地方，会无休止的增加开发成本，降低耦合度可以保证

程序的拓展性。

可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

• 开发中在什么地方用多态，怎么实现的多态？

接口实现、抽象类、继承父类进行方法重写、同一个类中进行方法重载。

• 接口：辐射拓展，如果接口中新增加了方法，则需要修改所有实现此接口的实现方法。

1. 接口中的变量会被隐式地指定为public static final变量。
2. 接口中的方法都是抽象方法。
3. 一个类可继承多个接口。
4. 实现接口需实现接口中的所有方法。

public interface InterDemo(){
    void setData();
    int getCount();
}

public class InterImpl implements InterDemo(){
    
    @Override
    public void setData(){
        //....
    }
    
    @Override
    public void getCount(){
        //....
    }
}

• 抽象类 : 延伸拓展，如果在抽象类中增加方法，底层所有继承此类的子类都不需要修改，如果需调用，则直接调用父类方法即可。

       抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象，所以抽象类一个是在           项目开始就得确定好的公共类。

interface FlyInter {
    void fly();
}

public abstract class FlyGroups implements FlyInter{
    public String name = "飞行类";
    public String getName(){
        return name;
    }
    abstract void fun();
}


public class Airplane extends FlyGroups {
    @Override
    public void fly() {
        String name = super.getName();
        System.out.println(name);
    }
    @Override
    public void fun(){
    }
}

• 继承父类进行方法重写

       纵向拓展，子类可以重写父类的方法进行拓展

public class Parent{

    public void fun(){
    }
}

public class Child extends Parent{
    @Override
    public void fun(){
        //子类的重写
    }
}

• 同一个类中进行方法重载

       横向拓展，方法的重写需参数不同、参数个数不同、返回值不同。

public void init(String name,int i){
        
}
    
public void init(int i,String name){
        
}
    
public void init(){
        
}
    
public int init(){
        
}

• 延伸    静态绑定和动态绑定

JVM方法调用的静态(static binding) 和动态绑定机制(auto binding) 

• 动态绑定  

     下面代码有三个概念多态 、方法覆盖 、方法重载。

      这种在程序运行过程中，通过动态创建的对象的方法表来定位方法的方式，我们叫做 动态绑定机制 也是多态的体现。

//被调用的父类  
class Father{  
    public void f1(){  
        System.out.println("father-f1()");  
    }  
        public void f1(int i){  
                System.out.println("father-f1()  para-int "+i);  
        }  
}  
//被调用的子类  
class Son extends Father{  
    public void f1(){ //覆盖父类的方法  
        System.out.println("Son-f1()");  
    }  
        public void f1(char c){  
                System.out.println("Son-s1() para-char "+c);  
        }  
}  
  


public class AutoCall{  
    public static void main(String[] args){  
        Father father=new Son(); //多态  
        father.f1(); //打印结果： Son-f1()  
    }  
} 

 

• 静态绑定

       在编译阶段就能够确定调用哪个方法的方式，我们叫做 静态绑定机制，new 类调用方法就是静态绑定。