Is er een manier om NIETalle methoden van een interface in een overervende klasse te implementeren?
Antwoord 1, autoriteit 100%
De enige manier om dit te omzeilen is om je klasse als abstractte declareren en het aan een subklasse over te laten om de ontbrekende methoden te implementeren. Maar uiteindelijk moet iemand in de keten het implementeren om aan het interfacecontract te voldoen. Als je een bepaalde methode echt niet nodig hebt, kun je deze implementeren en vervolgens returnof een variant van NotImplementedExceptiongebruiken, afhankelijk van wat in jouw geval het meest geschikt is.
De interface kan ook sommige methoden specificeren als ‘default’ en de bijbehorende methode-implementatie bieden binnen de interfacedefinitie (https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html). Deze ‘standaard’ methoden hoeven niet te worden vermeld bij het implementeren van de interface.
Antwoord 2, autoriteit 97%
Het punt van een interface is om te garanderen dat een object zich uiterlijk gedraagt zoals de interface aangeeft dat het zal
Als je niet alle methoden van je interface implementeert, vernietig je het hele doel van een interface.
Antwoord 3, autoriteit 24%
We kunnen alle interfacemethoden in de abstractbovenliggende klasse overschrijven en in de onderliggende klasse alleen die methoden overschrijven die vereist zijn door die specifieke onderliggende klasse.
Interface
public interface MyInterface{
void method1();
void method2();
void method3();
}
Abstracte ouderklas
public abstract class Parent implements MyInterface{
@Override
public void method1(){
}
@Override
public void method2(){
}
@Override
public void method3(){
}
}
In de klassen van uw kind
public class Child1 extends Parent{
@Override
public void method1(){
}
}
public class Child2 extends Parent{
@Override
public void method2(){
}
}
Antwoord 4, autoriteit 7%
Ik stelde mezelf dezelfde vraag en leerde toen over Adapters. Het loste mijn probleem op, misschien kan het het jouwe oplossen. Dit legt het heel goed uit: https://blogs.oracle.com/CoreJavaTechTips/entry/listeners_vs_adapters
Antwoord 5, autoriteit 6%
Definieer die klasse als een abstractklasse. U moet deze niet-geïmplementeerde methoden echter implementeren wanneer u er een instantie van wilt maken (door een subklasse of een anonieme klasse te gebruiken).
Antwoord 6, autoriteit 6%
Het is mogelijk en het is gemakkelijk. Ik heb een voorbeeldgecodeerd.
Het enige wat je hoeft te doen is erven van een klasse die de methode wel implementeert. Als je het niet erg vindt dat een klas niet instantieerbaar is, kun je ook een abstract-klasse definiëren.
Antwoord 7, autoriteit 6%
Dat kan in Java8. Java 8 introduceert “Standaardmethode” of (Defender-methoden) nieuwe functie, waarmee een ontwikkelaar nieuwe methoden aan de interfaces kan toevoegen zonder de bestaande implementatie van deze interfaces te onderbreken.
Het biedt flexibiliteit om de interface-implementatie te laten definiëren die als standaard zal worden gebruikt in de situatie waarin een concrete klasse er niet in slaagt om een implementatie voor die methode te bieden.
interface OldInterface {
public void existingMethod();
default public void DefaultMethod() {
System.out.println("New default method" + " is added in interface");
}
}
//following class compiles successfully in JDK 8
public class ClassImpl implements OldInterface {
@Override
public void existingMethod() {
System.out.println("normal method");
}
public static void main(String[] args) {
ClassImpl obj = new ClassImpl ();
// print “New default method add in interface”
obj.DefaultMethod();
}
}
Antwoord 8, autoriteit 4%
Als je een instantieerbare klasse wilt, is dat niet mogelijk. U kunt echter proberen een abstract-klasse te definiëren.
Antwoord 9
Als je een interface probeert te implementeren en je bevindt je in een situatie waarin het niet nodig is om ze allemaal te implementeren, dan is dit een codegeur. Het duidt op een slecht ontwerp en het is in strijd met het Liskov-substitutieprincipe. Vaak gebeurt dit vanwege het gebruik van een vette interface.
Soms gebeurt dit ook omdat u een interface probeert te implementeren vanuit een externe afhankelijkheid. In dit geval kijk ik altijd in de broncode om te zien of er een implementatie van die interface is die ik rechtstreeks kan gebruiken of die ik kan subclasseren en methoden kan overschrijven naar mijn behoeften.
Antwoord 10
We kunnen Adapter-klassen gebruiken, wat de complexiteit vermindert door niet verplicht te stellen alle methoden in de interface te implementeren
Adapterklasse is een eenvoudige Java-klasse die een interface implementeert met alleen een EMPTY-implementatie.
In plaats van een interface te implementeren als we de Adapter-klasse uitbreiden, bieden we alleen implementatie voor de vereiste methode
ex— in plaats van Servlet(I) te implementeren als we GenericServlet(AC) uitbreiden, bieden we implementatie voor de Service()methode. We zijn niet verplicht om implementatie te bieden voor de resterende methode..
Generieke klasse Fungeert als ADAPTER-klasse voor Servlet(I).
Antwoord 11
ja mogelijk hieronder getoond is de manier
interface Test {
void m() throws NullPointerException;
}
class Parent {
// Parent class doesn't implements Test interface
public void m() {
System.out.println("Inside Parent m()");
}
}
class Child extends Parent implements Test {
}
public class Program {
public static void main(String args[]) {
Child s = new Child();
s.m();
}
}