Abstrakte Klasse und Interface in Java
View more Tutorials:
Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt.
Facebook
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
Coding Java...
Job Name 1= Coding Java
Build a House
Job Name 2= Manual Job
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
Drink SEVEN UP
Tom cat eat ...
Mouse eat ...
catEat1 is Cat? true
Mouse drink ...
