PHP 抽象方法与抽象类abstract关键字介绍及应用,abstract关键字
PHP 抽象方法与抽象类abstract关键字介绍及应用,abstract关键字
PHP 抽象方法与抽象类 abstract 关键字
abstract 关键字用于定义抽象方法与抽象类。
抽象方法
抽象方法指没有方法体的方法,具体就是在方法声明的时候没有 {} 括弧以及其中的内容,而是直接在声明时在方法名后加上分号结束。
abstract 关键字用于定义抽象方法,语法:
abstract function function_name();
抽象类
只要一个类里面有一个方法是抽象方法,那么这个类就要定义为抽象类。抽象类同样用 abstract 关键字来定义。
抽象类不能产生实例对象,通常是将抽象方法做为子类方法重载的模板使用的,且要把继承的抽象类里的方法都实现。实际上抽象类是方便继承而引入的。
例子:
复制代码 代码如下:
abstract class AbstractClass{
// 定义抽象方法
abstract protected function getValue();
// 普通方法
public function printOut(){
print $this->getValue()."
";
}
}
class ConcreteClass extends AbstractClass{
protected function getValue(){
return "抽象方法的实现";
}
}
$class1 = new ConcreteClass;
$class1->printOut();
?>
在这个例子中,父类定义了抽象方法以及对于方法的实现,但实际的内容却在子类里定义。
用来提供基本的方法给派生类继承的!
1、声明一个抽象方法使用abstract关键字。
2、一个类中可以包含一个或多个抽象方法。
3、抽象类中可以存在非抽象的方法。
4、抽象类不能被直接被实例化。
5、实现抽象类用“:”(冒号),实现抽象方法用override关键字。
6、抽象类可以被抽象类所继承,结果仍是抽象类。
7、抽象方法被实现后,不能更改修饰符。
例子如下:
public abstract class Person
{
public abstract void SayHello();
public void about()
{
Console.WriteLine("Abstract Demo");
}
}
public class Student : Person
{
public override void SayHello()
{
Console.WriteLine("SayHello");
}
}
class MainClass
{
public static void Main()
{
new Student().SayHello();
}
}
抽象方法
抽象方法指没有方法体的方法,具体就是在方法声明的时候没有 {} 括弧以及其中的内容,而是直接在声明时在方法名后加上分号结束。
abstract 关键字用于定义抽象方法,语法:
abstract function function_name();
抽象类
只要一个类里面有一个方法是抽象方法,那么这个类就要定义为抽象类。抽象类同样用 abstract 关键字来定义。
抽象类不能产生实例对象,通常是将抽象方法做为子类方法重载的模板使用的,且要把继承的抽象类里的方法都实现。实际上抽象类是方便继承而引入的。
例子:
abstract class AbstractClass{
// 定义抽象方法
abstract protected function getValue();
// 普通方法
public function printOut(){
print $this->getValue()."
";
}
}
class ConcreteClass extends AbstractClass{
protected function getValue(){
return "抽象方法的实现";
}
}
$class1 = new ConcreteClass;
$class1->printOut();
?>
在这个例子中,父类定义了抽象方法以及对于方法的实现,但实际的内容却在子类里定义。

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Golang hat keine abstrakten Klassen. Golang ist keine objektorientierte (OOP) Sprache. Es gibt keine Konzepte für Klassen, Vererbung und abstrakte Klassen. Es gibt jedoch Strukturen (Strukturen) und Schnittstellen (Schnittstellen), die indirekt durch die Kombination von implementiert werden können Struktur und Schnittstelle. Abstrakte Klassen in Objektsprachen.

Der Grund für den Fehler liegt in Python. Der Grund, warum NotImplementedError() in Tornado ausgelöst wird, kann darin liegen, dass eine abstrakte Methode oder Schnittstelle nicht implementiert ist. Diese Methoden oder Schnittstellen werden in der übergeordneten Klasse deklariert, aber nicht in der untergeordneten Klasse implementiert. Unterklassen müssen diese Methoden oder Schnittstellen implementieren, um ordnungsgemäß zu funktionieren. Die Lösung dieses Problems besteht darin, die von der übergeordneten Klasse deklarierte abstrakte Methode oder Schnittstelle in der untergeordneten Klasse zu implementieren. Wenn Sie eine Klasse verwenden, um von einer anderen Klasse zu erben, und dieser Fehler angezeigt wird, sollten Sie alle in der übergeordneten Klasse deklarierten abstrakten Methoden in der untergeordneten Klasse implementieren. Wenn Sie eine Schnittstelle verwenden und dieser Fehler angezeigt wird, sollten Sie alle in der Schnittstelle deklarierten Methoden in der Klasse implementieren, die die Schnittstelle implementiert. Wenn Sie sich nicht sicher sind, welches

Java ermöglicht die Definition innerer Klassen innerhalb von Schnittstellen und abstrakten Klassen und bietet so Flexibilität für die Wiederverwendung und Modularisierung von Code. Innere Klassen in Schnittstellen können spezifische Funktionen implementieren, während innere Klassen in abstrakten Klassen allgemeine Funktionen definieren können und Unterklassen konkrete Implementierungen bereitstellen.

Schnittstellen und abstrakte Klassen werden in Entwurfsmustern zur Entkopplung und Erweiterbarkeit verwendet. Schnittstellen definieren Methodensignaturen, abstrakte Klassen stellen eine teilweise Implementierung bereit und Unterklassen müssen nicht implementierte Methoden implementieren. Im Strategiemuster wird die Schnittstelle zum Definieren des Algorithmus verwendet, und die abstrakte Klasse oder konkrete Klasse stellt die Implementierung bereit, wodurch ein dynamischer Wechsel von Algorithmen ermöglicht wird. Im Beobachtermuster werden Schnittstellen zum Definieren des Beobachterverhaltens verwendet, und abstrakte oder konkrete Klassen werden zum Abonnieren und Veröffentlichen von Benachrichtigungen verwendet. Im Adaptermuster werden Schnittstellen verwendet, um vorhandene Klassen anzupassen, oder konkrete Klassen können kompatible Schnittstellen implementieren und so eine Interaktion mit Originalcode ermöglichen.

Interface Interface definiert abstrakte Methoden und Konstanten in Java. Die Methoden in der Schnittstelle sind nicht implementiert, sondern werden von der Klasse bereitgestellt, die die Schnittstelle implementiert. Die Schnittstelle definiert einen Vertrag, der erfordert, dass die Implementierungsklasse bestimmte Methodenimplementierungen bereitstellt. Deklarieren Sie die Schnittstelle: publicinterfaceExampleInterface{voiddoSomething();intgetSomething();} Abstrakte Klasse Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann. Es enthält eine Mischung aus abstrakten und nicht-abstrakten Methoden. Ähnlich wie Schnittstellen werden abstrakte Methoden in abstrakten Klassen durch Unterklassen implementiert. Abstrakte Klassen können jedoch auch konkrete Methoden enthalten, die Standardimplementierungen bereitstellen. Deklarieren Sie die abstrakte Klasse: publicabstractcl

Für die Wiederverwendbarkeit von Code werden sowohl funktionale Schnittstellen als auch abstrakte Klassen verwendet, sie werden jedoch auf unterschiedliche Weise implementiert: funktionale Schnittstellen durch Referenzfunktionen, abstrakte Klassen durch Vererbung. Funktionale Schnittstellen können nicht instanziiert werden, abstrakte Klassen jedoch schon. Funktionale Schnittstellen müssen alle deklarierten Methoden implementieren, während abstrakte Klassen nur einige Methoden implementieren können.

Schnittstellen und abstrakte Klassen werden verwendet, um erweiterbaren PHP-Code zu erstellen, und es gibt den folgenden Hauptunterschied zwischen ihnen: Schnittstellen erzwingen durch Implementierung, während abstrakte Klassen durch Vererbung erzwungen werden. Schnittstellen können keine konkreten Methoden enthalten, abstrakte Klassen hingegen schon. Eine Klasse kann mehrere Schnittstellen implementieren, aber nur von einer abstrakten Klasse erben. Schnittstellen können nicht instanziiert werden, abstrakte Klassen jedoch schon.

Schnittstelle: Eine implementierte Vertragsschnittstelle definiert eine Reihe von Methodensignaturen in Java, stellt jedoch keine konkrete Implementierung bereit. Es fungiert als Vertrag, der Klassen, die die Schnittstelle implementieren, dazu zwingt, ihre angegebenen Methoden zu implementieren. Die Methoden in der Schnittstelle sind abstrakte Methoden und haben keinen Methodenkörper. Codebeispiel: publicinterfaceAnimal{voideat();voidsleep();} Abstrakte Klasse: Teilweise implementierter Entwurf Eine abstrakte Klasse ist eine übergeordnete Klasse, die eine teilweise Implementierung bereitstellt, die von ihren Unterklassen geerbt werden kann. Im Gegensatz zu Schnittstellen können abstrakte Klassen konkrete Implementierungen und abstrakte Methoden enthalten. Abstrakte Methoden werden mit dem Schlüsselwort abstract deklariert und müssen von Unterklassen überschrieben werden. Codebeispiel: publicabstractcla
