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

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.

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

association class allows you to add operaions  ,attributes 
and other features to associations.

attribute is a member of a class where as
Association is a relationship of one class to another

Associations represent relationships between instance of 
classes.Attributes are very similar to accociation.From the 
conceptual perspective,there is no difference.the 
difference occurs at the specification and implementation 
level

The Object Constraint Language is a declarative language 
for describing rules that apply to UML models developed at 
IBM and now part of the UML standard. Initially OCL was 
only a formal specification language extension to UML. OCL 
may now be used with any Meta-Object Facility OMG 
metamodel, including UML. The Object Constraint Language is 
a precise text language that provides constraint and object 
query expressions on any Meta-Object Facility model or 
metamodel that cannot otherwise be expressed by 
diagrammatic notation. OCL is a key component of the new 
OMG standard recommendation for transforming models, the 
QVT specification.

Class Responsibility Collaborator (CRC cards) are a 
brainstorming tool used in the design of object-oriented 
software. They were proposed by Ward Cunningham and Kent 
Beck. [1] They are typically used when first determining 
which classes are needed and how they will interact.

CRC cards are usually created from index cards on which are 
written:

The class name 
Its Super and Sub classes (if applicable) 
The responsibilities of the class. 
The names of other classes with which the class will 
collaborate to fulfill its responsibilities. 
Author 
Using a small card keeps the complexity of the design at a 
minimum. It focuses the designer on the essentials of the 
class and prevents him from getting into its details and 
inner workings at a time when such detail is probably 
counter-productive. It also forces the designer to refrain 
from giving the class too many responsibilities. Because 
the cards are portable, they can easily be laid out on a 
table and re-arranged while discussing a design with other 
people.

A common method to determine what cards should be created 
is to read a specification for the program being designed 
and consider if each noun should be a class and if each 
verb should be a responsibility of the noun or class to 
which it belongs. Naturally, the existence of a noun or 
verb does not require a class or responsibility in the 
program, but it is considered a good starting point.

Lets assume i've a Web Application where different kind of 
users can login based on their own credentials 
provided....and we implemented the login mechanism for the 
same....so now different users ( Actor ) has to interact 
with the login use case to get the access into the sys ...

consider a banking(ATM) application.
consider login. acustomer is an actor.also bank staff also 
actors who actually deposit money in ATM. their previleges 
are different.

in libray application, for usecase reserve book can be by 
students,staff and also other actors.

noramally you will move common functinality in base class 
or create the abstract class with common concrete methods 
and leave remaining for implemenetation also you can create 
interfaces.

If the concept leads to any functionality to the system, 
then should be part of class as a Method.

notation

UML is a method where u can show the flow of ur project 
overflow which is represented in symbolic diagram.
 
UML is a method.. methods which help us in undersatnding.

UML is neither process nor notation it is method which is 
followed in application/software development practice.
UML is devised for Object oriented approach for development 
process, that's why it is very well suited for Java & dot 
net enviroment.
Rather we can say UML follows certain set of standard 
notation from requirement analysis phase to development & 
testing.(Code generation Techniques) 
For example: system analyst/business analyst and Tech 
Architects uses UML very frequently.