O método padrão da interface java8
Qual é o método padrão e por que existe um método padrão?
Simplificando, a interface pode ter métodos de implementação e não há necessidade de implementar a classe para implementar seus métodos. Basta adicionar a palavra -chave padrão antes do nome do método.
Por que você precisa desse recurso? Primeiro de tudo, a interface anterior era uma faca de dois gumes. A vantagem era que ele visava a programação abstrata e não concreta. A desvantagem era que, quando era necessário modificar a interface, era necessário modificar todas as classes que implementaram a interface. A estrutura atual da coleção antes do Java 8 não tinha um método foreach. A solução que pode ser pensada é adicionar novos métodos e implementações às interfaces relacionadas no JDK. No entanto, para a versão publicada, é impossível adicionar novos métodos à interface sem afetar a implementação existente. Portanto, o método padrão introduzido. Seu objetivo é tornar a interface não introduzida incompatível com as implementações existentes.
Como mostrado abaixo,
interface pública Animal {padrão void eat () {System.out.println ("Método padrão de Animal Eat"); }} Uma interface é declarada e existe apenas um método padrão dentro. Em seguida, escreva uma classe específica para implementar esta interface.
public class Dog implementa Animal {public void Sayhi () {System.out.println ("Dog"); } public static void main (string args []) {cachorro cachorro = new Dog (); cachorro.eat (); }}Em uma classe específica, não é necessário substituir o método padrão, mas os métodos abstratos devem ser implementados.
Herança múltipla de métodos padrão
O código mostrado abaixo,
interface pública a {void Dosomething (); Void padrão hello () {System.out.println ("Hello World From Interface A"); } padrão void foo () {System.out.println ("Foo da interface A"); }} A interface B estende um {padrão void hello () {System.out.println ("Hello World da interface B"); A.super.Hello (); this.foo (); A.super.foo (); }} classe C implementa B, A {@Override public void Dosomething () {System.out.println ("C Objeto precisa fazer algo"); } public static void main (string args []) {a obj = new c (); obj.hello (); // chama o método de b obj.dosomething (); }}Resultado de impressão:
Olá mundo da interface Bhello World da interface Afoo da interface Afoo da interface Objeto AC precisa fazer algo
obj.hello () chama o método padrão na interface B. Ao mesmo tempo, o método padrão na interface B chama o método padrão na interface pai.
Vamos dar uma olhada em outro exemplo e pensar no método padrão com o mesmo nome em herança múltipla, como mostrado abaixo.
interface pública d {padrão void hello () {System.out.println ("Hello World from d"); }} interface E {padrão void hello () {System.out.println ("Hello World from E"); }} classe f implementos d, e {@Override public void hello () {System.out.println ("Hello World f class"); D.Super.Hello (); E.super.Hello (); } public static void main (string args []) {f f = new f (); F.Hello (); }} Precisamos formular o método padrão de qual interface chamar a seguinte:
D.Super.Hello (); E.super.Hello ();
Outro exemplo do método padrão de Java8 :
O Java8 adicionou um método padrão para a interface, o que significa que pode ser implementado na interface. Esse método de implementação é a implementação padrão e você também pode reescrever esse método padrão na classe de implementação da interface.
O exemplo a seguir:
public class AppInterFacedEfulMethod {interface estática pública DefaultMethodDemo {// Defina o método padrão, com a palavra -chave padrão precedida pelo método padrão, seguido pela declaração do método e pelo método do corpo padrão void de demonstração (entrada de string) {System.out.println (Inst); } void doSomething (); } classe estática pública Democlass implementa defaultMethodDemo {@Override public void Dosomething () {System.out.println ("Do Algo"); }} classe estática pública DemoclassoSoverRidedemo implementa defaultMethodDemo {// Reescreva o método padrão @Override public void Demo (String input) {System.out.println ("Demo" + Input + "por substituição do método"); } @Override public void Dosomething () {System.out.println ("Faça algo"); }} public static void main (string [] args) {defaultMethodDemo Demo = new Democlass (); Demo.Demo ("ABC"); DefaultMethodDemo Demooverride = new Democlassoverridedemo (); Demooverride.Demo ("ABC"); }}O exposto acima é uma introdução detalhada ao método padrão da interface Java8, e espero que seja útil para o aprendizado de todos.