Saltar para o conteúdo principal
Versão: 20 R5 BETA

Classes

Visão Geral

El lenguaje 4D soporta el concepto de clases. Numa linguagem de programação, a utilização de uma classe permite definir um comportamento do objecto com propriedades e funções associadas.

Cada objeto es una instancia de su clase. Cada objecto é uma instância da sua classe. A class can extend another class, and then inherits from its functions and properties (declared and computed).

O modelo de classe em 4D é semelhante às classes em JavaScript, e baseado numa cadeia de protótipos.

Por ejemplo, puede crear una clase Person con la siguiente definición:

//Class: Person.4dm
Class constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname

Function get fullName() -> $fullName : Text
$fullName:=This.firstName+" "+This.lastName

Function sayHello() -> $welcome : Text

$welcome:="Hello "+This.fullName

Ou em um método, criar uma "Pessoa":

var $person : cs. Person //object of Person class  
var $hello : Text
$person:=cs. Person.new("John";"Doe")
// $person:{firstName: "John"; lastName: "Doe" }
$hello:=$person.sayHello() //"Hello John Doe"

Gestão de classes

Definição de classe

Una clase usuario en 4D está definida por un archivo método específico (.4dm), almacenado en la carpeta /Project/Sources/Classes/. O nome do arquivo é o nome da classe.

Ao nomear classes, deve ter em mente as seguintes regras:

Por exemplo, se quiser definir uma classe chamada "Polígono", precisa criar o seguinte arquivo:

Project folder

Eliminação de uma classe

Para eliminar uma classe existente, pode:

  • no seu disco, remover o arquivo de classe .4dm da pasta "Classes",
  • in the 4D Explorer, select the class and click or choose Move to Trash from the contextual menu.

Using 4D interface

Los archivos de clase se almacenan automáticamente en la ubicación adecuada cuando se crean a través de la interfaz de 4D, ya sea a través del menú Archivo o del Explorador.

Puede crear un nuevo archivo de clase para el proyecto seleccionando Nueva > Clase... en el menú Archivo de 4D Developer o en la barra de herramientas.

También puede utilizar el atajo Ctrl+Mayús+Alt+k.

Explorador

En la página Métodos del Explorador, las clases se agrupan en la categoría Clases.

Para criar uma nova classe, pode:

  • select the Classes category and click on the button.
  • seleccione Nueva clase... en el menú de acciones de la parte inferior de la ventana del Explorador, o en el menú contextual del grupo Clases.
  • seleccione Nueva > Clase... en el menú contextual de la página de inicio del Explorador.

Suporte de código de classe

Nas várias janelas 4D (editor de código, compilador, depurador, explorador de tempo de execução), o código de classe é basicamente tratado como um método de projecto com algumas especificidades:

  • No editor de código:
    • uma aula não pode ser executada
    • uma função de classe é um bloco de código
    • Ir a la definición en un objeto miembro busca las declaraciones de función de clase; por ejemplo, "$o.f()" encontrará "Function f".
    • Buscar referencias en la declaración de función de clase busca la función utilizada como miembro de objeto; por ejemplo, "Function f" encontrará "$o.f()".
  • En el explorador de Ejecución y Depurador, las funciones clase se muestran con el formato <ClassName> constructor o <ClassName>.<FunctionName>.

Lojas de classe

As classes disponíveis são acessíveis a partir das suas class stores. Estão disponíveis duas class stores:

  • cs para el class store usuario
  • 4D para el class store integrado

cs

cs : Object

ParâmetroTipoDescrição
classStoreObject<-Class store de usuário para o projeto ou componente

The cs command returns the user class store for the current project or component. Devuelve todas las clases de usuario definidas en el proyecto o componente abierto. Por defecto, sólo las clases ORDA están disponibles.

Exemplo

Quiere crear una nueva instancia de un objeto de myClass:

$instance:=cs.myClass.new()

4D

4D : Object

ParâmetroTipoDescrição
classStoreObject<-Class store 4D

The 4D command returns the class store for available built-in 4D classes. Ofrece acceso a las APIs específicas como CryptoKey.

Exemplo

Quiere crear una nueva llave en la clase CryptoKey:

$key:=4D. CryptoKey.new(New object("type";"ECDSA";"curve";"prime256v1"))

Objecto de classe

Cuando una clase es definida en el proyecto, se carga en el entorno del lenguaje 4D. Una clase es un objeto de la clase "Class". Um objecto classe tem as seguintes propriedades e função:

In addition, a class object can reference a constructor object (optional).

Un objeto de clase en sí mismo es un objeto compartido y, por tanto, se puede acceder a él desde diferentes procesos de 4D simultáneamente.

Herança

If a class inherits from another class (i.e. the Class extends keyword is used in its definition), the parent class is its superclass.

When 4D does not find a function or a property in a class, it searches it in its superclass; if not found, 4D continues searching in the superclass of the superclass, and so on until there is no more superclass (all objects inherit from the "Object" superclass).

Palavras-chave de classe

As palavras-chave 4D específicas podem ser utilizadas nas definições de classes:

  • Function <Name> para definir las funciones de clase de los objetos.
  • Class constructor para inicializar nuevos objetos de la clase.
  • property para definir propiedades estáticas de los objetos con un tipo.
  • Function get <Name> y Function set <Name> para definir las propiedades calculadas de los objetos.
  • Class extends <ClassName> para definir la herencia.

Function

Sintaxe

{shared} Function <name>({$parameterName : type; ...}){->$parameterName : type}
// code

As funções de classe são propriedades específicas da classe. Son objetos de la clase 4D.Function. En el archivo de definición de clase, las declaraciones de función utilizan la palabra clave Function seguida del nombre de la función.

If the function is declared in a shared class, you can use the shared keyword so that the function could be called without Use...End use structure. Para obtener más información, consulte el párrafo Funciones compartidas a continuación.

El nombre de la función debe ser compatible con las reglas de nomenclatura de objetos.

nota

Como propriedades e funções compartilham o mesmo espaço de nomes, usar o mesmo nome para uma propriedade e uma função da mesma classe não é permitido (um erro é lançado nesse caso).

tip
Dica: Começar o nome da função com um caractere de sublinhado ("_") excluirá a função dos recursos de preenchimento automático no editor de código 4D. Por ejemplo, si declara `Function _myPrivateFunction` en `MyClass`, no se propondrá en el editor de código cuando digite en `"cs.MyClass. "`.

Inmediatamente después del nombre de la función, los parámetros de la función se pueden declarar con un nombre y un tipo de datos asignados, incluido el parámetro de retorno (opcional). Por exemplo:

Function computeArea($width : Integer; $height : Integer)->$area : Integer

En una función de clase, el comando This se utiliza como instancia del objeto. Por exemplo:

Function setFullname($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname

Function getFullname()->$fullname : Text
$fullname:=This.firstName+" "+Uppercase(This.lastName)

Para una función clase, el comando Current method name devuelve: <ClassName>.<FunctionName>, por ejemplo "MyClass.myFunction".

En el código de la aplicación, las funciones de clases se llaman como los métodos miembros de las instancias de objetos y pueden recibir parámetros si los hay. As seguintes sintaxes são suportadas:

  • utilización del operador (). Por ejemplo, myObject.methodName("hello")
  • use of a "4D. Function" class member method:
Thread-safety warning

Se uma função de classe não for thread-safe e for chamada por um método com o atributo "Pode ser executado num processo preemptivo":

  • o compilador não gera qualquer erro (o que é diferente dos métodos normais),
  • um erro é lançado por 4D apenas em tempo de execução.

Parâmetros

Os parâmetros da função são declarados utilizando o nome do parâmetro e o tipo de parâmetro, separados por dois pontos. El nombre del parámetro debe cumplir con las reglas de nomenclatura de las propiedades. Os parâmetros (e tipos) múltiplos são separados por ponto e vírgula (;).

Function add($x; $y : Variant; $z : Integer; $xy : Object)
nota

Si no se declaró el tipo, el parámetro se definirá como Variant.

Valor retornado

Se declara el parámetro de retorno (opcional) añadiendo una flecha (->) y la definición del parámetro de retorno después de la lista de parámetros de entrada, o dos puntos (:) y el tipo de parámetro de retorno únicamente. Por exemplo:

Function add($x : Variant; $y : Integer)->$result : Integer
$result:=$x+$y

You can also declare the return parameter by adding only : type and use the return expression (it will also end the function execution). Por exemplo:

Function add($x : Variant; $y : Integer)-&gt;$result : Integer

Exemplo 1

property name : Text
property height; width : Integer

// Class: Rectangle
Class constructor($width : Integer; $height : Integer)
This.name:="Rectangle"
This.height:=$height
This.width:=$width

// Function definition
Function getArea()->$result : Integer
$result:=(This.height)*(This.width)
// In a project method

var $rect : cs. Rectangle
var $area : Real

$rect:=cs. Rectangle.new(50;100)
$area:=$rect.getArea() //5000

Exemplo 2

This example uses the return expression:

Function getRectArea($width : Integer; $height : Integer) : Integer
If ($width > 0 && $height > 0)
return $width * $height
Else
return 0
End if

Class constructor

Sintaxe

// Class: MyClass
{shared} {singleton} Class Constructor({$parameterName : type; ...})
// code

Una función constructora de clase acepta parámetros opcionales y puede ser utilizada para crear e inicializar objetos de la clase del usuario.

When you call the new() function, the class constructor is called with the parameters optionally passed to the new() function.

Só pode haver uma função de construtor em uma classe (caso contrário um erro é retornado). A constructor can use the Super keyword to call the constructor of the super class.

É possível criar e digitar propriedades de instância dentro do construtor (ver exemplo). Alternatively, if your instance properties' values do not depend on parameters passed to the constructor, you can define them using the property keyword.

Utilizando la palabra clave shared se crea una clase compartida, utilizada para instanciar únicamente objetos compartidos. Para obtener más información, consulte el párrafo Clases compartidas.

Utilizando la palabra clave singleton se crea un singleton, utilizado para crear una única instancia. Para obtener más información, consulte el párrafo Clases singleton.

Exemplo

// Class: MyClass
// Class constructor of MyClass Class Constructor ($name : Text)
This.name:=$name
// In a project method
// You can instantiate an object
var $o : cs. MyClass
$o:=cs. MyClass.new("HelloWorld")
// $o = {"name":"HelloWorld"}

propriedade

Sintaxe

property <propertyName>{; <propertyName2>;...}{ : <propertyType>}

La palabra claveproperty se puede utilizar para declarar una propiedad dentro de una clase usuario. Uma propriedade de classe tem um nome e um tipo.

A declaração de propriedades de classe melhora as sugestões do editor de código, as funcionalidades de antecipação de tipos e a detecção de erros.

Properties are declared for new objects when you call the new() function, however they are not automatically added to objects (they are only added when they are assigned a value).

nota

Una propiedad se añade automáticamente al objeto cuando se inicializa en la línea de declaración.

Los nombres de las propiedades deben cumplir las normas de denominación de propiedades.

nota

Como propriedades e funções compartilham o mesmo espaço de nomes, usar o mesmo nome para uma propriedade e uma função da mesma classe não é permitido (um erro é lançado nesse caso).

O tipo de propriedade pode ser um dos seguintes tipos suportados:

SintaxeConteúdos
TextValor texto
DateValor data
TimeValor Hora
BooleanValor booleano
IntegerValor inteiro longo
RealValor real
PointerValor ponteiro
PictureValor imagem
BlobValor BLOB
CollectionValor colecção
VariantValor variant
ObjectObject with default class (4D.Object)
4D.<className>Objecto do nome da classe 4D
cs.<className>Objeto do nome da classe usuário
cs.<namespace>.<className>Objeto do nome da classe do componente <namespace>

Se você omitir o tipo na linha de declaração, a propriedade é criada como uma variante.

info

La palabra clave property sólo puede utilizarse en métodos clase y fuera de cualquier bloque Function o Class Constructor.

Inicializando a propriedade na linha de declaração

Ao declarar uma propriedade, você tem a flexibilidade de especificar seu tipo de dados e fornecer seu valor em uma única instrução. A sintaxe suportada é:

property <propertyName> { : <propertyType>} := <Propertyvalue>

nota

Ao usar essa sintaxe, você não pode declarar várias propriedades na linha de declaração.

Você pode omitir o tipo na linha da declaração, caso em que o tipo será inferido quando possível. Por exemplo:

// Class: MyClass

property name : Text := "Smith"
property age : Integer := 42

property birthDate := !1988-09-29! //date is inferred
property fuzzy //variant

When you initialize a property in its declaration line, it is added to the class object after its instantiation with the new() function but before the constructor is called.

Si una clase extiende a otra, las propiedades de la clase padre se instancian antes que las propiedades de la clase hija.

Exemplo

// Class: MyClass

property name : Text
property age : Integer
property color : Text := "Blue"

Num método:

var $o : cs.MyClass
$o:=cs.MyClass.new() //$o:{"color" : "Blue"}
$o.name:="John" //$o:{"color" : "Blue"; "name" : "John"}
$o.age:="Smith" //error com a sintaxe checada

Function get y Function set

Sintaxe

{shared} Function get <name>()->$result : type
// código
{shared} Function set <name>($parameterName : type)
// código

Function get y Function set son accesos que definen las propiedades calculadas en la clase. Uma propriedade calculada é uma propriedade nomeada com um tipo de dados que oculta um cálculo. Quando um valor de propriedade computado é acessado, 4D substitui o código do acessor correspondente:

  • cuando se lee la propiedad, Function get se ejecuta,
  • cuando se escribe la propiedad, Function get se ejecuta.

Se a propriedade não for acedida, o código nunca é executado.

As propriedades computadas são concebidas para tratar dados que não precisam de ser guardados na memória. São geralmente baseados em propriedades persistentes. For example, if a class object contains as persistent property the gross price and the VAT rate, the net price could be handled by a computed property.

In the class definition file, computed property

En el archivo de definición de la clase, las declaraciones de propiedades calculadas utilizan las palabras claves Function get (getter) y Function set (setter) seguido por el nombre de la propiedad. El nombre debe cumplir con las reglas de nomenclatura de las propiedades.

Función get devuelve un valor del tipo de la propiedad y Function set toma un parámetro del tipo de la propiedad. Ambos argumentos deben cumplir con los parámetros de función estándar.

Cuando ambas funciones están definidas, la propiedad calculada es read-write. Si solo se define una Function get, la propiedad calculada es de solo lectura. Neste caso, é devolvido um erro se o código tentar modificar a propriedade. Se apenas um Function set estiver definido, 4D devolve undefined quando a propriedade é lida.

If the functions are declared in a shared class, you can use the shared keyword with them so that they could be called without Use...End use structure. Para obtener más información, consulte el párrafo Funciones compartidas a continuación.

El tipo de la propiedad calculada es definido por la declaración de tipo $return del *getter *. Puede ser de cualquier tipo de propiedad válido.

Asignar undefined a una propiedad de objeto limpia su valor mientras se preserva su tipo. Para ello, la Function get es llamada primero para recuperar el tipo de valor, luego Function set es llamado con un valor vacío de ese tipo.

Exemplo 1

//Class: Person.4dm
property firstName; lastName : Text

Class constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname

Function get fullName() -> $fullName : Text
$fullName:=This.firstName+" "+This.lastName

Function set fullName( $fullName : Text )
$p:=Position(" "; $fullName)
This.firstName:=Substring($fullName; 1; $p-1)
This.lastName:=Substring($fullName; $p+1)
//num método projecto
$fullName:=$person.fullName // A função get fullName() é chamada
$person.fullName:="John Smith" // A função set fullName() é chamada

Exemplo 2

Function get fullAddress()->$result : Object

$result:=New object

$result.fullName:=This.fullName
$result.address:=This.address
$result.zipCode:=This.zipCode
$result.city:=This.city
$result.state:=This.state
$result.country:=This.country

Class extends <ClassName>

Sintaxe

// Class hijo
Class extends <ParentClass>

La palabra clave Class extends se utiliza en la declaración de clase para crear una clase usuario que es hijo de otra clase usuario. A classe filha herda todas as funções da classe mãe.

A extensão de classe deve respeitar as seguintes regras:

  • Una clase de usuario no puede extender una clase integrada (excepto las 4D.Object y clases ORDA que se extienden por defecto para las clases de usuario).
  • Uma classe de usuário não pode estender uma classe de usuário de outro projeto ou componente.
  • Uma classe usuário não se pode estender a si própria.
  • Não é possível estender classes de forma circular (ou seja, "a" estende "b" que estende "a").
  • No es posible definir una clase usuario compartida extendida a partir de una clase usuario no compartida.

La ruptura de tal regla no es detectada por el editor de código o el intérprete, solo el compilador y comprobar sintaxis arrojará un error en este caso.

An extended class can call the constructor of its parent class using the Super command.

Exemplo

Este ejemplo crea una clase llamada Square de una clase llamada Polygon.

//Class: Square

//path: Classes/Square.4dm

Class extends Polygon

Class constructor ($side : Integer)

// It calls the parent class's constructor with lengths
// provided for the Polygon's width and height
Super($side;$side)
// In derived classes, Super must be called before you
// can use 'This'
This.name:="Square"



Function getArea() -> $area : Integer
$area:=This.height*This.width

Super

Super( ...param : any )
Super : Object

ParâmetroTipoDescrição
paramany->Parâmetro(s) a passar para o construtor pai
ResultadosObject<-Pai do objecto

The Super keyword allows calls to the superclass, i.e. the parent class.

Super tiene dos propósitos diferentes:

  1. Dentro de un código constructor, Super es un comando que permite llamar al constructor de la superclase. Cuando se utiliza en un constructor, el comando Super aparece solo y debe ser usado antes de usar la palabra clave This.
  • Se todos os construtores de classe na árvore de herança não forem correctamente chamados, é gerado o erro -10748. É o programador 4D que se certifica de que as chamadas são válidas.
  • Si el comando This es llamado en un objeto cuyas superclases no han sido construidas, se genera el error -10743.
  • Si se llama a Super fuera de un contexto de objeto, o en un objeto cuyo constructor de superclase ya ha sido llamado, se genera el error -10746.
// dentro do construtor myClass
var $text1; $text2 : Text
Super($text1) //chama o construtor da superclasse com um parâmetro de texto
This.param:=$text2 // usa o segundo parâmetro
  1. Dentro de una función de clase, Super designa el prototipo de la superclase y permite llamar a una función de la jerarquía de superclases.
Super.doSomething(42) //chamada a função "doSomething"  
//declarada em superclasses

Exemplo 1

Este ejemplo ilustra el uso de Super en un class constructor. El comando es llamado para evitar duplicar las partes del constructor que son comunes entre las clases Rectangle y Square.

// Class: Rectangle
Class constructor($width : Integer; $height : Integer)
This.name:="Rectangle"
This.height:=$height
This.width:=$width


Function sayName()
ALERT("Hi, I am a "+This.name+".")

// Function definition
Function getArea()
var $0 : Integer

$0:=(This.height)*(This.width)
//Classe: Square

Classe extends Rectangle

Construtor da classe ($side : Integer)

// Chama o construtor da classe pai com comprimentos
// fornecidos para a largura e altura do Rectangle
Super($side;$side)
// Em classes derivadas, Super tem de ser chamado antes de
// poder usar 'This'
This.name:="Square"

Function getArea()
C_LONGINT($0)
$0:=This.height*This.width

Exemplo 2

Este ejemplo ilustra el uso de Super en un método miembro clase. Ha creado la clase Rectangle con una función:

//Classe: Rectângulo

Function nbSides()
var $0 : Text
$0:="I have 4 sides"

También creó la clase Square con una función que llama a la función superclase:

//Classe: Quadrado

Class extends Rectangle

Function description()
var $0 : Text
$0:=Super.nbSides()+" que são todos iguais"

Depois pode escrever num método projecto:

Parâmetros

This

This : Object

ParâmetroTipoDescrição
ResultadosObject<-Objecto actual

The This keyword returns a reference to the currently processed object.

En la mayoría de los casos, el valor de This está determinado por cómo se llama una función. Não pode ser definido por atribuição durante a execução e pode ser diferente de cada vez que a função é chamada.

Cuando se llama a una fórmula como método miembro de un objeto, su This se define en el objeto sobre el que se llama al método. Por exemplo:

$o:=New object("prop";42;"f";Formula(This.prop))
$val:=$o.f() //42

When a class constructor function is used (with the new() function), its This is bound to the new object being constructed.

//Class: ob Class Constructor  

// Create properties on This as
// desired by assigning to them
This.a:=42
// num método 4D  
$o:=cs.ob.new()
$val:=$o.a //42

Al llamar a la superclase del constructor en un constructor utilizando la palabra clave Super, tenga en cuenta que This no debe ser llamado antes del constructor de la superclase, de lo contrario se genera un error. Ver este ejemplo.

En todos los casos, This se refiere al objeto sobre el que se ha llamado el método, como si el método fuera una función del objeto.

//Class: ob Function f()
$0:=This.a+This.b

Depois pode escrever num método projecto:

$o:=cs.ob.new()
$o.a:=5
$o.b:=3
$val:=$o.f() //8

En este ejemplo, el objeto asignado a la variable $o no tiene su propia propiedad f, la hereda de su clase. Como f es llamado como un método de $o, su This se refiere a $o.

Comandos de classe

Vários comandos da linguagem 4D permitem-lhe lidar com funcionalidades de classe.

OB Class

OB Class ( object ) -> Object | Null

OB Class devuelve la clase del objeto pasado como parámetro.

OB Instance of

OB Instance of ( object ; class ) -> Boolean

OB Instance of devuelve true si object pertenece a la class o a una de las clases heredadas y false de lo contrario.

Classes compartilhadas

Puede crear clases compartidas. A shared class is a user class that instantiates a shared object when the new() function is called on the class. Uma classe compartilhada só pode criar objetos compartilhados.

Shared classes also support shared functions that can be called without Use...End use structures.

The .isShared property of Class objects allows to know if the class is shared.

info

Criação de uma classe compartilhada

Para crear una clase compartida, añada la palabra clave shared antes del Class Constructor. Por exemplo:

    //shared class: Person
shared Class Constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname

//myMethod
var $person := cs.Person.new("John"; "Smith")
OB Is shared($person) // true
cs.Person.isShared //true

Funções compartilhadas

If a function defined inside a shared class modifies objects of the class, it should call Use...End use structure to protect access to the shared objects. Sin embargo, para simplificar el código, puede definir la función como compartida, de modo que active automáticamente un Use...End use interno cuando se ejecute.

Para crear una función compartida, añada la palabra clave shared antes de la palabra clave Function en una clase compartida. Por exemplo:

    //shared class Foo
shared Class Constructor()
This.variable:=1

shared Function Bar($value : Integer)
This.variable:=$value //no need to call use/end use
nota

Si se utiliza la palabra clave shared en una clase usuario no compartida, se ignora.

Classes Singleton

Una clase singleton es una clase usuario que sólo produce una única instancia. Para más información sobre los singletons, por favor consulte la página Wikipedia sobre los singletons.

The class singleton is instantiated at the first call of the cs.<class>.me property. The instantiated class singleton is then always returned when the me property is used.

If you need to instantiate a singleton with parameters, you can also call the new() function. Nesse caso, é recomendado instanciar o singleton em algum código executado no início da aplicação.

O escopo de uma instância singleton pode ser o processo atual ou todos os processos. Un singleton process tiene un valor único para el proceso en el que se instancia, mientras que un singleton interprocess tiene un valor único para todos los procesos de la aplicación. Singletons são úteis para definir valores que precisam estar disponíveis em qualquer lugar em um aplicativo ou processo.

The .isSingleton property of Class objects allows to know if the class is a singleton.

info

Las clases Singleton no están soportadas por las clases ORDA.

Criação de um singleton process

To create a process singleton class, add the singleton keyword before Class Constructor. Por exemplo:

    //class: ProcessTag
singleton Class Constructor()
This.tag:=Random

Para usar o singleton process:

    //in a process
var $mySingleton := cs.ProcessTag.me //First instantiation
//$mySingleton.tag = 5425 for example
...
var $myOtherSingleton := cs.ProcessTag.me
//$myOtherSingleton.tag = 5425

    //in another process
var $mySingleton := cs.ProcessTag.me //First instantiation
//$mySingleton.tag = 14856 for example
...
var $myOtherSingleton := cs.ProcessTag.me
//$myOtherSingleton.tag = 14856

Criação de um singleton interprocesso

Para crear un singleton interprocess, añada las palabras claves shared singleton antes del Class Constructor. Por exemplo:

//Class VehicleFactory

property vehicleBuilt : Integer

shared singleton Class constructor()
This.vehicleBuilt := 0 //Number of vehicles built by the factory

shared Function buildVehicle ($type : Text) -> $vehicle : cs.Vehicle

Case of
: $type="car"
$vehicle:=cs.Car.new()
: $type="truck"
$vehicle:=cs.Truck.new()
: $type="sport car"
$vehicle:=cs.SportCar.new()
: $type="motorbike"
$vehicle:=cs.Motorbike.new()
Else
$vehicle:=cs.Car.new()
End case
This.vehicleBuilt+=1

Luego puede llamar al singleton cs.VehicleFactory para obtener un nuevo vehículo desde cualquier lugar de su aplicación con una sola línea:

$vehicle:=cs.VehicleFactory.me.buildVehicle("caminhão")

Dado que la función buildVehicle() modifica el singleton cs.VehicleFactory (incrementando This.vehicleBuilt), debe agregar la palabra clave shared.

Veja também

Ver también esta entrada de blog para más detalles.