Spring offre la possibilité lier les beans via des annotations dans le code et non via le fichier de configuration xml. On peut prendre l'exemple d'une classe MessageDisplayer faisant appel à une autre classe MessageDisplayer2. Cette relation n'a alors pas besoin d'être spécifiquement indiquée dans le fichier de Beans :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <context:annotation-config />
 <bean class="mainPackage.MessageDisplayer">
 </bean>
</beans> 
Classe principale :
package mainPackage;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@ComponentScan(basePackages = "mainPackage")
public class MainClass
 public static void main(String[] args)
 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Beans.xml");
 MessageDisplayer messageDisplayer = classPathXmlApplicationContext.getBean(MessageDisplayer.class);
 messageDisplayer.setMessage("test");
 messageDisplayer.displayMessage();
 classPathXmlApplicationContext.close();
Première classe d'affichage :
package mainPackage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
@Component
@ComponentScan("mainPackage")
public class MessageDisplayer
 @Autowired
 MessageDisplayer2 messageDisplayer2;
 private String message;
 public String getMessage()
 return message;
 public void setMessage(String message)
 this.message = message;
 public void displayMessage()
 System.out.println("message from MessageDisplayer : " + message);
 messageDisplayer2.setMessage("test2");
 messageDisplayer2.displayMessage();
Seconde classe d'affichage, appelée par la première : 
package mainPackage;
import org.springframework.stereotype.Component;
@Component
public class MessageDisplayer2
 private String message;
 public String getMessage()
 return message;
 public void setMessage(String message)
 this.message = message;
 public void displayMessage()
 System.out.println("message from MessageDisplayer2 : " + message);
Affichage du résultat :

Gambas 3/Gambas3LeLangage/L'orienté objet avec Gambas/Le polymorphisme

Le polymorphisme.
Le polymorphisme est un concept essentiel de la programmation orientée objet. 
Ce concept est intimement lié à l'héritage. 
Gambas utilise le dispatching virtuel selon le wiki officiel. 
Cela signifie qu'en cas d'appel de méthode, il cherche d'abord la méthode dans les classes fille. 
S'il ne trouve pas la méthode dans la classe fille, il remonte dans la classe parente. 
Dans la pratique, vous rassemblez des objets qui se ressemblent dans une collection. 
Mais chaque objet aura un comportement qui lui est propre. Certains objets agiront différemment des autres. 
L'exemple ci-dessous utilise des objets de type "Bateau". 
Ces objets sont créés avec les classes dérivées "Bateau à moteur" et "Bateau à voile". 
Un "Bateau à moteur" EST UN "Bateau". Un "Bateau à voile" EST UN "Bateau" lui aussi. 
Il y a donc une relation d'héritage entre ces classes. 
Toutes ces classes partagent plusieurs méthodes comme "RaffraichirPosition" ou "Demarrer" ou "Stopper". 
Vous l'aurez compris, un "Bateau à moteur" n'avance pas comme un "Bateau à voile" et le code sera donc différent dans les classes. 
' Gambas class file
' FMain (partielle)
Private v As Boat ' «--- bateau
Private v2 As Boat ' «--- bateau
Public Sub Form_Open()
 Dim x As Integer
 Dim y As Integer
 v2 = New Motorboat ' «--- bateau à moteur
 v = New Sailboat ' «--- bateau à voile
 x = DrawingArea1.Width \ 2
 y = DrawingArea1.height \ 2
 v.Cap = 90
 v.Speed = 0.0
 v.XPosition = x
 v.YPosition = y
 v2.Cap = 180
 v2.Speed = 0.0
 v2.XPosition = 40
 v2.YPosition = 40
 DrawingArea1.Refresh()
 TimerVoilier.Start()
End
Public Sub DrawingArea1_Draw()
 v.Draw() ' «--- bateau qui est un bateau à voile
 v2.Draw() ' «--- bateau qui est un bateau à moteur
End
Public Sub Timer_Timer()
 If ToggleButtonGaz1.Value = True Then
 v.Gaz()
 Endif
 v.Move()
 If ToggleButtonGaz2.Value = True Then
 v2.Gaz()
 Endif
 v2.Move()
 DrawingArea1.Refresh()
End
' ... (plus du code ci-dessous) ... 
En résumé :

Gambas 3/Gambas3LeLangage/L'orienté objet avec Gambas/Créer une collection personnalisée

Créer une collection personnalisée avec Gambas.
Vous savez déjà instancier et utiliser l'objet Collection. Peut-être aurez-vous besoin un jour de créer une classe pour représenter une collection personnalisée ? 
Si tel est le cas, il suffit de créer une classe qui contient un tableau ou une collection privée puis d'écrire les méthodes spéciales : 
qui ont été prévues à cet effet. :-)
' Gambas class file
' GambasIterable
' En Gambas, il y a un itérateur implicite qui : 
' - met Enum.Index à Null et qui
' - appelle _next()
' - appelle _get()
Private $col As New Collection
' _next() est une des méthodes spéciale de Gambas ...
' _next() renvoie un Variant qui est l'identifiant du prochain élément.
Public Function _next() As Variant
 If IsNull(Enum.Index) Then
 Enum.Index = 0 ' select first item ... 
 Else
 Inc Enum.Index
 Endif
 If Enum.Index >= $col.Count Then
 Enum.Stop
 Return
 Endif
 Return $col[Enum.Index]
End
' _get() est une des méthodes spéciale de Gambas ...
' _get() renvoie un élément de la collection selon l'identifiant
Public Function _get(Index As Integer) As String
 Return $col[CStr(Index)]
End
Public Sub _put(Value As Variant, Index As Integer)
 If Index <= $col.Count Then
 $col[CStr(Index)] = Value
 Else
 Error.Raise("Out of range or Wrong Key format (Integer wanted)!")
 Endif
End

Gambas 3/Gambas3LeLangage/L'orienté objet avec Gambas/Comparaison de types

Comparaison de types avec Gambas.
La comparaison de type se fait avec l'opérateur "Is". La comparaison se fait aussi sur les classes parente. 
En protique, cela permet de savoir si un objet est d'un type donné et a fortiori d'une classe parente.
Voici un exemple avec ... 
... la classe parente "Pomme" 
' Gambas class file
' Pomme
... et la classe fille "PommeVerte" qui hérite de "Pomme"
' Gambas class file
' PommeVerte
Inherits Pomme
Voici deux façons de comparer les types des objets : 
' Gambas module file
' Main
Public Sub Main()
 Dim p As New PommeVerte
 Print Object.Type(p) = "Pomme" ' «-- Vérifie le type de la classe fille uniquement
 Print p Is Pomme ' «-- Vérifie le type (fille ou parent)
End
La sortie est : 
False
True
Remarque.
Si vous concevez bien vos classes, vous n'aurez pas à comparer les types et votre application gagnera en performance.

Précis d'épistémologie/Principes logiques