java-interface

/*The Method selection algorithm *Consider the function call foo.bar(x1), where foo has static type TPrime, and has dynamic type T1 At compile time, the compiler verifies that TPrime has a method that can handle T1. It then records the signature of this method. *****Note: If there are multiple methods that can handle T1, the compiler records the "most specific" one. For example, if T1=Dog, and TPrime has bar(Dog) and bar(Animal), it will record bar(Dog); ***** At runtime, if foo's dynamic type overrides the recorded signature, use the overridden method. Otherwise, use TPrime's version of the method. * */ public interface Animal { default void greet(Animal a) { print("hello animal"); } default void sniff(Animal a) { print("sniff animal"); } default void flatter(Animal a) { print("u r cool animal"); } } public class Dog implements Animal { void sniff(Animal a) { print("dog sniff animal"); } void flatter(Dog a) { print("u r cool dog"); } } Animal a = new Dog(); Dog d = new Dog(); a.flatter(d); /*Compiler asks "Is there a method in Animal that can handle * Dog"? Yes! * flatter(Animal a) " * It then records the signature flatter(Animal a). * */ /*----------------------------- *Interface vs. Implementation Inheritance. * Interface Inheritance(what): * 1.1 Allows you to generalize code in a powerful, simple way. * *Implementation Inheritance(how): *Allowas code-reuse:Subclasses can rely on superclasses or interfaces. */

2. Interface and inherience. 

/*Method. Overriding vs. Overloading. * If a "subclass" has a method with the exact same signature * as int the "superclass", we say the subclass overrides the *the method. 1.Animal's subclass Pig overrides the makeNoise() method. 2.Methods with the same name but different signatures are overload. * */ /*If a subclass has a method with the exact same signature * as in the superclass, we say the subclass overrides the method. *1. Even if you don't write @Override, subclass still overrides the method. @Override is just an optional reminder that you are overriding. * *Why use @Override ? 1. Main reason: Protects against typos. 1.1 If you say @Override, but it the method isn't actually overriding anything, you'll get a compiler error. 1.2 public void addLats(Item x). 2. Reminds programmer that method definition came from somewhere higher up in the inheritance hierarchy. */ /*Interface Inheriance. * Specify the capabilities of a subclass using the implements * keyword is known as interface inheritance. * 1.1 Interface: The list of all method signatures. * 1.2 Inheritance: The subclass "inherits" the interface * from a superclass. * 1.3 Specifies what the subclass can do, but not how. * 1.4 Subclasses must override all of the these methods.! * will fail to compiler otherwise. */ /* Two seemingly contradictory facts: * #1. When you set x = y or pass a parameter, * you're just copying the bits. * #2. A memory box can only hold 64 bit addresses for the appropriate * type. * String x can never hold the 64 bit address of a Dog. * * Copying the Bits. * Answer: If X is a superclass of Y, then memory boxes * for X may contain Y, * 1. An AList is-a List. * 2. Therefore List variable can hold ALList addresses. * / /*Implementation Inheritance * Interface inheritance: * 1.1 Subclass inherits signature, but NOT implementaion. * * For better or worse, Java also allows implementaion inheritance. * --Subclasses can inherit signatures AND implementation. * *Use the default keyword to specify a method that subclasses should inherit from an interface. 1.1 Example: Let's add a default print() method to List61B.java. * */ public interface Animal { public void makeNoise(); } public class Pig implements Animal { public void makeNoise() { //override. System.out.print("oink"); } } public class Dog implements Animal { public void makeNoise(Dog x) { //overload. // .... } }

 

转载于:https://www.cnblogs.com/Shinered/p/10464167.html