langthang’s Weblog

UML 2.0 comporte ainsi treize types de diagrammes

Diagrammes structurels ou diagramme statiques

1. diagramme de classe
2. diagramme d’objet
3. diagramme de composants
4. diagramme de déploiment
5. diagramme de paquetages
6. diagramme de structures composites

Diagrammes comportementaux ou diagramme dynamiques

1. diagramme de cas d’utilisation
2. diagramme d’activités
3. diagramme d’états-transitions
4. diagramme d’interaction
5. diagramme de séquence
6. diagramme de communication
7. diagramme global d’interaction
8. diagramme de temps

Comment présenter un modèle UML ?

la présentation d’un modèle UML se compose de plusieurs documents écrits en langage courant et d’un document formalisé.

1. Présentation stratégique : Elle décrit pourquoi l’entreprise a voulu se doter de l’outil considéré, les buts qu’elle cherche à atteindre, le calendrier de réalisation prévu, etc..
2. Présentation des processus de travail par lesquels la stratégie entend se réaliser : Pour permettre au lecteur de voir comment l’application va fonctionner en pratique, elle doit être illustrée par une esquisse des écrans qui seront affichés devant les utilisateurs de terrain.
3. Explication des choix qui ont guidé la modélisation formelle: Il s’agit de synthétiser, sous les yeux du lecteur, les discussions qui ont présidé à ces choix.
4. Modèle formel: c’est le document le plus épais et le plus difficile à lire. Il est préférable de le présenter sur l’Intranet de l’entreprise. En effet, les diagrammes peuvent être alors  équipés de liens hypertextes permettant l’ouverture de diagrammes plus détaillés ou de commentaires.

Quand on rencontre un problème, d’abord on peut l’ approcher des différences.

A class that is declaresd within another type declaration is call a nested type(nested class).

• Top-level class is one that is not nested

In addition, to the top-level types, thes are four categories of nested class

1. static member classes, enums, inteface
2. non-static member classes
3. local classes
4. anonymous classes

Pour les enumeration type  et interface type, il n’ai pas implementation => il est tjs static type.

class TLC { // (1) Top level class
static class SMC {/*…*/} // (2) Static member class
interface SMI {/*…*/} // (3) Static member interface
class NSMC {/*…*/} // (4) Non-static member (inner) class
void nsm() {
class NSLC {/*…*/} // (5) Local (inner) class in non-static context
}
static void sm() {
class SLC {/*…*/} // (6) Local (inner) class in static context
}
SMC nsf = new SMC() { // (7) Anonymous (inner) class in non-static context
/*…*/
};
static SMI sf = new SMI() { // (8) Anonymous (inner) class in static context
/*…*/
};
enum SME {/*…*/} // (9) Static member enum
}

Nest type can be regarded  as a form  of encapsulation, enforcing relationship between types by greater proximity. They allow structures  type and a special binding relationship between a nested object and its enclosing instance.

A static class must be declared avec explicite keyword static, pendant enum, et interface pas besoin.

Pour inport nest type , import and static import est équivalent.

//Filename: ListPool.java
public class ListPool { // Top-level class
public void messageInListPool() { // Instance method
System.out.println(« This is a ListPool object. »);
}
private static class MyLinkedList { // (1) Static class
private static int maxNumOfLists = 100; // Static variable
private int currentNumOfLists; // Instance variable
public static void messageInLinkedList() { // Static method
System.out.println(« This is MyLinkedList class. »);
}
interface ILink { int MAX_NUM_OF_NODES = 2000; } // (2) Static interface
protected static class Node implements ILink { // (3) Static class
private int max = MAX_NUM_OF_NODES; // (4) Instance variable
public void messageInNode() { // Instance method
// int currentLists = currentNumOfLists; // (5) Not OK.
int maxLists = maxNumOfLists;
int maxNodes = max;
// messageInListPool(); // (6) Not OK.
messageInLinkedList(); // (7) Call static method
}
public static void main (String[] args) {
int maxLists = maxNumOfLists; // (8)

// int maxNodes = max; // (9) Not OK.
messageInLinkedList(); // (10) Call static method
}
} // Node
} // MyLinkedList
} // ListPool

Non-static member class : can only exist with an instant of it enclosing class => don’t have static member, however final static variable are allowed, as these constant.

A special form of the new operator is used to non static class.

<enclosing object reference>.new <non-static member class constructor call>

expression

<enclosing object reference>.this : evaluates to reference that denotes the enclosing object.

Pour extends un type class :

class OuterA { // (1)
class InnerA { } // (2)
}
//_____________________________________________________________________________
class SubclassC extends OuterA.InnerA { // (3) Extends NSMC at (2)
// (4) Mandatory non-default constructor:
SubclassC(OuterA outerRef) {
outerRef.super(); // (5) Explicit super() call
}
}
//_____________________________________________________________________________
class OuterB extends OuterA { // (6) Extends class at (1)
class InnerB extends OuterB.InnerA { } // (7) Extends NSMC at (2)
}
//_____________________________________________________________________________
public class Extending {
public static void main(String[] args) {
// (8) Outer instance passed explicitly in constructor call:
new SubclassC(new OuterA());
// (9) No outer instance passed explicitly in constructor call to InnerB:
new OuterB().new InnerB();
}
}

Local class : ce sont des classe qui définissent dans les block {}, static ou non-static.

Quelque restriction:

1. Local classe can not have static member. Hower final staic  are allow
2. Local class can not have any accessibility modifier. The declaration of the class is only accessible in the context  of the block in which it is defined.

Access non final local variable is not permitted from local classes.

Declaration dans local class can hide variable dans local block, and there is no way for the local class to refer to such hide declarations.