Programmation Java/Interfaces
Une interface définit un ensemble de méthodes mais pas leur implémentation.
C'est pourquoi il n'est pas possible d'instancier une interface directement.
Il est toutefois possible d'appeler une méthode en utilisant une référence à une interface, sans savoir quelle classe implémentant concrètement la méthode appelée est réellement utilisée.
Présentation.
En fait, une interface est une classe abstraite dont toutes les méthodes sont abstraites et dont tous les attributs sont constants (des constantes, voir le mot-clé "final").
Exemple.
Définition de l'interface ;
package org.wikibooks.fr;
public interface Vehicule
 public void rouler(int vitesse);
 public void freiner();
 public int getVitesse();
La présence du modificateur codice_1 est implicite et n'est donc pas obligatoire.
Cependant, sa présence est recommandée et permet de montrer que ces méthodes seront publiques, de plus cela permet de copier la signature de la méthode dans la classe qui l'implémente.
La présence du modificateur codice_2 est implicite également.
Sa présence n'est cependant pas recommandée afin de permettre la copie de la signature de la méthode dans la classe qui l'implémente.
On a défini ici ce qu'on attend d'un objet de type véhicule.
On peut maintenant donner une ou plusieurs implémentations de cette interface grâce à l'utilisation du mot clef implements :
package org.wikibooks.fr;
public class Velo implements Vehicule
 // Champs
 private String marque;
 private int rayonRoue, vitesse;
 // Constructeurs
 public Velo(String marque, int rayonRoue)
 this.marque = marque;
 this.rayonRoue = rayonRoue;
 // Méthodes
 public int getVitesse()
 // Retourner la vitesse actuelle du vélo
 return vitesse;
 public void rouler(int vitesse)
 // Coder ici la manière dont le vélo roule
 if (vitesse < 0 || vitesse > 80) throw new IllegalArgument("Vitesse incorrecte pour un vélo.");
 this.vitesse = vitesse;
 public void freiner()
 // Coder ici la manière dont le vélo freine
 this.vitesse = 0;
 // ... Autres méthodes propres à Velo
package org.wikibooks.fr;
public class Auto implements Vehicule
 //Champs
 private String marque;
 private int poids, vitesse;
 // Constructeurs
 public Auto(String marque, int poids)
 this.marque = marque;
 this.poids = poids;
 // Méthodes
 public int getVitesse()
 // Retourner la vitesse actuelle de l'auto
 return vitesse;
 public void rouler(int vitesse)
 //Coder ici la manière dont l'auto roule
 if (vitesse < 0 || vitesse > 160) throw new IllegalArgument("Vitesse incorrecte pour une auto.");
 this.vitesse = vitesse;
 public void freiner()
 // Coder ici la manière dont l'auto freine
 this.vitesse = 0;
 // ... Autres méthodes propres à Auto.
Dans cet exemple, nous avons donné deux implémentations de Vehicule.
Conséquences : 
Abstraction.
Si, par exemple, nous avons une classe Personne possédant une méthode conduire(Vehicule v), on peut alors écrire :
Personne p = new Personne();
p.conduire(new Velo()); //comme la méthode attend un codice_3 en argument, on peut passer tout objet implémentant cette interface.
p.conduire(new Auto()); //idem
On peut "instancier" un codice_3 par le biais de ses implémentations :
Vehicule v = new Auto();
Vehicule t = new Velo();
Dans ce cas v et t sont vus comme des codice_3 et, par conséquent, on ne peut appeler sur ces objets que les méthodes définies dans l'interface codice_3.
Implémentation partielle.
Une classe peut n'implémenter qu'une partie de l'interface.
Dans ce cas, il s'agit d'une classe abstraite et doit utiliser le mot-clé codice_2.
Dans l'exemple de ce chapitre, les deux classes concrètes implémentent certaines méthodes de la même façon.
Ce comportement commun peut être déplacé dans une classe abstraite intermédiaire :
package org.wikibooks.fr;
public abstract class VehiculeConcret implements Vehicule
 // Attributs accessible par les sous-classes
 protected int vitesse;
 // Méthodes implémentant l'interface Vehicule
 public int getVitesse()
 // Retourner la vitesse actuelle du véhicule concret
 return vitesse;
 public void freiner()
 this.vitesse = 0;
 // La méthode rouler(int vitesse) n'est pas implémentée par cette classe abstraite.
package org.wikibooks.fr;
public class Velo extends VehiculeConcret
 // Champs
 private String marque;
 private int rayonRoue, vitesse;
 // Constructeurs
 public Velo(String marque, int rayonRoue)
 this.marque = marque;
 this.rayonRoue = rayonRoue;
 // Méthodes complétant l'implémentation de l'interface Vehicule
 public void rouler(int vitesse)
 // Coder ici la manière dont le vélo roule
 if (vitesse < 0 || vitesse > 80) throw new IllegalArgument("Vitesse incorrecte pour un vélo.");
 this.vitesse = vitesse;
 // ... Autres méthodes propres à Velo
package org.wikibooks.fr;
public class Auto extends VehiculeConcret
 //Champs
 private String marque;
 private int poids, vitesse;
 // Constructeurs
 public Auto(String marque, int poids)
 this.marque = marque;
 this.poids = poids;
 // Méthodes complétant l'implémentation de l'interface Vehicule
 public void rouler(int vitesse)
 //Coder ici la manière dont l'auto roule
 if (vitesse < 0 || vitesse > 160) throw new IllegalArgument("Vitesse incorrecte pour une auto.");
 this.vitesse = vitesse;
 // ... Autres méthodes propres à Auto.
Instanciation.
L'exemple suivant semble instancier l'interface :
Vehicule quelqu_un_en_rollers = new Vehicule()
 private int vitesse = 0;
 // Méthodes
 public int getVitesse()
 // Retourner la vitesse actuelle
 return vitesse;
 public void rouler(int vitesse)
 if (vitesse < 0 || vitesse > 20) throw new IllegalArgument("Vitesse incorrecte pour des rollers.");
 this.vitesse = vitesse;
 public void freiner()
 // Coder ici la manière dont l'auto freine
 this.vitesse = 0;
}; // Fin de déclaration d'objet.
En réalité, une classe anonyme est créée et définie, implémentant l'interface indiquée.
Cette syntaxe est utilisée notamment pour créer des instances de listeners pour l'écoute d'évènements, comme en Swing.

Programmation Java/Classes abstraites
Exemple.
public interface Chien
 public void vieillir();
 public void aboyer();
On sait que la méthode vieillir sera implémentée de la même manière quelle que soit l'implémentation de Chien. Plutôt que d'implémenter cette interface à chaque fois, on va factoriser le code dans une classe abstraite et étendre cette classe quand le besoin s'en fait sentir. On crée donc une classe AbstractChien qui n'implémente que la méthode vieillir de notre interface, les autres étant laissées abstract.
package org.wikibooks.fr;
public abstract class AbstractChien implements Chien
 // Champs
 // On met les champs en protected pour que les classes filles
 // puissent les manipuler directement.
 protected int age;
 protected String couleur;
 //Constructeur
 //Pourra être utilisé par les classes filles pour initialiser les champs.
 public AbstractChien(int age, String couleur)
 this.age = age;
 this.couleur = couleur;

// Méthode
 //On donne l'implémentation qui est commune à tous les chiens
 public void vieillir()
 age ++;
 //Cette méthode n'est définie que par les classes filles
 //Elle est donc laissée abstract.
 public abstract void aboyer();

Programmation GTK2 en Pascal/Les décorations

Les contrôles décoratifs ne sont pas indispensables mais permettent de réaliser des interfaces graphiques plus agréables, plus ergonomiques. On va y trouver les cadres qui permettent de regrouper visuellement des contrôles et des lignes qui permettent au contraire de séparer les contrôles :