Abstrakte Klasse und Interface in Java
View more Tutorials:
In dieser Unterlagen gebe ich die Hinweise über Interface und Abstract Class. Gleichzeigt analysiere ich die Gleichheit und Unterschied von ihnen
Abstract class, Sehen Sie ein Beispiel über derselbe class
// Das ist eine abstrakte Klasse .
// Es muss zwanghaft als abstract verzollen
// denn sie hat eine abstrakte Methode
public abstract class ClassA {
// Das ist eine abstrakte Methode. Sie hat keinen Körper
// Access modifier dieser Methode ist public.
public abstract void doSomething();
// Access modifier dieser Methode ist protected.
protected abstract String doNothing();
// Die Methode erklärt access modifier nicht.
// Ihre Access modifier ist Default.
abstract void todo() ;
}
// Das ist eine abstrakte Klasse. Sie wird abstract verzollt
// obwohl sie keine abstrakte Methode hat
public abstract class ClassB {
}
Die Eigenschaften von Abstrakt Class sind:
- Es wird abstract.gemeldet
- Es wird 0, 1 oder viele abstrakt method darin gemeldet.
- es kann nicht ein Instance aus abstrakt class zu erstellen sein
Sehen Sie Beispiel
AbstractJob.java
package org.o7planning.tutorial.abs;
// Eine abstrakte Klasse (eine Arbeit simulieren)
// Sie verzollt 2 abstrakte Methode.
public abstract class AbstractJob {
public AbstractJob() {
}
// Das ist eine abstrakte Methode.
// Diese Methode gibt den Name der Arbeit zurück.
public abstract String getJobName();
// Das ist eine abstrakte Methode
public abstract void doJob();
}
JavaCoding.java
package org.o7planning.tutorial.abs;
// Diese Klasse führt die abstrakten Methode der Vaterklasse durch.
public class JavaCoding extends AbstractJob {
public JavaCoding() {
}
// Die abstrakte Methode, die bei der Vaterklasse erklärt werden, durchführen
@Override
public void doJob() {
System.out.println("Coding Java...");
}
// Die Durchführung der abstrakten Methode, die bei der Vaterklasse erklärt werden.
// Die Methode hat den Körper (body).
// Und den Name der Arbeit zurückgeben
@Override
public String getJobName() {
return "Coding Java";
}
}
ManualJob.java
package org.o7planning.tutorial.abs;
// ManualJob - eine Arbeit bezeichnen
// Die Vaterklasse (AbstractJob) hat 2 abstrakte Methode.
// Diese Klasse implementiert eine abstrakte Methode der Vaterklasse
// Deshalb muss sie als abstract verzollen
public abstract class ManualJob extends AbstractJob {
public ManualJob() {
}
// Die Durchführung der abstrakten Methode der Vaterklasse
@Override
public String getJobName() {
return "Manual Job";
}
}
BuildHouse.java
package org.o7planning.tutorial.abs;
// Diese Klasse erbt aus der abstrakten Klasse ManualJob
// BuildHouse wird als abstrakt nicht verzollt.
// Deshalb braucht sie alle restlichen abstrakten Methoden.
public class BuildHouse extends ManualJob {
public BuildHouse() {
}
// Die Durchführung der abstrakten Vaterklasse
@Override
public void doJob() {
System.out.println("Build a House");
}
}
Demo Beispiel
JobDemo.java
package org.o7planning.tutorial.abs;
public class JobDemo {
public static void main(String[] args) {
// Ein Objekt AbstractJob aus dem Constructor der Klasse JavaCoding erstellen.
AbstractJob job1 = new JavaCoding();
// Die Aufruf nach der Methode doJob()
job1.doJob();
// Die Methode getJobName ist abstrakt in der Klasse AbstractJob.
// Aber sie wird in einer Subklasse implementiert.
// So können Sie sie aufrufen
String jobName = job1.getJobName();
System.out.println("Job Name 1= " + jobName);
// Ein Objekt AbstractJob aus dem Constructor der Klasse BuildHouse erstellen
AbstractJob job2 = new BuildHouse();
job2.doJob();
String jobName2 = job2.getJobName();
System.out.println("Job Name 2= " + jobName2);
}
}
Ergebnis von Beispiel
Wir wissen, dass ein Class nur aus ein VaterClass ausgeweitert werden kann
// Die Klasse B ist die Subklasse der Klasse A oder mit anderen Worten ist B aus A verlängert
// Java erlaubt, dass eine Klasse nur aus einer einzigen Klasse verlängen.
public class B extends A {
// ....
}
// Falls nicht bestimmen, von welcher bestimmten Klasse die Klasse B verlängert wird,
// nach dem Default verstanden, dass B aus der Klasse Objekt verlängert wird.
public class B {
}
// Diese Erklärung und die obengemeinte Maßnahme sind gleich
public class B extends Object {
}
Aber ein Class kann aus viele Interface ausgeweitert werden
// Eine Klasse kann aus einer Vaterklasse nur velängert werden,
// aber aus mehren Interface verlängert
public class Cat extends Animal implements CanEat, CanDrink {
// ....
}
Die Eigenschaften von Interface
- Interface hat immer modifier : public interface, falls Sie melden oder nicht.
- Wenn Die Field sich befindet, sind sie public static final, falls Sie melden oder nicht.
- Ihre Methode sind abtrakt methode, d.h haben die modifier public abstract, falls Sie melden oder nicht.
- Interface hat keine Constructor.
NoAccessModifierInterface.java
package org.o7planning.tutorial.itf;
// Das ist eine Interface, die 'access modifier' nicht festlegt.
// Ihre Access modifier ist Default.
// Nur die Klasse in der gleichen Package können die Interface implementieren.
interface NoAccessModifierInterface {
}
CanMove.java
package org.o7planning.tutorial.itf;
// Diese Interface definiert ein Standard über die beweglichen Dinge
public interface CanMove {
// Die Methode in der Interface sind abstrakt und public.
public abstract void run();
// Obwohl Sie 'public abstract' nicht schreiben, versteht Java das immer.
void back();
// Die Geschwindigkeit
public int getVelocity();
}
CanDrink.java
package org.o7planning.tutorial.itf;
// Die Interface definiert ein Standard über die trinkbaren Dinge.
public interface CanDrink {
// Die Felder (field) in der Interface sind 'public static final'.
// Obwohl Sie klar oder nicht verzollen, versteht Java das immer
public static final String PEPSI = "PEPSI";
final String NUMBER_ONE = "NUMBER ONE";
String SEVENUP = "SEVEN UP";
public void drink();
}
CanEat.java
package org.o7planning.tutorial.itf;
// Die Interface definiert ein Standard über die essbaren Dinge
public interface CanEat {
public void eat();
}
Animal.java
package org.o7planning.tutorial.cls;
import org.o7planning.tutorial.itf.CanMove;
// Animal (das Tier).
// Diese Klasse verlängert aus der Klasse Object .
// und implementiert die Interface CanMove.
// Interface CanMove hat 3 abstrakte Methode.
// Diese Klasse implementiert nur eine Methode.
// So muss es als abstrakt verzollen.
// Die restlichen abstrakten Methode werden durch die SubKlasse durchgrführt.
public abstract class Animal implements CanMove {
// Die Durchführung der Methode run() der Interface CanMove.
@Override
public void run() {
System.out.println("Animal run...");
}
}
Cat.java
package org.o7planning.tutorial.cls;
import org.o7planning.tutorial.itf.CanDrink;
import org.o7planning.tutorial.itf.CanEat;
// Die Klasse Cat verlängert aus der Klasse Animal
// und implementiert 2 Interface CanEat, CanDrink.
// Cat ist eine normale Klasse ( sie wird als abstrakt nicht erklärt).
// So muss sie alle abstrakten Methode der Interface durchführen.
public class Cat extends Animal implements CanEat, CanDrink {
private String name;
public Cat(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
// Die Methode der Interface CanMove implementieren
@Override
public void back() {
System.out.println(name + " cat back ...");
}
// Die Methode der Interface CanMove implementieren
@Override
public int getVelocity() {
return 110;
}
// Die Methode der Interface CanEat implementieren.
@Override
public void eat() {
System.out.println(name + " cat eat ...");
}
// Die Methode der Interface CanDrink implementieren.
@Override
public void drink() {
System.out.println(name + " cat drink ...");
}
}
Mouse.java
package org.o7planning.tutorial.cls;
import org.o7planning.tutorial.itf.CanDrink;
import org.o7planning.tutorial.itf.CanEat;
public class Mouse extends Animal implements CanEat, CanDrink {
@Override
public void back() {
System.out.println("Mouse back ...");
}
@Override
public int getVelocity() {
return 85;
}
@Override
public void drink() {
System.out.println("Mouse drink ...");
}
@Override
public void eat() {
System.out.println("Mouse eat ...");
}
}
AnimalDemo.java
package org.o7planning.tutorial.cls;
import org.o7planning.tutorial.itf.CanEat;
public class AnimalDemo {
public static void main(String[] args) {
// Den static Felder aus Interface CanDrink erben.
System.out.println("Drink " + Cat.SEVENUP);
// Ein Objekt CanEat initializieren.
// Ein Objekt, das als CanEat erklärt wird.
// Aber es ist eigentlich Cat.
CanEat canEat1 = new Cat("Tom");
// Ein Objekt, das als CanEat erklärt wird.
// Aber es ist eigentlich Mouse.
CanEat canEat2 = new Mouse();
// Das Polymorphism wird klar hier gezeigt .
// Java kennt immer, zu welchem Typ ein Objekt gehört
// ==> Tom cat eat ...
canEat1.eat();
// ==> Mouse eat ...
canEat2.eat();
boolean isCat = canEat1 instanceof Cat;
System.out.println("catEat1 is Cat? " + isCat);
// Cast.
if (canEat2 instanceof Mouse) {
Mouse mouse = (Mouse) canEat2;
// Die Aufruf auf die Methode drink (aus CanDrink erben).
mouse.drink();
}
}
}
Beispiel bezeichnet das Ergebnis
*
