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.

• L’analyse du besoin
• L’élaboration des spécifications
• La conception
• Le développement
• La phase de test
• La maintenance

Notion de qualité pour un logiciel

• Validité : Aptitude d’un produit logiciel à remplir exactement ses fonctions, définies par les cahier des charges et les spécification
• Fiabilité ou robustesse: Aptitude d’un produit logiciel à fonctionner dans des conditions anormales.
• Extensibilité(maintenance) : Facilité avec laquelle un logiciel se prête à sa maintenance, c’est-à-dire à une modification ou une extension des fonctions qui lui sont demandées.
• Réutilisabilité: Aptitude d’un logiciels à être réutilisé, en tout ou en partie, dans de nouvelles applications.
• Compatibilité: facilité avec laquelle un logiciel peut être combiné avec d’autres logiciels.
• Efficacité: Utilisation optimales des ressources matérielles
• Portabilité; facilité avec laquelle un logiciel peut être transféré sous différents environnements matériels et logiciels
• Vérifiabilité: facilité de préparation des procédures de test
• Intégrité: aptitude d’un logiciel à protéger son code et ses données contre des accès non autorisé
• Facilité d’emploi: facilité d’apprentissage, d’utilisation, de préparation des données, d’interprétation des erreurs et de rattrapage en cas d’erreur d’utilisation

Qui doit modéliser ?

Le maître mot modélisation

Maîtrise d’ouvrage et maîtrise d’uvre

Maître d’ouvrage (MOA) : Le MOA est une personnes morale(entreprise, direction, etc…) une entité de l’organisation. ce n’est jamais une personne

Maître d’uvre (MOE): Le MOE est une personne morale, garante de la bonne réalisation technique des solutions. Il a, alors de la conception du SI, un devoir de conseil vis-à-vis du MOA, car le SI doit tirer le meilleur parti des possibilités, techniques.

Le MOA est client du MOE à qui il passe commande d’un produit nécessaire à son activité

le MOE fourmit ce produit, soit il le réalise lui-même, soit il pass commande à un ou plusieurs fournisseurs qui élaborent le produit sous sa direction.

la relation MOA et MOE est définie par un contrat qui précise leurs engagements mutuels.

Le cycle de vie d’un logiciel

Le cycle de vie du logiciel comprend généralement au minimum les étape suivantes:

• Définition des objectifs: Cet étape consiste à définir la finalité du projet et son inscription dans une stratégie globale.
• Analyse des besoins et faisabilité: C’est-à-dire l’expression, le recueil et la formalisation des besoin du demandeur(le client) et de l’ensemble des contraintes, puis l’estimation de la faisabilité de ces besoins.
• Spécifications ou conception générale: il s’agit de l’élaboration des spécifications de l’architecture générale du logiciel.
• Conception détaillée: Cette étape consiste à définir précisément chaque sous-ensemble du logiciel
• Codage(implémentation ou programmation): c’est la traduction dans un langage de programmation des fonctionnalités lors de phase de conception
• Test unitaires: Ils permettent de vérifier individuellement que chaque sous-ensemble du logiciel est implémenté conformément aux spécifications
• Intégration L’objectif est de s’assurer de l’interfaçage des différents éléments(modules) du logiciel. Elle fait l’objet de tests d’intégration consignés dans un document.
• Qualification( our recette): c’est_à-dire la vérification de la conformité du logiciel aux spécifications initiales
• Documentation: Elle vise à produire les informations nécessaires pour l’utilisation du logiciel et pour des développements ultérieurs
• Mise en production: c’est le déploiement sur site du logiciel
• Maintenance: Elle comprend toutes les actions correctives (maintenance corrective) et évolutives (maintenance évolutives) sur le logiciel

Modèles de cycles de vie d’un logiciel

Préparez quelques situations inhabituels.

Sachez bien qu’est que vous êtes en train de dire

ceci est très important d’avoir des connaissances étendues sur le sujet que vous supposez d’en parler. Lisez des livres et fait la recherche d’information sur internet. Préparez-vous un court note sur des important questions et les lisez quatre fois. Et bien les notes préparés sont le clé pour organiser les connaissances. Il est évident que vous ne pouvez pas vous rappeler tous ce que vous voulez parler(et il est même déconseillé que les apprendre par coeur). Mais quand vous avez des bonnes notes ils seront une sorte de réseau qui permettra de connexion d’un point à un autre. En cas de perdu  vous pouvez faire une vérification rapide et revenir immédiatement sur la bonne voie.

2. Mọi người sẽ không bao giờ ngó ngàng đến lòng tự trọng của bạn, điều mà họ quan tâm chính là thành tựu mà bạn đạt được. Do đó, trước khi có được những thành tựu thì bạn đừng nên quá chú trọng hay cường điệu lòng tự trọng của bản thân mình lên.
(Lòng tự trọng quá cao sẽ tỷ lệ thuận với sự bất lợi trong công việc của bạn)

3. Thường thì bạn sẽ không thể trở thành CEO nếu chỉ mới tốt nghiệp trung học. Nhưng khi bạn đã trở thành một CEO thì không còn ai để ý là bạn mới chỉ có tốt nghiệp trung học nữa.
(Lúc này người ta sẽ đánh giá và quan tâm nhiều đến năng lực hơn là bằng cấp của bạn)

4. Khi bạn gặp khó khăn hay bế tắc trong công việc thì đừng có oán trách số phận. Điều bạn học được khi gặp trắc trở chính là kinh nghiệm và bài học để lần sau không bao giờ mắc phải nữa.
(Điều cần làm lúc này là trấn tĩnh và bắt tay làm lại từ đầu)

5. Nên hiểu một điều rằng: Trước khi có bạn, bố mẹ bạn không phải là những người “chán ngắt, vô vị” như bạn của ngày hôm nay đã nghĩ. Đây chính là cái giá rất lớn mà bố mẹ đã phải trả cho sự trưởng thành của bạn.
(Bạn phải có nghĩa vụ đền đáp công ơn với những người đã dành cả cuộc đời mình cho sự sống và trưởng thành của bạn)

6. Khi đi học, bạn đứng thứ mấy trong lớp cũng không phải là vấn đề quan trọng. Nhưng khi đã bước chân ra xã hội thì mọi việc lại không đơn giản như vậy. Dù đi đâu hay làm công việc gì bạn cũng nên tạo đẳng cấp cho mình.
(Luôn tự nhủ rằng bạn sẽ luôn là người đứng đầu, như vậy bạn sẽ có động lực và tinh thần nhiều hơn cho sự nghiệp của bản thân)

7. Khi đi học, bạn luôn mong chờ đến ngày nghỉ lễ, Tết. Khi đi làm thì hoàn toàn không giống vậy, dường như là bạn sẽ không được nghỉ ngơi. Công việc sẽ cuốn bạn đi bất cứ lúc nào kể cả ngày nghỉ.
(Nếu là một nhân viên luôn mong chờ ngày nghỉ lễ thì bạn sẽ bị lạc hậu hơn so với những nhân viên khác. Sự lạc hậu này còn luôn đồng hành với sự đào thải và thất nghiệp).

8. Khi ngồi trên ghế nhà trường, lúc gặp khó khăn trong học tập thì có giáo viên giúp đỡ bạn. Tuy nhiên, nếu lúc đó bạn lại cảm thấy mọi khó khăn đều do những yêu cầu quá nghiêm khắc từ phía giáo viên thì bạn đừng nên đi làm sau khi tốt nghiệp. Đơn giản nếu như không có những yêu cầu nghiêm khắc từ phía công ty thì chắc chắn bạn sẽ không làm được gì và sẽ nhanh chóng thất nghiệp, hơn nữa lúc này sẽ không có ai giúp đỡ bạn cả.
(Nên nhận thức được rằng: Công ty sẽ luôn yêu cầu cao hơn rất nhiều so với trường học. Vì ở trường học, dù bạn có học được hay không thì chỉ ảnh hưởng đến cá nhân bạn. Còn ở công ty bạn có làm được việc hay không thì lại ảnh hưởng đến rất nhiều người)

9. Mọi người đều thích xem phim truyền hình, nhưng bạn không nên xem nhiều vì đó không phải là cuộc sống của bạn. Vì công việc ở công ty mới phản ánh cuộc sống thực của bạn.
(Bạn không nên xem nhiều vì tư tưởng của bạn sẽ bị ảnh hưởng bởi những bộ phim truyền hình đó. Cuộc sống của bạn nên do bạn quyết định)

10. Không bao giờ phê bình người khác sau lưng của họ, đặc biệt đừng bao giờ phê phán sếp là người không có năng lực, điều này là không đúng.
(Nếu bạn có thắc mắc gì trong công việc thì nên nói ý kiến của mình trước mặt mọi người. Còn nếu như bạn luôn giữ thái độ và hành động phản kháng sau lưng người khác thì chỉ có bất lợi cho bạn mà thôi).

• 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.

Field access is determined by the declared type of the reference, whereas the instance method to execute is detemined by the actual type of the object denoted by reference…(not dans le cas everload).

Static method can not be override, but it can be hide(declared a same method).

The super() constructor has the same restriction as the this() : the super() must be occur as the first statement in a constructor. and it can be used only in the contructor declaration.

Is a super only defines non default constructor, its subclasses can not rely on the implicit super() call being inserted.

Interface

<accessibility modifier> interface <interface> <extends interface clause>

{

<constant declarations>

<abstract method declarations>

<nested class declarations>

<nested interface declarations>

}

interface member implicitly have public accessiblity and the public modifier can be ommited.

dans le UML diagram interface est comme classe sauf <interface> typographe. le génération

An interface can also define named constant, Such constant are defined by field declaration and are considered to be public static final.

When defining a set of related constants, the recommended pratictice is to use an enumerated type, rather than named constants in an interface.

interface Constants {

double PI_APPROXIMATION = 3.14;

String AREA_UNIT = « sq.cm » ;

}

Interface est consideré come class qui est extends par une classes. Field in interface are always static, and can be declared static explicity. Abstract method declarations in interface are always non static and cannot be declare static.

StackImpl [] stackImplArray = new SafeStakImpl[2]

Since StackImpl is a supertype of SafeStackImpl object.

stackImplArray[0] = new SafeStackImpl(10);

mais stackImplArray[1] = new StackImpl(20); // ArrayStoreException

At compile time there are no problems, as the complier cannot deduce that the array variable stackImplArray will actually denote a SafeStackImpl[] object.

Reference values and Conversions

Reference values, like primative values, can be assigned, cast, and passed as arguments. Conversion can occur in the following contexts:

• assignment
• method invocation
• casting

The rule of the thumb for the primative data type is that widening conversions are permitted, but narrowing conversion require an explicited cast.

The rule of thumb for reference values is that widening conversions up the type hierachy are permitted, but narrowing conversions down the hierachy require an explicite cast. In other words, conversions that are from a subtype to is supertypes are allowed,other conversion require an explicit cast or are otherwise illegal.

• Widening primative and reference conversion ; long <= int, Object <= String…. not apply to Bowing type, (Long <= Integer…. false)
• Number <= Long, Integer…. est root de tout les Boxing type.

When a non-private instanse methode is invoked on an object, theq methode definition actually executed is determined both by the type of the object at runtime and  the methode signature.

Basic Concepts inObject-Oriented Design

• Encapsulation
• Cohesion
• Coupling : Coupling is an mesure of intra-class dependencies. Objects need to interact with each other, therefore denpendencies between classes are inherent in OO design. However, these dependencies should be minimized in order to achiveve loose coupling, wich aids in creating extensible application.

Wrapper objects are immuable, but the following values are interned when they are wrapped during boxing

• boolean : true, false
• byte : -128:127
• short,int -128:127
• char ! \u0000 :  \u007F

10.101.0.4 : orchid.active-system.com

• ssl.conf : httpsserverproxy: /local/areas => /media/local/areas
• httpd.conf: /reporting1 => https://reporting1.yllio.com

10.101.0.5:reporting1.yllio.com

• httpd.conf : serverroot = /home/media/client

ipconfig /fluchdns

Répertoire Tomcat :  var/lib/tomcat

réportoire log : var/log

répertoire httpd: etc/httpd