精选Java中的多态和继承

在优锐课架构学习中,了解了关于用多态方法调用将你的大脑包围在Java方法调用周围

成都创新互联云计算的互联网服务提供商,拥有超过13年的服务器租用、托管服务器、云服务器、网络空间、网站系统开发经验,已先后获得国家工业和信息化部颁发的互联网数据中心业务许可证。专业提供云主机、网络空间、域名与空间、VPS主机、云服务器、香港云服务器、免备案服务器等。

根据传说中的Venkat Subramaniam,多态是面向对象编程中最重要的概念。 多态性(或对象根据其类型执行特殊操作的能力)使Java代码具有灵活性。 诸如 四个人帮 之类的设计模式(例如Command,Observer,Decorator,Strategy和许多其他模式)都使用某种形式的多态性。 精通此概念可极大地提高你思考解决编程难题的能力。

Juggy:
public abstract class JavaMascot {
    public abstract void executeAction();}public class Duke extends JavaMascot {
    @Override
    public void executeAction() {
        System.out.println("Punch!");
    }}public class Juggy extends JavaMascot {
    @Override
    public void executeAction() {
        System.out.println("Fly!");
    }}public class JavaMascotTest {
    public static void main(String... args) {
        JavaMascot dukeMascot = new Duke();
        JavaMascot juggyMascot = new Juggy();
        dukeMascot.executeAction();
        juggyMascot.executeAction();
    }}
 Punch!Fly!

多态性的接口和继承
借助此Java Challenger,我们将致力于多态性与继承之间的关系。 要记住的主要事情是多态性需要继承或接口实现。 你可以在下面的示例中看到这一点,其中包括Duke和
由于其特定的实现方式,Duke和Juggy的动作都将被执行。

方法是否重载了多态性?
许多程序员对多态与方法重写和方法重载之间的关系感到困惑。 实际上,只有方法重载才是真正的多态性。 重载使用相同的方法名称,但参数不同。 多态性是一个广义术语,因此始终会有关于该主题的讨论。

多态性的目的是什么?
使用多态的最大优点和目的是将客户端类与实现代码分离。 客户端类无需进行硬编码,而是接收实现以执行必要的操作。 这样,客户端类就足够了解执行其动作的知识,这是松耦合的示例。

为了更好地了解多态的目的,请看一下

public abstract class SweetProducer {
    public abstract void produceSweet();}public class CakeProducer extends SweetProducer {
    @Override
    public void produceSweet() {
        System.out.println("Cake produced");
    }}public class ChocolateProducer extends SweetProducer {
    @Override
    public void produceSweet() {
        System.out.println("Chocolate produced");
    }}public class CookieProducer extends SweetProducer {
    @Override
    public void produceSweet() {
        System.out.println("Cookie produced");
    }}public class SweetCreator {
    private List sweetProducer;
    public SweetCreator(List sweetProducer) {
        this.sweetProducer = sweetProducer;
    }
    public void createSweets() {
        sweetProducer.forEach(sweet -> sweet.produceSweet());
    }}public class SweetCreatorTest {
    public static void main(String... args) {
        SweetCreator sweetCreator = new SweetCreator(Arrays.asList(new CakeProducer(),
                new ChocolateProducer(), new CookieProducer()));
        sweetCreator.createSweets();
    }}

在此示例中,你可以看到SweetCreator类仅知道SweetProducer类。 它不知道每个甜食的实现。 这种分离使我们可以灵活地更新和重用我们的类,并使代码易于维护。 设计代码时,请始终寻找使代码尽可能灵活和可维护的方法。 多态性是用于这些目的的一种非常强大的技术。

提示:@Override注释使程序员有义务使用必须重写的相同方法签名。 如果未重写该方法,则将出现编译错误。
方法覆盖中的协变返回类型

如果它是协变类型,则可以更改覆盖方法的返回类型。 协变量类型基本上是返回类型的子类。 考虑一个例子:

public abstract class JavaMascot {
    abstract JavaMascot getMascot();}public class Duke extends JavaMascot {
    @Override
    Duke getMascot() {
        return new Duke();
    }}

由于Duke是JavaMascot,因此我们可以在覆盖时更改返回类型。

Java核心类的多态性
我们一直在核心Java类中使用多态。 一个非常简单的示例是当我们实例化ArrayList类时,将List接口声明为一种类型:

List list = new ArrayList<>();

为了进一步讲解,请考虑使用Java Collections API且无多态性的以下代码示例:

public class ListActionWithoutPolymorphism {
   // Example without polymorphism
    void executeVectorActions(Vector vector) {/* Code repetition here*/}
    void executeArrayListActions(ArrayList arrayList) {/*Code repetition here*/}
    void executeLinkedListActions(LinkedList linkedList) {/* Code repetition here*/}
    void executeCopyOnWriteArrayListActions(CopyOnWriteArrayList copyOnWriteArrayList)
        { /* Code repetition here*/}}public class ListActionInvokerWithoutPolymorphism {
        listAction.executeVectorActions(new Vector<>());
        listAction.executeArrayListActions(new ArrayList<>());
        listAction.executeLinkedListActions(new LinkedList<>());
        listAction.executeCopyOnWriteArrayListActions(new CopyOnWriteArrayList<>());}

丑陋的代码,不是吗? 想象一下要维护它! 现在来看具有多态性的相同示例

public static void main(String … polymorphism) {ListAction listAction = new ListAction();   
    listAction.executeListActions();}public class ListAction {
    void executeListActions(List list) {
        // Execute actions with different lists
    }}public class ListActionInvoker {
    public static void main(String... masterPolymorphism) {
        ListAction listAction = new ListAction();
        listAction.executeListActions(new Vector<>());
        listAction.executeListActions(new ArrayList<>());
        listAction.executeListActions(new LinkedList<>());
        listAction.executeListActions(new CopyOnWriteArrayList<>());
    }}

多态性的好处是灵活性和可扩展性。 除了创建几种不同的方法外,我们可以只声明一个接收通用List类型的方法。

在多态方法调用中调用特定方法
可以在多态调用中调用特定的方法,但是这样做会牺牲灵活性。 这是一个例子:

public abstract class MetalGearCharacter {
    abstract void useWeapon(String weapon);}public class BigBoss extends MetalGearCharacter {
    @Override
    void useWeapon(String weapon) {
        System.out.println("Big Boss is using a " + weapon);
    }
   void giveOrderToTheArmy(String orderMessage) {
        System.out.println(orderMessage);
    }}public class SolidSnake extends MetalGearCharacter {
    void useWeapon(String weapon) {
        System.out.println("Solid Snake is using a " + weapon);
    }}public class UseSpecificMethod {
    public static void executeActionWith(MetalGearCharacter metalGearCharacter) {
        metalGearCharacter.useWeapon("SOCOM");
    // The below line wouldn't work
        // metalGearCharacter.giveOrderToTheArmy("Attack!");
        if (metalGearCharacter instanceof BigBoss) {
            ((BigBoss) metalGearCharacter).giveOrderToTheArmy("Attack!");
        }
    }public static void main(String... specificPolymorphismInvocation) {
        executeActionWith(new SolidSnake());
        executeActionWith(new BigBoss());
    }}

我们在这里使用的技术是广播或在运行时故意更改对象类型。
请注意,只有在将通用类型转换为特定类型时才可以调用特定方法。 一个很好的类比是对编译器明确地说:“嘿,我知道我在这里做什么,所以我将对象转换为特定类型并使用特定方法。”

参考上面的示例,一个重要原因是编译器拒绝接受特定的方法调用:正在传递的类可能是SolidSnake。 在这种情况下,编译器无法确保MetalGearCharacter的每个子类都声明了giveOrderToTheArmy方法。

保留关键字的实例
请注意实例化的保留字。 在调用特定方法之前,我们询问了MetalGearCharacter是否为BigBoss的“实例”。 如果不是BigBoss实例,我们将收到以下异常消息:

线程“主”中的异常java.lang.ClassCastException:com.javaworld.javachallengers.polymorphism.specificinvocation.SolidSnake无法转换为com.javaworld.javachallengers.polymorphism.specificinvocation.BigBoss

超级保留关键字
如果我们想引用Java超类的属性或方法怎么办? 在这种情况下,我们可以使用超级保留字。 例如:

public class JavaMascot {
  void executeAction() {
    System.out.println("The Java Mascot is about to execute an action!");
  }}public class Duke extends JavaMascot {
  @Override
  void executeAction() {
    super.executeAction();
    System.out.println("Duke is going to punch!");
  }
  public static void main(String... superReservedWord) {
    new Duke().executeAction();
  }}

在Duke的executeAction方法中使用保留字super调用超类方法。 然后我们从杜克(Duke)执行特定操作。 因此,我们可以在下面的输出中看到两条消息:

Java Mascot即将执行一个动作!Duke要出拳了!

接受多态挑战!
让我们尝试一下你对多态性和继承的了解。首先,请仔细分析以下代码:

public class PolymorphismChallenge {
    static abstract class Simpson {
        void talk() {
            System.out.println("Simpson!");
        }
        protected void prank(String prank) {
            System.out.println(prank);
        }
    }
    static class Bart extends Simpson {
        String prank;
        Bart(String prank) { this.prank = prank; }
        protected void talk() {
            System.out.println("Eat my shorts!");
        }
        protected void prank() {
            super.prank(prank);
            System.out.println("Knock Homer down");
        }
    }
    static class Lisa extends Simpson {
        void talk(String toMe) {
            System.out.println("I love Sax!");
        }
    }
    public static void main(String... doYourBest) {
        new Lisa().talk("Sax :)");
        Simpson simpson = new Bart("D'oh");
        simpson.talk();
        Lisa lisa = new Lisa();
        lisa.talk();
        ((Bart) simpson).prank();
    }}

你怎么看? 最终输出将是什么? 不要使用IDE来解决这个问题! 关键是要提高代码分析技能,因此请尝试自己确定输出。

了解多态
对于以下方法调用:

new Lisa().talk("Sax :)");

输出为“ I love Sax!”,这是因为我们正在向该方法传递字符串,而Lisa具有该方法。
对于下一个调用:

Simpson simpson = new Bart("D'oh");
simpson.talk();

输出将是“Eat my shorts!” 这是因为我们正在使用Bart实例化Simpson类型。
现在检查一下,这有点棘手:

Lisa lisa = new Lisa();
lisa.talk();

在这里,我们使用带有继承的方法重载。 我们没有将任何内容传递给talk方法,这就是调用Simpsontalk方法的原因。 在这种情况下,输出将是:

"Simpson!"

这里还有一个:

((Bart) simpson).prank();

在这种情况下,当我们使用new Bart(“ D'oh”);实例化Bart类时,会传递恶作剧字符串。 在这种情况下,首先将调用super.prank方法,然后是来自Bart的特定恶作剧方法。 输出将是:

"D'oh""Knock Homer down"

视频挑战! 调试Java多态性和继承

调试是完全吸收编程概念并改善代码的最简单方法之一。 在此视频中,你可以在调试和解释Java多态性挑战时继续学习:

多态性的常见错误
认为无需使用强制转换就可以调用特定方法是一个常见的错误。

另一个错误是不确定多态实例化类时将调用哪种方法。 请记住,要调用的方法是创建的实例的方法。
还要记住,方法重载不是方法重载。

如果参数不同,则无法覆盖方法。 如果返回类型是超类方法的子类,则可以更改重写方法的返回类型。

喜欢这篇文章的可以点个赞,欢迎大家留言评论,记得关注我,每天持续更新技术干货、职场趣事、海量面试资料等等
 > 如果你对java技术很感兴趣也可以交流学习,共同学习进步。 
不要再用"没有时间“来掩饰自己思想上的懒惰!趁年轻,使劲拼,给未来的自己一个交代

文章写道这里,欢迎完善交流。最后奉上近期整理出来的一套完整的java架构思维导图,分享给大家对照知识点参考学习。有更多JVM、MySQL、Tomcat、Spring Boot、Spring Cloud、Zookeeper、Kafka、RabbitMQ、RockerMQ、redis、ELK、Git等Java干货

关于多态性要记住什么
创建的实例将确定使用多态时将调用哪种方法。
@ Override注释使程序员有义务使用覆盖的方法; 否则,将出现编译器错误。
多态可以与普通类,抽象类和接口一起使用。
大多数设计模式取决于某种形式的多态性。
在多态子类中使用特定方法的唯一方法是使用强制转换。
可以使用多态性在代码中设计功能强大的结构。
运行测试。 这样做,你将能够掌握这个强大的概念!

精选Java中的多态和继承


网页题目:精选Java中的多态和继承
URL分享:http://scyanting.com/article/pddhsp.html