Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:48:43Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' [http://en.wikipedia.org/wiki/Precondition] Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.




• '''Postconditions -''' [http://en.wikipedia.org/wiki/Postcondition] The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.




• '''Class invariant -''' [http://en.wikipedia.org/wiki/Invariant_%28computer_science%29] The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive. This will always be satisfied, since, the getage() method returns the value of the same variable that is set using the setage() method, and the setage() method will never allow that value to be negative.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/
http://www.developer.com/lang/article.php/10924_3642656_1
http://wwwse.inf.tu-dresden.de/data/courses/ws07/lab/session2.pdf
http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:48:01Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' [http://en.wikipedia.org/wiki/Precondition] Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.




• '''Postconditions -''' [http://en.wikipedia.org/wiki/Postcondition] The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.




• '''Class invariant -''' [http://en.wikipedia.org/wiki/Invariant_%28computer_science%29] The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive. This will always be satisfied, since, the getage() method returns the value of the same variable that is set using the setage() method, and the setage() method will never allow that value to be negative.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/
http://www.developer.com/lang/article.php/10924_3642656_1
http://wwwse.inf.tu-dresden.de/data/courses/ws07/lab/session2.pdf
http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:39:18Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' [http://en.wikipedia.org/wiki/Precondition] Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.




• '''Postconditions -''' [http://en.wikipedia.org/wiki/Postcondition] The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.




• '''Class invariant -''' [http://en.wikipedia.org/wiki/Invariant_%28computer_science%29] The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive. This will always be satisfied, since, the getage() method returns the value of the same variable that is set using the setage() method, and the setage() method will never allow that value to be negative.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:37:33Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' [http://en.wikipedia.org/wiki/Precondition] Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.




• '''Postconditions -''' [http://en.wikipedia.org/wiki/Postcondition] The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.




• '''Class invariant -''' [http://en.wikipedia.org/wiki/Invariant_%28computer_science%29] The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive. This will always be satisfied, since, the getage() method returns the value of the same variable that is set using the setage() method.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:34:53Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' [http://en.wikipedia.org/wiki/Precondition] Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.




• '''Postconditions -''' [http://en.wikipedia.org/wiki/Postcondition] The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.




• '''Class invariant -''' [http://en.wikipedia.org/wiki/Invariant_%28computer_science%29] The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:32:45Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –




• '''Preconditions -''' Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.




• '''Postconditions -''' The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.




• '''Class invariant -''' The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.




<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:29:51Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract [http://en.wikipedia.org/wiki/Design_by_contract] is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:27:28Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

[[http://en.wikipedia.org/wiki/Design_by_contract]] Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-27T04:24:48Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

[http://en.wikipedia.org/wiki/Design_by_contract] Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:52:17Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29
http://www.artima.com/intv/contracts.html
http://archive.eiffel.com/doc/manuals/technology/contract/

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:49:21Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:48:27Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References & External Links==

http://en.wikipedia.org/wiki/Design_by_contract
http://en.wikipedia.org/wiki/Precondition
http://en.wikipedia.org/wiki/Postcondition
http://en.wikipedia.org/wiki/Invariant_%28computer_science%29

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:46:30Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References==

(1) http://en.wikipedia.org/wiki/Design_by_contract

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:20:50Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.
The fact that the stack is a valid one is always true. Also, whenever a pop operation is done on an empty stack, a value of -1 is returned. Since these two things never change, they are the class invariants.




Whenever any element is to be added to the stack, the client needs to make sure that the element is positive and that it is an integer. These two requirements are the preconditions.



Also, the stack needs to ensure that whenever a push operation is performed on it, the old stack and the new resulting stack are never the same and the size of the new stack is one more than that of the old one. It also needs to ensure, that the top method always returns the latest inserted element i and if that element i is popped out, the resulting stack is the same as the old one.


==References==

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:12:16Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>




The above implementation shows a stack of positive integers. The stack has no limit on the number of elements in it.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:09:10Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns
" " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a
stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-18T01:08:36Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).


===Stack of integers===


<pre>

public class Stack {

/* @ public invariant
@ \forall (isValidstack() == true)
\forall (s.isEmpty == true <==> s.pop() == -1)
@ */

public Stack() { ... }

/*@ normal behavior //non-exceptional specification
@ // precondition
@ requires i > 0
@ requires i % 1 == 0
@ //postcondition
@ ensures \this.toString != \old.toString
@ ensures \this.size() == \old.size + 1
@ ensures \this.top() == i
@ ensures \this.contains(i) == true
@ ensures \this.pop() == \old
@ */

//push adds a given element to the top of the stack leaving previous elements below
public void push(int i){ ... }

// pop removes the current top element of the stack
public int top() { ... }

// isEmpty checks whether the stack is empty or not
public boolean isEmpty() { ... }

//contains checks whether the stack contains the given element or not
public boolean contains(int i) { ... }

//size queries the number of elements stored in the stack
public int size() { ... }

/* toString returns a string to represent the stack content. For example, it returns " " for an empty stack; "8;" for a stack containing only one element 8, "8;9;" for a stack containing 2 elements 8 and 9 */
public String toString() { ... }

//isValidStack checks whether the stack has valid state;
public boolean isValidStack();
}

</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:53:52Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of eps (0.0001).

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:53:24Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.


===Calculating the square root===


<pre>

public class SqrtExample {

public final static double eps = 0.0001;

//@ requires x >= 0.0;
//@ ensures JMLDouble.approximatelyEqualTo(x, \result * \result, eps);

public static double sqrt (double x) {
return Math.sqrt(x);
}

}

</pre>



In the above example, the caller of the sqrt method (the client) needs to make sure that it is trying to find the
square root of a positive number. This is the precondition. The post condition is that the method sqrt will calculate the square root of x to a precision of 0.0001.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:38:21Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

Precondition Postcondition
Supplier Benefit Obligation
Client Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:37:17Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>



<pre>

'''Precondition''' ''' Postcondition'''
'''Supplier''' Benefit Obligation
'''Client ''' Obligation Benefit
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:36:26Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>




'''Precondition''' ''' Postcondition'''
'''Supplier''' Benefit Obligation
'''Client ''' Obligation Benefit

==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:26:40Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:26:23Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>



In the above example, the precondition for the setter method setAge is that the value of the input parameter being passed (the age of the person) should always be positive. Also, the getter method getAge has to satisfy the postcondition (obligation) that the age of the person on whom the method has been invoked is always positive.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:23:40Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>


==Examples==

=== A simple interface ===


<pre>

interface Person {

/** age always positive
* @post return > 0
*/

int getAge();

/** age always positive
* @pre years > 0
*/

void setAge (int years);

}

class Employee implements Person {

private int age;

public int getAge() {
return age;
}

public void setAge (int years) {
age = years;
}

}
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:02:37Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a '''contract''' which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind programming by contract is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T17:01:15Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each program component has a "contract" which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in human understandable form rather than something syntactical.
eg- When given a positive real number, this function calculates its square root.
This contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind "programming by contract" is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:57:02Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==


Programming by contract is a way of designing programs. Each part of a program has a "contract" which specifies how it should cooperate with the rest of the program.



This documentation is usually only written in a form that humans understand, something like "When given a positive real number, this function calculates its square root". Note that this contract contains two parts, the input spesification (postive real number) and the output specification (calculates the square root).



The idea behind "programming by contract" is that one should make as much of this information available to the computer as possible. This means that the system itself can catch a lot of the simple errors programmers make.



The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –



<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:53:08Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as
pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:52:45Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:52:22Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are called as pre-conditions. The module making the call is called the client. The preconditions are the obligations that the client needs
to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle
cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of
properties are called the supplier's postconditions. These postconditions are obligations for the supplier, and benefits for
the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on
exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:51:26Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software component are
called as pre-conditions. The module making the call is called the client. The preconditions are the obligations
that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the
supplier from having to handle cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These
set of properties are called the supplier's postconditions. These postconditions are obligations for the supplier,
and benefits for the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry and is
guaranteed on exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:50:04Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Preconditions - Certain obligations need to be fulfilled by any module which calls the software
component are called as pre-conditions. The module making the call is called the client. The preconditions
are the obligations that the client needs to fulfill and are benefits for the software component, called the
supplier, as it frees the supplier from having to handle cases outside of the precondition.

• Postconditions - The supplier in turn, needs to guarantee certain outputs or certain properties on
exit. These set of properties are called the supplier's postconditions. These postconditions are obligations
for the supplier, and benefits for the client obtained from calling the supplier module.

• Class invariant - The supplier needs to maintain a certain property that is assumed to exist on entry
and is guaranteed on exit, called the class invariant.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:48:16Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


<pre>
• Certain obligations need to be fulfilled by any module which calls the software component are called as '''pre-conditions'''. The module making the call is called the client. The preconditions are the obligations that
the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the
supplier from having to handle cases outside of the precondition.

• The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's '''postconditions'''. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.

• The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the '''class invariant'''.
</pre>

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:45:47Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –


• Certain obligations need to be fulfilled by any module which calls the software component are called as '''pre-conditions'''. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.



• The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's '''postconditions'''. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.



• The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the '''class invariant'''.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:42:34Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –

• Certain obligations need to be fulfilled by any module which calls the software component are called as '''pre-conditions'''. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.

• The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's '''postconditions'''. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.

• The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the '''class invariant'''.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:42:01Z

Pnphadni:

'''Topic'''

----

''Find some concise examples that illustrate the principle of programming by contract, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –

• Certain obligations need to be fulfilled by any module which calls the software component are called as '''pre-conditions'''. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.

• The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's '''postconditions'''. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.
• The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the '''class invariant'''.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:41:00Z

Pnphadni:

'''Topic'''

----

''Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.''

==Definition==

Programming by contract is a software development approach that enforces the developers to define concrete and verifiable interface specifications for the software code. It is based on the theory of a business contract.

==Norms of the contract==

The core idea of programming by contract is how components of a software system collaborate with each other on the basis of mutual obligations and benefits. The concept is drawn from the business domain where clients and suppliers agree on a contract that defines certain norms. The corresponding norms that one can associate with a software system are –
• Certain obligations need to be fulfilled by any module which calls the software component are called as '''pre-conditions'''. The module making the call is called the client. The preconditions are the obligations that the client needs to fulfill and are benefits for the software component, called the supplier, as it frees the supplier from having to handle cases outside of the precondition.
• The supplier in turn, needs to guarantee certain outputs or certain properties on exit. These set of properties are called the supplier's '''postconditions'''. These postconditions are obligations for the supplier, and benefits for the client obtained from calling the supplier module.
• The supplier needs to maintain a certain property that is assumed to exist on entry and is guaranteed on exit, called the '''class invariant'''.

CSC/ECE 517 Fall 2007/wiki3 2 dp

2007-11-17T16:23:01Z

Pnphadni:

'''Topic'''

----

''Find some concise ones that illustrate the principle well, and are accessible to a general audience of programmers.''

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-30T02:19:46Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In this article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer. [1]

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. [1]

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it [3]. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type. [2]

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. [2] A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, categorized into ''value types'' and ''reference types''. [7]

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever a variable can be cast into. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions. [5]

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

[4] Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. [4]

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method [6]. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[1] [http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[2] [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[3] [http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[4] [http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[5] [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=/com.ibm.xlcpp8l.doc/language/ref/cplr058.htm Classes and Types in C++] 
[6] [http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[7] [http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-30T02:14:50Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In this article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer. [1]

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. [1]

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it [3]. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type. [2]

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. [2] A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, categorized into ''value types'' and ''reference types''.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever a variable can be cast into. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

[4] Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. [4]

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[1] [http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[2] [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[3] [http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[4] [http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[5] [http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[6] [http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[7] [http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-29T06:04:39Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In this article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, categorized into ''value types'' and ''reference types''.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever a variable can be cast into. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-29T06:03:36Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, categorized into ''value types'' and ''reference types''.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever a variable can be cast into. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-29T06:01:29Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, categorized into ''value types'' and ''reference types''.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever you can assign as a type to a variable. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-29T06:00:14Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever you can assign as a type to a variable. This includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-29T05:59:18Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever you can assign as a type to a variable, which includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-24T21:29:26Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever type you can assign as a type to a variable, which includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html Types and Classes] 
[http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming concepts on Wikipedia] 
[http://haskell.org/haskellwiki/OOP_vs_type_classes OOP vs type classes] 
[http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html Java Language Specification,Second Edition Chapter4: Types, Values, Variables] 
[http://en.wikibooks.org/wiki/Java_Programming/Types Java Programming/Types on Wikipedia] 
[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html Writing Classes in Ruby and Insipration for Example] 
[http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html What is the difference between class and type]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-24T21:26:50Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever type you can assign as a type to a variable, which includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

[Types and Classes http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html] 
[Object Oriented Programming concepts on Wiki http://en.wikipedia.org/wiki/Object-oriented_programming] 
[OOP vs type classes http://haskell.org/haskellwiki/OOP_vs_type_classes] 
[Java Language Specification,Second Edition Chapter4: Types, Values, Variables http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html] 
[Java Programming/Types on wiki http://en.wikibooks.org/wiki/Java_Programming/Types] 
[Writing Classes in Ruby and Insipration for Example http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html] 
[What is the difference between class and type http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-24T21:24:05Z

Pnphadni:

'''Topic'''

----

''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.''

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever type you can assign as a type to a variable, which includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

Types and Classes [http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html] 
Object Oriented Programming concepts on Wiki [http://en.wikipedia.org/wiki/Object-oriented_programming] 
OOP vs type classes [http://haskell.org/haskellwiki/OOP_vs_type_classes] 
Java Language Specification,Second Edition Chapter4: Types, Values, Variables [http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html] 
Java Programming/Types on wiki [http://en.wikibooks.org/wiki/Java_Programming/Types] 
Writing Classes in Ruby and Insipration for Example[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html] 
What is the difference between class and type [http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079

CSC/ECE 517 Fall 2007/wiki2 6 ap

2007-10-24T21:12:24Z

Pnphadni:

'''Topic'''

----

Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.

==Types vs Classes==

In object oriented programming concepts, the difference between types and classes is not clearly understood. The differences between them are subtle and the two terms are often misunderstood to be the same. In the article we try to bring out the differences between Types and Classes and provide more insight into them. Furthermore, in OOP languages, classes are types, while most types are not classes. In pure object languages, by opposition (e.g. Smalltalk, Scala, perhaps Python), every type maps to a class.

==Definition==

===Type===
A ''type'', in an object-oriented system, summarizes the common features of a set of objects with the same characteristics. It corresponds to the notion of an abstract data type. Type has 2 parts: the interface and the implementation(s). The interface, which is the only part visible to the user, consists of a list of operations and their signatures. The type implementation is of concern only to the type designer.

===Class===
A ''class'', in object oriented systems, is a kind of metadata that describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks.

==Types==

Types are abstract views that define properties of a set of entities. Object-oriented programming languages must allow to implement these types. Consequently, once a type is implemented we have a particular representation of it available. We will use the seminal concept of the integer data type to explain the concept of type in detail. Programming languages such as C, Java, C++, Pascal and others already offer an implementation for it. Sometimes it is called int or integer. Once you've created a variable of this type you can use its provided operations. For example, you can add two integers:

<code><pre>
int i, j, k; /* Define three integers */

i = 1; /* Assign 1 to integer i */
j = 2; /* Assign 2 to integer j */
k = i + j; /* Assign the sum of i and j to k */
</pre></code>

The first line defines three instances i, j and k of type Integer. Consequently, for each instance the special operation constructor should be called. In our example, this is internally done by the compiler. The compiler reserves memory to hold the value of an integer and ''binds'' the corresponding name to it. If you refer to i you actually refer to this memory area which was ''constructed'' by the definition of i.

The implementation of types comprises of the data (internal structure of the object’s data) and operation (methods / procedures which implement the interface operations). By making users declare the types of variables at compile time, the system simplifies the procedure of checking the program correctness at compile time, thereby increasing programmer productivity. The types cannot be modified at run-time.

===Properties of a Type===
* It exports a set of operations. This set is called interface.
* Operations of the interface are the one and only access mechanism to the type's data structure.
* Axioms and preconditions define the application domain of the type.

==Classes==

A class is a combination of state (data) and behavior (methods) that manipulate the state. A class is a blueprint for an object.It is an actual representation of a type. It therefore provides implementation details for the data structure used and operations specified in the type. Now we will define a class that implements the Integer data type:

<code><pre>
class Integer {
attributes: || implementation :
int i /* Integer data type */

methods: || operation :
setValue(int n) /* To assign value to i */
Integer addValue(Integer j) /* To add integer j with i */
}
</pre></code>

In this notation class {...} denotes the definition of a class. Enclosed in the curly brackets are two sections attributes: and methods: which define the implementation of the data structure and operations of the corresponding class. Again we distinguish the two levels with different terms: At the implementation level we speak of ''attributes'' which are elements of the data structure at the class level. The same applies to ''methods'' which are the implementation of the class operations.
In our example, the attribute is an ordinary integer of a programming language . We only define two methods setValue() and addValue() representing the two of the many operations that can be performed on an integer data type set and add, to make the comparison succinct and concise.

Although the specification of a class is pretty similar to that of a type, it is more of a runtime notion. There are two major aspects of a class – an object factory and an object warehouse. The object factory is the means by which objects of a class are created, using the new operation on the class. Object warehouse stores the set of objects that are instances of the class. Users can work with all these objects by performing all the allowed operations on them and thereby change the contents of the object warehouse. Thus, classes by no means determine the correctness of a program, rather they are used to create and manipulate objects, thereby making the system more flexible.

==Types vs Classes==

The concept of ''type'' itself is an abstraction, such as it can be either a ''value type'' or a ''reference type''. In most languages, ''Type'' is the most general abstraction, with ''value types'' and ''reference types'' as subtypes of the general type.

Value types in turn can be of different kinds, such as the primitive types, but some languages also allow you to construct compound types which are classes. Reference types can also have different constructions, such as class as one and some would consider arrays as another.

In reality, type is whatever type you can assign as a type to a variable, which includes both value types and reference types. Since the concepts of types and classes are tightly coupled, in this article we don't explicitly show direct contrasts between them, but rather subtly bring out the differences in their implementations in various programming languages.

==Types and Classes in C++==

C++ supports three kinds of object types:
* Fundamental types are built into the language (such as int, float, or double). Instances of these fundamental types are
often called ''variables''.
* Derived types are new types derived from built-in types.
* Class types are new types created by combining existing types. These include Classes, Structures, and Unions.

===Fundamental Types===

Fundamental types in C++ are divided into three categories: integral, floating, and void. Integral types are capable of handling whole numbers. Floating types are capable of specifying values that may have fractional parts.The void type describes an empty set of values. No variable of type void can be specified — it is used primarily to declare functions that return no values or to declare generic pointers to untyped or arbitrarily typed data

===Derived Types===

Derived types are new types that can be used in a program, and can include directly derived types and composed derivative types.
====Directly Derived Types====

New types derived directly from existing types are types that point to, refer to, or (in the case of functions) transform type data to return a new type.

* Arrays of Variables or Objects
* Functions
* Pointers of a Given Type
* References to Objects
* Constants
* Pointers to Class Members
====Composed Derivative Types====

The following are the various composed derivative types:

* Classes
* Structures
* Unions

Class types are derivatives of composed types. More on class types below.

===Class Types===

Class types are defined using the class, struct, and union keywords. For simplicity, types defined with these keywords are called class declarations. Class Type names are introduced as identifiers immediately after the compiler processes them (before entry into the class body); they can be used to declare class members. This allows declaration of self-referential data structures

'''Example :'''

<code><pre>

#include <iostream.h>
#include <string.h>
#define TRUE = 1

class dog
{
//implementation
public:
dog()
{
legs = 4;
bark = true;
}

void setDogSize(string dogSize)
{
_dogSize = dogSize;
}
string getDogSize()
{
return _dogSize;
}
void setBreed(string breed)
{
_breed = breed;
}

private: // attributes || fundamental types
string _dogSize, _breed;
int _legs;
bool _bark;

};

int main()
{
dog mongrel;//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
cout << "Ricky is a " << mongrel.getDogSize() << " sized dog" << endl;
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Java==

Java is a strongly typed language i.e. the type of every variable and expression used in a program must be known at compile time. The type of a variable / expression defines the range of values that it can hold. The type of a variable also determines the operations that can be performed on that variable. The strong typing nature of Java enables it to determine errors at compile time.Whenever a variable is declared in Java, we need to mention its type, which may be a class, interface or a primitive. When an object of a subclass of some other class is instantiated, we can say that the object is of type subclass and type superclass and it can perform all operations of both the subclass and the superclass. 

There are two different types in Java :
* Primitive Types are boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types are class types, interface types and array types.

{|width="100%" border="1" cellpadding="2" bordercolor = "black" cellspacing="2" align = "left"
|-
!A side note on Null Types
|-
|There is also a special null type in Java, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
|-
|}
 
 
====Primitive Types====

A primitive type is predefined by the Java programming language and named by its reserved keyword.Primitive values do not share state with other primitive values. A variable whose type is a primitive type always holds a primitive value of that same type. The value of a variable of primitive type can be changed only by assignment operations on that variable.

====Reference Types====

There are three kinds of reference types: class types, interface types, and array types.

<code><pre>
ReferenceType:
ClassOrInterfaceType
ArrayType

ClassOrInterfaceType:
ClassType
InterfaceType

ClassType:
TypeName

InterfaceType:
TypeName

ArrayType:
[ ]
</pre></code>

'''Example :'''

<code><pre>

import java.io.*;

class Dog
{
//implementation
public Dog() //constructor
{
legs = 4;
bark = true;
}

void setDogSize(String dogSize) //setter method
{
this.dogSize = dogSize;
}
String getDogSize() //getter method
{
return this.dogSize;
}
void setBreed(String breed)
{
this.breed = breed;
}

// attributes || fundamental types
String dogSize = new String ("");
Sting breed = new String ("");
int legs;
boolean bark;
public static void main(String[] args)
{
Dog mongrel = new Dog();//class types
//setting specific attributes that makes it different from types
mongrel.setDogSize("medium");
mongrel.setBreed("country specific");
System.out.println("Ricky is a "+ mongrel.getSize() +" size dog");
}
}
</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==Types and Classes in Ruby==

Ruby being a dynamically typed, reflective object oriented language, every variable is an object and we do not explicitly mention their type as in other object oriented languages, rather the type is implicitly inferred from the type of the value which is assigned to them at runtime. Hence there is no distinction between primitive data types and object types in ruby. In Ruby, all classes are instances of the class Class. Whenever a new class is defined, an object of type Class is created and assigned to the ''Name'' of the class. ''Name.new'' is used to create a new object of the class. This invokes the ''new'' instance method in Class, which in turn calls the ''allocate'' method to allocate memory for the object, before finally calling the new object's initialize method. Thus, the construction of an object is separate from its initialization, and both can be over-ridden. The initialization is done via the ''initialize'' instance method while the construction is done via the ''new'' class method. 

'''Example :'''

<code><pre>
#since ruby is dynamic Oo language no explicit type assignment statements
class Dog

#implementation
def initialize
@legs = 4
@bark = true
end
#attributes
attr_accessor :dogSize, :breed
end

#at runtime
mongrel = Dog.new #dynamiclly typed
#setting specific attributes that makes it different from types
mongrel.dogSize = "medium" # string class type
mongrel.breed = "country specific" # string class type
puts "Ricky is a #{mongrel.dogSize} size dog"

</pre></code>

'''Output:'''

<code><pre>
Ricky is a medium sized dog
</pre></code>

==References==

Types and Classes [http://www.cs.cmu.edu/People/clamen/OODBMS/Manifesto/htManifesto/node6.html] 
Object Oriented Programming concepts on Wiki [http://en.wikipedia.org/wiki/Object-oriented_programming] 
OOP vs type classes [http://haskell.org/haskellwiki/OOP_vs_type_classes] 
Java Language Specification,Second Edition Chapter4: Types, Values, Variables [http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html] 
Java Programming/Types on wiki [http://en.wikibooks.org/wiki/Java_Programming/Types] 
Writing Classes in Ruby and Insipration for Example[http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html] 
What is the difference between class and type [http://www.velocityreviews.com/forums/t127376-what-is-the-difference-between-class-and-type.html]

==Further Reading / External Links==

Bjarne Stroustrup's article on OOP in C++ and beyond http://www.research.att.com/~bs/bs_faq.html#oop 
B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158 
Fundamentals of OOP and Data Structures in Java - Page xiii by Richard Wiener, Lewis J. Pinson 
Type vs Class, A general overview http://lambda-the-ultimate.org/node/2079