抽象类 php 抽象类的简单应用
All right, 父类postParent定义为抽象,规定子类必须重新实现 buildHTML()方法,这个方法并没有花括号,如果有不管有没有内容都会报错的。
现在越看越觉得这代码完全没必要用抽象类,用继承也都很鸡肋,好吧,也没啥好说的好像。。。。。
另外我把mysql 分开在外面了,所以调用方法很麻烦
1,先实例化 readArticle
2,mysql查询,参数来自 readArticle::getSQL();
3,返回mysql结果资源给 readArticle::fetchResult( $result );
4,readArticle::buildHTML(); 返回HTML
如果是列表循环输出的话,把 3 和 4 重复调用就可以了
复制代码 代码如下:
abstract class postParent
{
protected $querySQL;
public $fetchResult;
public $timeAgo; // eg : 2 days ago
abstract protected function buildHTML();
public function getSQL()
{
return $this->querySQL;
}
public function fetchResult( $result )
{
$this->fetchResult = mysql_fetch_assoc( $result );
}
public function error()
{}
}
class readArticle extends postParent
{
public function __construct( $id )
{
$this->querySQL =SELECT title, author, text, unixtime FROM post
WHERE id = $id ORDER BY unixtime DESC;
eof;
}
public function buildHTML()
{
return
{$this->fetchResult['author']} at
{$this->fetchResult['text']}
eof;
}
}
以上就介绍了抽象类 php 抽象类的简单应用,包括了抽象类方面的内容,希望对PHP教程有兴趣的朋友有所帮助。

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Golang n'a pas de classes abstraites. Golang n'est pas un langage orienté objet (POO). Il n'a pas de concepts de classes, d'héritage et de classes abstraites. Cependant, il existe des structures (structures) et des interfaces (interfaces) qui peuvent être indirectement implémentées via la combinaison de. struct et interface. Classes abstraites dans les langages objets.

Java permet de définir des classes internes au sein d'interfaces et de classes abstraites, offrant ainsi une flexibilité pour la réutilisation et la modularisation du code. Les classes internes des interfaces peuvent implémenter des fonctions spécifiques, tandis que les classes internes des classes abstraites peuvent définir des fonctions générales et les sous-classes fournissent des implémentations concrètes.

Interface L'interface définit des méthodes abstraites et des constantes en Java. Les méthodes de l'interface ne sont pas implémentées, mais sont fournies par la classe qui implémente l'interface. L'interface définit un contrat qui exige que la classe d'implémentation fournisse des implémentations de méthodes spécifiées. Déclarez l'interface : publicinterfaceExampleInterface{voiddoSomething();intgetSomething();} Classe abstraite Une classe abstraite est une classe qui ne peut pas être instanciée. Il contient un mélange de méthodes abstraites et non abstraites. Semblables aux interfaces, les méthodes abstraites des classes abstraites sont implémentées par des sous-classes. Cependant, les classes abstraites peuvent également contenir des méthodes concrètes, qui fournissent des implémentations par défaut. Déclarer la classe abstraite : publicabstractcl

Interface : une interface de contrat sans implémentation définit un ensemble de signatures de méthodes en Java mais ne fournit aucune implémentation concrète. Il agit comme un contrat qui oblige les classes qui implémentent l'interface à implémenter ses méthodes spécifiées. Les méthodes de l'interface sont des méthodes abstraites et n'ont pas de corps de méthode. Exemple de code : publicinterfaceAnimal{voideat();voidsleep();} Classe abstraite : plan partiellement implémenté Une classe abstraite est une classe parent qui fournit une implémentation partielle dont ses sous-classes peuvent hériter. Contrairement aux interfaces, les classes abstraites peuvent contenir des implémentations concrètes et des méthodes abstraites. Les méthodes abstraites sont déclarées avec le mot-clé abstract et doivent être remplacées par des sous-classes. Exemple de code : publicabstractcla

Les interfaces et les classes abstraites sont utilisées dans les modèles de conception pour le découplage et l'extensibilité. Les interfaces définissent les signatures des méthodes, les classes abstraites fournissent une implémentation partielle et les sous-classes doivent implémenter des méthodes non implémentées. Dans le modèle de stratégie, l'interface est utilisée pour définir l'algorithme, et la classe abstraite ou la classe concrète assure l'implémentation, permettant une commutation dynamique des algorithmes. Dans le modèle d'observateur, les interfaces sont utilisées pour définir le comportement de l'observateur, et les classes abstraites ou concrètes sont utilisées pour s'abonner et publier des notifications. Dans le modèle d'adaptateur, les interfaces sont utilisées pour adapter les classes existantes ou les classes concrètes peuvent implémenter des interfaces compatibles, permettant une interaction avec le code d'origine.

Les interfaces fonctionnelles et les classes abstraites sont utilisées pour la réutilisabilité du code, mais elles sont implémentées de différentes manières : interfaces fonctionnelles via des fonctions de référence, classes abstraites via l'héritage. Les interfaces fonctionnelles ne peuvent pas être instanciées, mais les classes abstraites le peuvent. Les interfaces fonctionnelles doivent implémenter toutes les méthodes déclarées, tandis que les classes abstraites ne peuvent implémenter que certaines méthodes.

Conseils pour optimiser les performances des interfaces et des classes abstraites en Java : Évitez d'utiliser les méthodes par défaut dans les interfaces et utilisez-les uniquement lorsque cela est nécessaire. Réduisez la définition de l’interface pour inclure uniquement le contenu nécessaire. Implémentez autant de méthodes de classe abstraites que possible. Utilisez le modificateur final pour éviter le remplacement par des sous-classes. Déclarez les méthodes qui ne doivent pas être appelées comme privées.

Les interfaces et les classes abstraites sont utilisées pour créer du code PHP extensible, et il existe la différence clé suivante entre elles : les interfaces s'appliquent via l'implémentation, tandis que les classes abstraites s'appliquent via l'héritage. Les interfaces ne peuvent pas contenir de méthodes concrètes, contrairement aux classes abstraites. Une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d'une seule classe abstraite. Les interfaces ne peuvent pas être instanciées, mais les classes abstraites le peuvent.
