Structural(modular) representation of ur system requiremnt 
is UML, Usecase is one of them.
Use Case is setup activity done by actor, Here actor should 
think How to do, Not What to do.
You should know ur functional requirment of ur systemk 
before starting usecase diagram.
Here requirement can not be derived only function can be 
derived.

Include, one cannot live without the other. The use case 
must include another use case. For example when you create 
an order you always must verify name etc. 

Extend, one can live without the other only some instances 
the use case will extend to another use case to do some 
stuff. For example, you can create an order but if the 
order is for a new customer you possible have to do 
additional check which you do not have to do for existing 
customers. In that case you can have an extend use case.

For Component:- A Component may use interface called import
                A Component may realiase from interface 
called export

An Extends relationship is exactly like an Includes
relationship with one important difference: An Extends
relationship is a conditional include

Include: Can not be completed without the included use case. For example To order an item, one must select the item while extends is executed on an particular event for example View Report extends print report.

Extend - if a use case is optional for another use case. 
that is defiend using extend; if a use case should be 
called another use case to accompalish a functionlity ,it 
will be represented as include.

Both Sequence and Collaboration diagrams are interaction
diagrams. The difference is that Sequence diagrams describes
the interaction between classes against time. In
Collaboration diagram the interaction between classes is
shown against both time and space (the relationship between
classes can also be shown). The sequence in this case is
depicted by numbering. You may want to check out some sample
sequence and collaboration diagram to understand this more.

Composition that is used to store several instances of the 
composited data type is referred to as containment. 
Examples of such containers are arrays, linked lists, 
binary trees and associative arrays.

In UML, containment is depicted with a multiplicity of 1 or 
0..n (depending on the issue of ownership), indicating that 
the data type is composed of an unknown amount of instances 
of the composited data type.

Persistent objects are on this heap, while transient 
objects are in the transient memory. Transient and 
persistent objects can access each other mutually. 
Accessing a persistent object leads to loading the object 
into the transient heap. It it is not accessed from 
transient objects any more, it will be written back to the 
persistent heap. A transient object becomes persistent as 
soon as it can be reached from a persistent root

Persistent is permanent storage and transient is for memory.
Persistemt objects when call transient objets ,first it is 
loaded into memory.After process a transient objects can be 
stored as persitent objects in hard disk.

data is stored in the class so the object of that class 
having dynamic bindig is called transient class object 
where data that is not changed and static binding is 
applied to it is of persistent base class object:

persistent is related to static
where as transient is related to dynamic

it means leaving the implementation to the implementer, 
i.e. interface. you leave the implementation of 
functionality to the class who is implementing this 
interface

In a realization relationship, one entity (normally an 
interface) defines a set of functionalities as a contract 
and the other entity (normally a class) "realizes" the 
contract by implementing the functionality defined in the 
contract.

It is similar to generalization.It indicates that one class 
implements behavior specified by another.

Realization denotes implementing an interface.Arrow with 
dotted line 
Generalization denotes extending a class.Arrow with solid 
line.

I just want to add that realization is not only for 
interfaces or class it is also for use cases and use case 
realizations is to design its inner diagrams like sequence 
diagram …etc.

Constraint rule:
     Much of what you are doing in drawing a class diagram 
is indicating constraint.

     EX:Corporate customers have credit limits but Personal 
customer do not.

Design by contract:
     It provides rigorous defn. of operation's purpose and 
class's legal state. This is to enhance the debugging.

Dynamic classification allows objects to change type within 
the subtyping structure whereas static classification does 
not Ex:for dynamic classification is person's job(It can 
change).EX:for static classification sex.(male & female).

static means constant. Dynamic means randomly we can change 
in genral sences. So, static diagram we can not change it 
si fixed attributes but dynamic diagram we can change. As 
given example:- person job is attribut we can change the 
job . so, it is dynamic but sex of person male / female we 
canot change it is static