Learn About Computers and Programming

How to Connect Java With Mysql in eclipse

2013-12-29T01:13:00.002-08:00

Step 1: Download mysql Connector from the link Below.

http://mirrors.ibiblio.org/pub/mirrors/maven2/mysql/mysql-connector-java/5.0.8/mysql-connector-java-5.0.8.jar

Step2: Right Click on project name select properties, then select java Build Path and go to Libraries tab.

Step 3: Click on add External jar browse to the downloaded mysql-connector jar file then Click ok.
Step 4: write the following code.

import java.sql.*;

public class ConnectToMySql {

public static void main(String[] args) throws Exception {

Class.forName("com.mysql.jdbc.Driver"); //checking for drivers
//DriverManager.getConnection("jdbc:mysql://servername/database","username","password")
Connection con = DriverManager.getConnection("jdbc:mysql://localhost/test","root","");

Statement st=con.createStatement();
System.out.println("Connected To MySql 5.0");
ResultSet rs=st.executeQuery("SELECT * FROM users"); //users table name
while ( rs.next()) {
System.out.println( rs.getString("username") + ":" + rs.getString("password"));//username and password are the fields of users table
}
con.close();
}
}

Creating a Client Proxy in Java

2013-12-24T06:49:00.001-08:00

@WebServiceClient(name = "CalculatorWSService",
targetNamespace = "http://calculator.me.org/",
wsdlLocation = "http://localhost:4933/CalculatorApp/CalculatorWSService?wsdl")
public class CalculatorWSService extends Service { //...
@WebEndpoint(name = "CalculatorWSPort")
public CalculatorWS getCalculatorWSPort() {
return super.getPort(new QName("http://calculator.me.org/",
"CalculatorWSPort"), CalculatorWS.class);
}

Here the getCalculatorWSPort method returns an object that implements the
CalculatorWSinterface, which is discussed next. The no-arg getPortmethod can be
used in general; the second getPort method accepts a variable-length array of
javax.xml.ws.WebServiceFeatureobjects that can be used by clients to configure certain
aspects of the invocation, such as whether to enable MTOM or WS-Addressing.

In the calculator example, the port has one method, to match the single addoperation
defined in the WSDL. Let’s take a step back and unpack this for a moment, as there’s
a lot going on here:
@WebMethod
@WebResult(targetNamespace = "")
@RequestWrapper(localName = "add",
targetNamespace = "http://calculator.me.org/",
className = "org.me.calculator.Add")
@ResponseWrapper(localName = "addResponse",
targetNamespace = "http://calculator.me.org/",
className = "org.me.calculator.AddResponse")
public int add(
@WebParam(name = "i", targetNamespace = "")
int i,
@WebParam(name = "j", targetNamespace = "")
int j);

As you can see, your seemingly simple, innocuous addmethod suddenly has a variety

of annotations adorning it. We’ll account for these one by one.
First, your WSDL specifies the following in the messages section:
<message name="add"> <part name="parameters" element="tns:add"></part> </message>
So the SEI needs to account for this message, and creates an annotation indicating that
the runtime will create a message with a QNamethat contains a local part of add, in the
specified namespace. That message is derived from the Java class that is also generated,
org.me.calculator.Add, which looks like this:
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "add", propOrder = {
"i",
"j"
})
public class Add {
protected int i;
protected int j;
//getters and setters omitted
That class acts as the wrapper for each of the integers that will be sent in the request.
The @Xml annotations on this class come from JAXB. They indicate how JAXB should
marshal and unmarshal instances of this class to and from XML. The @XmlTypeannotation is used to specify that this Addclass matches a top-level complex type (or an
enum) within an XML schema, and the “name” property is specified as “add” in it, to
match the item’s name within the schema. If you look at the schema that your WSDL
refers to, you see the following complex type, which matches your Addclass:
<xs:complexType name="add">
<xs:sequence>
<xs:element name="i" type="xs:int"></xs:element>
<xs:element name="j" type="xs:int"></xs:element>
</xs:sequence>
</xs:complexType>
But why does this type get created for you? Integers are defined as basic types provided
with XML Schema; they are not custom types that you have written that require something special. The complex type that wraps these two integers is created in order to
match your WSDL, which uses the document/literal style. Here is the portion of the
WSDL that tells you this:
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document"></soap:binding>
<operation name="add">
<soap:operation soapAction=""></soap:operation>
<input>
<soap:body use="literal"></soap:body>
</input>
Had you been using RPC and not document, the values would have been passed separately to the operation invocation just like method parameters.

The @RequestWrapperand @ResponseWrapperannotations capture information that JAXB
needs to perform the marshaling and unmarshaling operations. If your service is defined
as using document/literal mode, as ours is, this annotation also serves to resolve overloading conflicts.
Now, let’s write a quick program to invoke the generated client code and get a result
from your service. Here are the steps in their simplest form, stripped of any unnecessary
items so you can get the clearest picture.

import org.me.calculator.*;

public class CalculatorInvoker {
public static void main(String... arg) {
CalculatorWSService service = new CalculatorWSService();
CalculatorWS port = service.getCalculatorWSPort();
int result = port.add(2, 3);
System.out.println("Result: " + result);
}
}

Then you can run it:
>java -cp . CalculatorInvoker
Result: 5

Invoking the Simplest Web Service In Java

2013-12-24T06:44:00.001-08:00

import java.net.URL;
import java.util.Iterator;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
public class HelloClient {
public static void main(String[] args) throws Exception {
//Specify the WSDL
//Create a Qualified Name that represents the
//namespace and local part of the service
QName serviceName = new QName("http://ch03.soacookbook.com/",
"HelloWSService");
//Create a proxy to get a port stub from
Service service = Service.create(wsdlLocation, serviceName);
// Return a list of QNames of ports
System.out.println("QNames of service endpoints:");
Iterator<QName> it = service.getPorts();
QName lastEndpoint = null;
while (it.hasNext()) {
lastEndpoint = it.next();
System.out.println("Name: " + lastEndpoint);
//prints: Name: {http://ch03.soacookbook.com/}HelloWSPort
}
// Get the Hello stub
Hello hello = service.getPort(lastEndpoint, Hello.class);
//Invoke the business method
String result = hello.sayHello("Duke");
System.out.println("\nResponse: " + result);
}
}

ITERATORS in C++

2013-12-24T06:40:00.002-08:00

Iterators are similar to pointers in that they point to elements in a container. Iterators
are commonly used in C++ and are very important when using the STL.
A number of functions dealt with iterators, and in the following section we will
take a closer look at them and how they relate to the vector template class.

#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
using namespace std;
void PrintVector(vector<int> &array)
{

cout << "Contents (" << "Size: " << (int)array.size() <<
" Max: " << (int)array.capacity() << ") - ";
ostream_iterator<int> output(cout, " ");
copy(array.begin(), array.end(), output);
cout << endl;
}
int main(int args, char **argc)
{
cout << "STL Vector Example 2: Iterators" << endl;
cout << "Data Structures for Game Developers" << endl;
cout << "Allen Sherrod" << endl << endl;
vector<int> array;
array.reserve(5);
// Add items then print.
array.push_back(10);
array.push_back(20);
array.push_back(30);
array.push_back(40);
array.push_back(50);
// Calling the copy algorithm.
vector<int> array2;
for(int i = 0; i < 5; i++)
array2.push_back(0);
copy(array.begin(), array.end(), array2.begin());
cout << " Inserted into vector: ";
PrintVector(array);
// Run the accumulate algorithm.
cout << " Accumulate: "
<< accumulate(array.begin(), array.end(), 0)
<< endl;
// Pop off the container.
array.pop_back();
array.pop_back();
cout << "Popped two from vector: ";
PrintVector(array);
// Clear the container.
array.clear();
cout << " Cleared vector: ";
PrintVector(array);
cout << endl;
// Test if the container is empty.
if(array.empty() == true)
cout << "Vector is empty.";
else
cout << "Vector is NOT empty.";
cout << endl << endl;
return 1;
}
the demo application stlvector in Listing Vector Demo by creating an integer container and
filling it with elements. Once the container is filled, the STL copy algorithm is used
to copy the first container into another. Before the copying, a loop is used to create
the element space in the second container because to copy the first container into
the second, the second must have at least the number of elements required by the
range, which is specified by the iterators begin(first element or [0]) and end(last
element or [4]in this case).
After the copy algorithm is performed and the container is displayed, the
accumulate STL algorithm is performed to demonstrate that to get the sum of all
the elements, a few pop()calls are performed, the container is cleared, and it is
tested for emptiness. Inside the function used to print the container is new code
that replaces the forloop in the first vectordemo application stlvector. In this
function an output iterator is created and the STL copy algorithm is called. The call
states that the range of elements from the first parameter (the beginning of the container in this case) to the second parameter (the end of the container in this case)
should be copied to the output iterator. The output iterator for this demo application is set up to point to the C++ STD count object. This is an example of how to use
algorithms and iterators together to perform fast tasks in C++ code. Using a for
loop is one option, which was seen in the first stl vector demo, but it is slower than
using STL algorithms. Whenever possible use STL algorithms for traditional arrays
and containers because the performance is efficient. The output iterator that is set
up in points to the coutobject and appends a ""character to every
element that is passed to it. This is what gives the output a space between each
element that is printed

C++ Vector Demo

2013-12-24T06:34:00.006-08:00

#include<iostream>
#include<vector>
using namespace std;
void PrintVector(vector &array)
{
cout << "Contents (" << "Size: " << (int)array.size() <<
" Max: " << (int)array.capacity() << ") - ";
for(int i = 0; i < (int)array.size(); i++)
{
cout << array[i] << " ";
}
cout << endl;
}

int main(int args, char **argc)
{
cout << "STL Vector Example" << endl;
cout << "Data Structures for Game Developers" << endl;
cout << "Allen Sherrod" << endl << endl;
vector array;
array.reserve(5);
array.push_back(10);
array.push_back(20);
array.push_back(30);
array.push_back(40);
cout << " Inserted into vector. ";
PrintVector(array);
array.pop_back();
array.pop_back();
cout << "Popped two from vector. ";
PrintVector(array);
array.clear();
cout << " Cleared vector. ";
PrintVector(array);
cout << endl;
if(array.empty() == true)
cout << "Vector is empty.";
else
cout << "Vector is NOT empty.";
cout << endl << endl;
return 1;
}

the demo application creates an integer array and populates it with data using the push_back()method . The container is empty until items are pushed onto it. Once on the list, the array [] operators can be used to access the element by reading or writing to it. In the example code four items are pushed onto the list before popping (removal) of the last two and displaying the contents of the container.
The container is cleared, displayed again, and tested to see if it is empty. Inside
the function used to print a container, the code uses size()to determine how many
valid elements are currently pushed onto the container while capacity()is used to
determine how much space the container can hold without being resized. To access
the elements, we use the array operators [] for convenience.

The Entire Ordered and Unordered Array Classes

2013-12-24T06:29:00.000-08:00

template<class T>
class UnorderedArray
{
public:
UnorderedArray(int size, int growBy = 1) :
m_array(NULL), m_maxSize(0),
m_growSize(0), m_numElements(0)
{
if(size)
{
m_maxSize = size;
m_array = new T[m_maxSize];
memset(m_array, 0, sizeof(T) * m_maxSize);
m_growSize = ((growBy > 0) ? growBy : 0);
}
}
virtual ~UnorderedArray()
{
if(m_array != NULL)
{
delete[] m_array;
m_array = NULL;
}
}
virtual void push(T val)
{
assert(m_array != NULL);
if(m_numElements >= m_maxSize)
{
Expand();
}
m_array[m_numElements] = val;
m_numElements++;
}
void pop()
{
if(m_numElements > 0)
m_numElements—;
}
void remove(int index)
{
assert(m_array != NULL);
if(index >= m_maxSize)
{
return;
}
for(int k = index; k < m_maxSize - 1; k++)
m_array[k] = m_array[k + 1];
m_maxSize—;
if(m_numElements >= m_maxSize)
m_numElements = m_maxSize - 1;
}
virtual T& operator[](int index)
{
assert(m_array != NULL && index <= m_numElements);
return m_array[index];
}
virtual int search(T val)
{
assert(m_array != NULL);
for(int i = 0; i < m_numElements; i++)
{
if(m_array[i] == val)
return i;
}
return -1;
}
void clear() { m_numElements = 0; }
int GetSize() { return m_numElements; }
int GetMaxSize() { return m_maxSize; }
int GetGrowSize() { return m_growSize; }
void SetGrowSize(int val)
{
assert(val >= 0);
m_growSize = val;
}
private:
bool Expand()
{
if(m_growSize <= 0)
return false;
T *temp = new T[m_maxSize + m_growSize];
assert(temp != NULL);
memcpy(temp, m_array, sizeof(T) * m_maxSize);
delete[] m_array;
m_array = temp;
m_maxSize += m_growSize;
return true;
}
private:
T *m_array;
int m_maxSize;
int m_growSize;
int m_numElements;
};

Ordered Array Class

template <class T>
class OrderedArray
{
public:
OrderedArray(int size, int growBy = 1) :
m_array(NULL), m_maxSize(0),
m_growSize(0), m_numElements(0)
{
if(size)
{
m_maxSize = size;
m_array = new T[m_maxSize];
memset(m_array, 0, sizeof(T) * m_maxSize);
m_growSize = ((growBy > 0) ? growBy : 0);
}
}
virtual ~OrderedArray()
{
if(m_array != NULL)
{
delete[] m_array;
m_array = NULL;
}
}
void push(T val)
{
assert(m_array != NULL);
if(m_numElements >= m_maxSize)

{
Expand();
}
for(int i = 0; i < m_numElements; i++)
{
if(m_array[i] > val)
break;
}
for(int k = m_numElements; k > i; k—)
{
m_array[k] = m_array[k - 1];
}
m_array[i] = val;
m_numElements++;
}
void pop()
{
if(m_numElements > 0)
m_numElements—;
}
void remove(int index)
{
assert(m_array != NULL);
if(index >= m_maxSize)
{
return;
}
for(int k = index; k < m_maxSize - 1; k++)
m_array[k] = m_array[k + 1];
m_maxSize—;
if(m_numElements >= m_maxSize)
m_numElements = m_maxSize - 1;

}
// Making this const allows for reading but not writing.
virtual const T& operator[](int index)
{
assert(m_array != NULL && index <= m_numElements);
return m_array[index];
}
int search(T searchKey)
{
if(!m_array)
return -1;
int lowerBound = 0;
int upperBound = m_numElements - 1;
int current = 0;
while(1)
{
current = (lowerBound + upperBound) >> 1;
if(m_array[current] == searchKey)
{
return current;
}
else if(lowerBound > upperBound)
{
return -1;
}
else
{
if(m_array[current] < searchKey)
lowerBound = current + 1;
else
upperBound = current - 1;
}
}
return -1;
}
void clear() { m_numElements = 0; }
int GetSize() { return m_numElements; }
int GetMaxSize() { return m_maxSize; }
int GetGrowSize() { return m_growSize; }
void SetGrowSize(int val)
{
assert(val >= 0);
m_growSize = val;
}
private:
bool Expand()
{
if(m_growSize <= 0)
return false;
T *temp = new T[m_maxSize + m_growSize];
assert(temp != NULL);
memcpy(temp, m_array, sizeof(T) * m_maxSize);
delete[] m_array;
m_array = temp;
m_maxSize += m_growSize;
return true;
}
private:
T *m_array;
int m_maxSize;
int m_growSize;
int m_numElements;
};

BINARY SEARCHES

2013-12-24T06:21:00.001-08:00

A binary search can be performed on an ordered array. It works by taking a value
that is being searched for and testing it by the element in the middle of the array. If
the value being searched for is lower than the item in the middle of the ordered
array, it can be determined that if the value exists, it is in the first half of the array.
If the value is larger than the element in the middle, the value might exist in the
upper half. Once the direction is known, half of that new section is tested to further
narrow down where the value can be. This is repeated until the value is found or
until there are no more elements left. The binary search gets its name from the fact
that the remaining elements are always split in half (binary equals 2). Because a binary search requires the elements to be in order, this algorithm cannot work for an unordered array since the
unordered array can be unpredictable in terms of item positions.
The binary search can eliminate large sections of an array in an effort to narrow
down the list to find the value, assuming it exits. When compared to the linear
search, this can result in a huge difference in performance as Ngrows larger. For example, an array being searched with a linear algorithm that is made up of 1 million
elements will take on average 500,000 steps for items that exist, which can mean
that some checks can go up to the whole million depending on the item. Using a
binary search on an ordered array with that same number of elements will take
20 comparisons. To go from an average of 500,000 comparisons to just 20 is a huge
difference. To go from 1 million comparisons to 20 with items that are not found

while(1)
{
current = (lowerBound + upperBound) >> 1;
if(m_array[current] == searchKey)
{
return current;
}
else if(lowerBound > upperBound)
{
return -1;
}
else
{
if(m_array[current] < searchKey)
lowerBound = current + 1;
else
upperBound = current - 1;
}
}
return -1;
}
};

The binary search starts off by defining the bounds that make up
the search range, which is initially set to the entire array. Once the range is set, the
middle of the range is determined and the element at the position is tested. If the
item is found, the index is returned; if the lower bound’s value becomes higher than
the upper bound’s value (which will happen when the search has stepped through
the entire array), then the value is not found. If neither of these two cases are true,
the lower bound, which is the minimum search range position, is adjusted if
the item is greater than the item in the middle, or else the upper bound is adjusted.
Adjusting the range values will quickly shrink the search range until the value is
found or until there are no more elements to check this

operation is pretty fast as N grows larger.

BASICSEARCHES

2013-12-24T06:17:00.002-08:00

When we are looking for a value in an unordered array, our main option is the
linear search. The linear search is a brute-force-style search. The algorithm works
by stepping through each element of the array, starting with the first element, and
checking to see if the value of that element matches the value of what is being
searched for. If it is found, then the algorithm can report that the item exists in
some meaningful fashion, and it can also report where in the array the item is
positioned.
During a linear search the algorithm can find the first occurrence or all occurrences of a value. If duplicates are allowed in the array, then more than one value
can exist. In this chapter we’ll discuss finding the first occurrence. If there are times
when you know you need to know how many occurrences there are, or even how
many and where they are, then the searching function of the unordered array class
can be expanded to accommodate those needs. Searching beyond the first occurrence can be a waste of CPU time if there is no need to look for duplicates.

template<class T>
class UnorderedArray
{
public:
virtual int search(T val)
{
assert(m_array != NULL);
for(int i = 0; i < m_numElements; i++)
{
if(m_array[i] == val)
return i;
}
return -1;
}
};
A linear search can become slow for arrays with large numbers of items. On
average, the algorithm requires half the total number of items to find a value. If
there were 100 items in a list, then the average would be 50. Because the linear
search’s performance is based on the number of items in the array, it has a big-O of
O(N). The linear search is the most basic, yet slowest, search because it must check
potentially every item (half on average) before finding a value, assuming the value
even exists in the array. If the value does not exist, the search would have checked
every element in the array and come up with nothing.

The Ordered Array Class that Differs from the Unordered Array

2013-12-24T06:13:00.003-08:00

template <class T>
class OrderedArray
{
public:
int push(T val)
{
assert(m_array != NULL);
if(m_numElements >= m_maxSize)
{
Expand();
}
for(int i = 0; i < m_numElements; i++)
{
if(m_array[i] > val)
break;
}
for(int k = m_numElements; k > i; k—)
{
m_array[k] = m_array[k - 1];
}
m_array[i] = val;
m_numElements++;
return i;
}
};
Another option for inserting an item into an ordered array is to use a modified binary search to find the index closest to where the item would need to be inserted
and start the stepping from that point.

Removing Items from the Unordered Array

2013-12-24T06:12:00.000-08:00

template<class T>
class UnorderedArray
{
public:
void pop()
{
if(m_numElements > 0)
m_numElements—;
}
void remove(int index)a
{
assert(m_array != NULL);
if(index >= m_maxSize)
{
return;
}
for(int k = index; k < m_maxSize - 1; k++)
m_array[k] = m_array[k + 1];
m_maxSize—;
if(m_numElements >= m_maxSize)
m_numElements = m_maxSize - 1;
}
};

Using JDBC with Spring

2013-12-23T08:41:00.001-08:00

There are many persistence technologies out there. Hibernate, iBATIS, and JPAare
just a few. Despite this, a good number of applications are writing Java objects to a
database the old-fashioned way: they earn it. No, wait—that’s how people make
money. The tried-and-true method for persisting data is with good old JDBC.
And why not? JDBCdoesn’t require mastering another framework’s query language. It’s built on top of SQL, which is the data access language. Plus, you can more
finely tune the performance of your data access when you use JDBCthan with practically any other technology. And JDBCallows you to take advantage of your database’s
proprietary features, where other frameworks may discourage or flat-out prohibit this.
What’s more, JDBClets you work with data at a much lower level than the persistence frameworks, allowing you to access and manipulate individual columns in a
database. This fine-grained approach to data access comes in handy in applications,
such as reporting applications, where it doesn’t make sense to organize the data into
objects, just to then unwind it back into raw data.
But all is not sunny in the world of JDBC. With its power, flexibility, and other niceties also come some not-so-niceties.
Tackling runaway JDBC code
Though JDBCgives you an APIthat works closely with yourdatabase, you’re responsible for handling everything related to accessing the database. This includes managing
database resources and handling exceptions.
If you’ve ever written JDBCthat inserts data into the database, the following
shouldn’t be too alien to you.

private static final String SQL_INSERT_SPITTER =
"insert into spitter (username, password, fullname) values (?, ?, ?)";
private DataSource dataSource;
public void addSpitter(Spitter spitter) {
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = dataSource.getConnection();
stmt = conn.prepareStatement(SQL_INSERT_SPITTER);
stmt.setString(1, spitter.getUsername());
stmt.setString(2, spitter.getPassword());
stmt.setString(3, spitter.getFullName());
stmt.execute();
} catch (SQLException e) {
// do something...not sure what, though
} finally {
try {
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
// I'm even less sure about what to do here
}
}
}

private static final String SQL_UPDATE_SPITTER =
"update spitter set username = ?, password = ?, fullname = ?"
+ "where id = ?";
public void saveSpitter(Spitter spitter) {
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = dataSource.getConnection();

stmt = conn.prepareStatement(SQL_UPDATE_SPITTER);
stmt.setString(1, spitter.getUsername());
stmt.setString(2, spitter.getPassword());
stmt.setString(3, spitter.getFullName());
stmt.setLong(4, spitter.getId());
stmt.execute();
} catch (SQLException e) {
// Still not sure what I'm supposed to do here
} finally {
try {
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
// or here
}
}

}

private static final String SQL_SELECT_SPITTER =
"select id, username, fullname from spitter where id = ?";
public Spitter getSpitterById(long id) {
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection();
stmt = conn.prepareStatement(SQL_SELECT_SPITTER);
stmt.setLong(1, id);
rs = stmt.executeQuery();
Spitter spitter = null;
if (rs.next()) {
spitter = new Spitter();
spitter.setId(rs.getLong("id"));
spitter.setUsername(rs.getString("username"));

spitter.setPassword(rs.getString("password"));
spitter.setFullName(rs.getString("fullname"));
}
return spitter;
} catch (SQLException e) {
} finally {
if(rs != null) {
try {
rs.close();
} catch(SQLException e) {}
}
if(stmt != null) {
try {
stmt.close();
} catch(SQLException e) {}
}
if(conn != null) {
try {
conn.close();
} catch(SQLException e) {}
}
}
return null;

}

Working with JDBC templates

Spring’s JDBC framework will clean up your JDBCcode by shouldering the burden of
resource management and exception handling. This leaves you free to write only the

code necessary to move data to and from the database.
All that a SimpleJdbcTemplateneeds to do its work is a DataSource. This makes it easy
enough to configure a SimpleJdbcTemplatebean in Spring with the following XML:
<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.simple.SimpleJdbcTemplate">
<constructor-arg ref="dataSource" />
</bean>
The actual DataSourcebeing referred to by the dataSourceproperty can be any
implementation of javax.sql.DataSource, including those we created in section 5.2.
Now we can wire the jdbcTemplatebean into our DAOand use it to access the database. For example, suppose that the Spitter DAOis written to use SimpleJdbcTemplate:
public class JdbcSpitterDAO implements
SpitterDAO {
...
private SimpleJdbcTemplate jdbcTemplate;
public void setJdbcTemplate(SimpleJdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
}
You’d then wire the jdbcTemplateproperty of JdbcSpitterDAOas follows:
<bean id="spitterDao"
class="com.habuma.spitter.persistence.SimpleJdbcTemplateSpitterDao">
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>

With a SimpleJdbcTemplateat our DAO’s disposal, we can greatly simplify the
addSpitter()method from listing The new SimpleJdbcTemplate-based

addSpitter()method is shown next.

public void addSpitter(Spitter spitter) {
jdbcTemplate.update(SQL_INSERT_SPITTER,
spitter.getUsername(),
spitter.getPassword(),
spitter.getFullName(),
spitter.getEmail(),
spitter.isUpdateByEmail());
spitter.setId(queryForIdentity());
}

Querying for a Spitterusing SimpleJdbcTemplate

public Spitter getSpitterById(long id) {
return jdbcTemplate.queryForObject(
SQL_SELECT_SPITTER_BY_ID,
new ParameterizedRowMapper<Spitter>() {
public Spitter mapRow(ResultSet rs, int rowNum)
throws SQLException {
Spitter spitter = new Spitter();
spitter.setId(rs.getLong(1));
spitter.setUsername(rs.getString(2));
spitter.setPassword(rs.getString(3));
spitter.setFullName(rs.getString(4));
return spitter;
}
},
id
);
}

Using named parameters with Spring JDBC templates

public void addSpitter(Spitter spitter) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("username", spitter.getUsername());
params.put("password", spitter.getPassword());
params.put("fullname", spitter.getFullName());
jdbcTemplate.update(SQL_INSERT_SPITTER, params);
spitter.setId(queryForIdentity());

}

USING SPRING’S DAO SUPPORT CLASSES FOR JDBC

public class JdbcSpitterDao extends SimpleJdbcDaoSupport
implements SpitterDao {
...

}

public void addSpitter(Spitter spitter) {
getSimpleJdbcTemplate().update(SQL_INSERT_SPITTER,
spitter.getUsername(),
spitter.getPassword(),
spitter.getFullName(),
spitter.getEmail(),
spitter.isUpdateByEmail());
spitter.setId(queryForIdentity());
}

When configuring your DAOclass in Spring, you could directly wire a SimpleJdbcTemplatebean into its jdbcTemplateproperty as follows:
<bean id="spitterDao"
class="com.habuma.spitter.persistence.JdbcSpitterDao"> <property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>

This will work,

Cascading in JPA

2013-12-18T08:48:00.001-08:00

To begin, let’s consider the changes required to make the persist()operation cascade from Employee
to Address. In the definition of the Employeeclass, there is a @ManyToOne annotation defined for the
address relationship. To enable the cascade, we must add the PERSISToperation to the list of cascading
operations for this relationship of the Employee entity that
demonstrates this change.
.Enabling Cascade Persist
@Entity
public class Employee {
// ...
@ManyToOne(cascade=CascadeType.PERSIST)
Address address;
// ...
}
To leverage this change, we need only ensure that the Add ressentity has been set on the Employee
instance before invoking persist()on it. As the entity manager encounters the Employee instance and
adds it to the persistence context, it will navigate across the address relationship looking for a new
Address entity to manage as well. In comparison with the approach in Listing
Cascade settings are unidirectional. This means that they must be explicitly set on both sides of a
relationship if the same behavior is intended for both situations. For example, in Listing, we only
added the cascade setting to the address relationship in the Employee entity. If Listing were
changed to persist only the Address entity, not the Employee entity, the Employee entity would not
become managed because the entity manager has not been instructed to navigate out from any
relationships defined on the Address entity.

The Database Life Cycle

2013-12-07T08:40:00.002-08:00

Before getting into the development of any system, you need to have strong a life-cycle model to follow. The model must have all the phases defined in the proper sequence, which will help the development team build the system with fewer problems and full functionality as expected.
The database life cycle consists of the following stages, from the basic steps involved in designing a global schema of the database to database implementation and maintenance:
• Requirements analysis: Requirements need to be determined before you can begin design and implementation. The requirements can be gathered by interviewing
both the producer and the user of the data; this process helps in creating a formal requirement specification.
• Logical design: After requirements gathering, data and relationships need to be
defined using a conceptual data modeling technique such as an entityrelationship (ER) diagram. This diagram shows how one object will connect to the other one and by what relationship (one-one or one-many). Relationships are.
• Physical design: Once the logical design is in place,the next step is to produce the
physical structure for the database. The physical design phase involves creating
tables and selecting indexes.but an index is basically like an index of a book, which allows you to jump to a
particular page based on the topic of your choice and helps you avoid shuffling all
the pages of the book to reach the page of interest. Database indexes do
something similar; they manage and maintain the order of rows when inserted
into the table, which helps SQL queries pull data fast based on a provided value for
the index column.
Database implementation: Once the design is completed, the database can be
created through the implementation of formal schema using the data definition
language (DDL) of the RDBMS. The DDL consists of the statements that play key
roles in creating, modifying, and deleting the database or database objects. CREATE,
ALTER, and DROP are prime examples of a DDL.
Data modification: A data modification language (DML) can be used to query and
update the database as well as set up indexes and establish constraints such as referential integrity. A DML consists of the statements that play key roles in inserting,
updating and deleting the data from database tables. INSERT, UPDATE, and DELETE
are prime examples of a DDL.
• Database monitoring: As the database begins operation, monitoring indicates
whether performance requirements are being met; if they are not, modifications
should be made to improve database performance. Thus, the database life cycle
continues with monitoring, redesign, and modification.

Why Use a Database?

2013-12-07T08:32:00.000-08:00

The following are some of the reasons why you would use databases:
• Compactness: Databases help you maintain large amounts of data and thus completely replace voluminous paper files.
• Speed: Searches for a particular piece of data or information in a database are
much faster than sorting through piles of paper.

• Less drudgery: It is a dull work to maintain files by hand; using a database completely eliminates such maintenance.
• Currency: Database systems can easily be updated and so provide accurate information all the time and on demand.

Benefits of Using a RelationalDatabase Management System

RDBMSs offer various benefits by controlling the following:
• Redundancy: RDBMSs prevent you from having duplicate copies of the same data,
which takes up disk space unnecessarily.
• Inconsistency: Each redundant set of data may no longer agree with other sets of
the same data. When an RDBMS removes redundancy, inconsistency cannot
occur.
• Data integrity: Data values stored in the database must satisfy certain types of
consistency constraints.
• Data atomicity: In event of a failure, data is restored to the consistent state it
existed in prior to the failure. For example, fund transfer activity must be atomic.
• Access anomalies: RDBMSs prevent more than one user from updating the same
data simultaneously; such concurrent updates may result in inconsistent data.
• Data security: Not every user of the database system should be able to access all
the data. Security refers to the protection of data against any unauthorized access.
• Transaction processing: A transaction is a sequence of database operations that
represents a logical unit of work. In RDBMSs, a transaction either commits all the
changes or rolls back all the actions performed until the point at which the failure
occurred.
• Recovery: Recovery features ensure that data is reorganized into a consistent state
after a transaction fails.
• Storage management: RDBMSs provide a mechanism for data storage
management. The internal schema defines how data should be stored.

Comparing Desktop and Server RDBMS Systems

In the industry today, you’ll mainly work with two types of databases: desktop databases and server
databases
Desktop Databases
Desktop databases are designed to serve a limited number of users and run on desktop PCs, and they
offer a less-expansive solution wherever a database is required. Chances are you have worked with a
desktop database program; Microsoft SQL Server Express, Microsoft Access, Microsoft FoxPro,
FileMaker Pro, Paradox, and Lotus are all desktop database solutions.
Desktop databases differ from server databases in the following ways:
• Less expensive: Most desktop solutions are available for just a few hundred dollars.
In fact, if you own a licensed version of Microsoft Office Professional, you’re
already a licensed owner of Microsoft Access, which is one of the most commonly
and widely used desktop database programs around.
• User friendly: Desktop databases are quite user friendly and easy to work with,
because they do not require complex SQL queries to perform database operations
(although some desktop databases also support SQL syntax if you want to write
code). Desktop databases generally offer an easy-to-use graphical user interface.
Server Databases
Server databases are specifically designed to serve multiple users at a time and offer features that allow
you to manage large amounts of data very efficiently by serving multiple user requests simultaneously.
Well-known examples of server databases include Microsoft SQL Server, Oracle, Sybase, and DB2.
The following are some other characteristics that differentiate server databases from their desktop
counterparts:
• Flexibility: Server databases are designed to be very flexible and support multiple
platforms, respond to requests coming from multiple database users, and perform
any database management task with optimum speed.
• Availability: Server databases are intended for enterprises, so they need to be
available 24/7. To be available all the time, server databases come with some highavailability features, such as mirroring and log shipping.
• Performance: Server databases usually have huge hardware support, so servers
running these databases have large amountsof RAM and multiple CPUs. This is
why server databases support rich infrastructure and give optimum performance.
• Scalability: This property allows a server database to expand its ability to process
and store records even if it has grown tremendously.

Using Layout Controls

2013-12-07T07:43:00.001-08:00

Although you can use fixed positioning to place controls on a WPF window, it’s
positioning usually works well for a fixed resolution size but it doesn’t scale we
To overcome the limitations of fixed positioning, WPF offers several layout con
position other controls within it using a relative positioning format. One of the
other controls is the Grid. As seen previous post, a Grid control contains columns
its child controls. The height and width of the columns and rows can be set to a
takes up as much space as needed by the contained control. The *setting take
The Grid control is often used to lay out data entry forms. The following code l
collect user information. The resulting form (in the Visual Studio designer) is s
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="28" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" />
<ColumnDefinition Width="200" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Label Grid.Row="0" Grid.Column="0" Content="Name:"/>
<Label Grid.Row="1" Grid.Column="0" Content="Old Password:"/>
<Label Grid.Row="2" Grid.Column="0" Content="New Password:"/>
<Label Grid.Row="3" Grid.Column="0" Content="Confirm Password:
<TextBox Grid.Column="1" Grid.Row="0" Margin="3" />
<TextBox Grid.Column="1" Grid.Row="1" Margin="3" />
<TextBox Grid.Column="1" Grid.Row="2" Margin="3" />
<TextBox Grid.Column="1" Grid.Row="3" Margin="3" />
<Button Grid.Column="1" Grid.Row="4" HorizontalAlignment="Righ
MinWidth="80" Margin="0,0,0,8" Content="Submit" />
</Grid>

XAML

2013-12-07T07:36:00.001-08:00

WPF user interfaces are built using a declarative markup language called XAML. XAML declares the controls that will
make up the interface. An opening angle bracket (<) followed by the name of the control type and a closing bracket
define the control. For example, the following markup defines a button control inside a Grid.
<Grid>

<Button/>

</Grid>
Notice the Grid needs a formal closing tag because it contains the Button control. Since the Button control does not contain any other elements, you can use a forward slash (/) in front of the end bracket to close it
The next step is to define the properties of the controls. For example, you may want to set the background colour of the button to red and write some text on it. The properties of the control are set by using attribute syntax, which consists of the property name followed by an equal sign and the attribute value in quotation marks. The following mark-up shows the Button control with some attributes added:

<Grid>
<Button Content="Click Me" Background="Red"/>
</Grid>
For some properties of an object element a syntax known as property element syntax is used. The syntax for the property element start tag is <typeName.propertyName>. For example, you can create rows and columns in the layout grid to control placement of controls in the grid, as shown:

<Grid.ColumnDefinitions>
<ColumnDefinition Width="100" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="25" />
<RowDefinition Height="25" />
<RowDefinition Height="25" />
</Grid.RowDefinitions>
Controls are positioned in the grid by including a Grid.Rowand Grid.Columnattribute, as shown:
<Label Grid.Column="0" Grid.Row="0" Content="Name:" />
<Label Grid.Column="0" Grid.Row="1" Content="Password:" />
<TextBox Name="txtName" Grid.Column="1" Grid.Row="0"/>
<TextBox Name="txtPassword" Grid.Column="1" Grid.Row="1"/>
<Button Grid.Column="1" Grid.Row="3"
Content="Click Me" HorizontalAlignment="Right"
MinWidth="80" Background="Red"/>

WHAT IS A CASE STUDY?

2013-12-06T05:40:00.001-08:00

The term “case study” appears every now and then in the title of software engineering
research papers. These papers have in common that they study a specific case, in
contrast to a sample from a specified population. However, the presented studies
range from very ambitious and well-organized studies in the field of operations
(in vivo) to small toy examples in a university lab (in vitro) that claim to be case
studies. This variation creates confusion, which should be addressed by increased
knowledge about case study methodology.
Case study is a commonly used research strategy in areas such as psychology,
sociology, political science, social work, business, and community planning
In these areas, case studies are conducted with the objectives of not only increasing knowledge (e.g., knowledge about individuals, groups,
and organizations and about social, political, and related phenomena) but also bringing about change in the phenomenon being studied (e.g. improving education or social
care). Software engineering research has similar high-level objectives, that is, to better understand how and why software engineering should be undertaken and, with
this knowledge, to seek to improve the software engineering process and the resultant
software products.
There are different taxonomies used to classify research in software engineering.
The term case study is used in parallel with terms like field study and observational
study, each focusing on a particular aspect of the research methodology. For example,
Case studies offer an approach that does not require a strict boundary between the
object of study and its environment. Case studies do not generate the same results
on, for example, causal relationships, as controlled experiments do, but they provide
a deeper understanding of the phenomena under study. As they are different from
analytical and controlled empirical studies, case studies have been criticized for being
of less value, being impossible to generalize from, being biased by researchers, and so
on. This critique can be met by applying proper research methodology practices and
by reconsidering that knowledge is more than statistical significance.
However, the research community has to learn more about the case study methodology
in order to conduct, report, review, and judge it properly.

HISTORY:

The term case study first appeared in software engineering journal papers in the
late 1970s. At that time, a case study was typically a demonstration case, that
is, a case that demonstrated the implementation of some software technology or
programming concept.
In the mid- to late-1980s, papers started to report case studies of a broader range
of software development phenomena, for example, Alexander and Potter’study
of formal specifications and rapid prototying. For these types of papers, the term case
study refers to a self-experienced and self-reported investigation. Throughout the
1990s the scale of these “self investigations” increased and there were, for example, a
series of papers reporting case studies of software process improvement in large and
multinational organizations such as Boeing, Hughes, Motorola, NASA, and Siemens.
Case studies based on the external and independent observation of a software
engineering activity first appeared in the late 1980s, for example, Boehm and
Ross’s “extensive case study” of the introduction of new information
systems into a large industrial corporation in an emerging nation. These case studies,
however, did not direct attention at case study methodology that is, at the design,

conduct, and reporting of the case study
The first case study papers that explicitly report the study methodology were
published in 1988: Curtis et al.’s [37] field study of software design activities and
Swanson and Beath’s [199] multiple case study of software maintenance. Given the
status of case study research in software engineering at the time, it is not surprising that Swanson and Beath were actually researchers in a school of management
in the United States, and were not software engineering researchers. Swanson and
Beath use their multiple case studies to illustrate a number of challenges that arise
when conducting case studies research, and they also present methodological lessons.
Their paper therefore appears to be the first of its kind in the software engineering
research community that explicitly discusses the challenge of designing, conducting,
and reporting case study research.
During the 1990s, both demonstration studies and genuine case studies (as we
define them here) were published, although only in small numbers. Glass et al.
analyzed software engineering publications in six major software engineering journals
for the period 1995–1999 and found that only 2.2% of these publications reported case
studies .Much more recently, a sample of papers from Sjøberg et al.’s large systematic review of experimental studies in software engineering were analysed
by Holt .She classified 12% of the sample as case studies. This compares to
1.9% of papers classified as formal experiments in the Sjøberg study. But differences
in the design of these reviews make it hard to properly compare the reviews and draw
firm conclusions.
The first recommendations, by software engineering researchers, regarding case
study methodology were published in the mid-1990s . However, these recommendations focus primarily on the use of quantitative data. In the late 1990s, Seaman
published guidelines on qualitative research . Then, in the early twenty-first

century, a broader set of guidelines on empirical research were published by Kitchen ham et al. Sim et al. arranged a workshop on the topic, which was summarized
in Empirical Software Engineering, Wohlin et al. provided a brief introduction
to case studies among other empirical methods , and Dittrich et al. edited a special issue of Information and Software Technology on qualitative software engineering
There is a very wide range of activities in software engineering, such as development, operation, and maintenance of software and related artifacts as well as the
management of these activities. A frequent aim of software engineering research is to
investigate how this development, operation, and maintenance is conducted, and also
managed, by software engineers and other stakeholders under different conditions.
With such a wide range of activities, and a wide range of software products being
developed, there is a very diverse range of skills and experience needed by the actors
undertaking these activities.
Software engineering is also distinctive in the combination of diverse topics that
make up the discipline
Many of the interim products are produced either intentionally by the actors (e.g.,
the minutes of meetings) or automatically by technology (e.g., updates to a version
of control system). Therefore, one of the distinctive aspects of software engineering
is the raw data that are naturally, and often automatically, generated by the activities
and technologies.
There are clear overlaps with other disciplines, such as psychology, management,
business, and engineering, but software engineering brings these other disciplines
together in a unique way, a way that needs to be studied with research methods
tailored to the specifics of the discipline
Case studies investigate phenomena in their real-world settings, for example, new
technologies, communication in global software development, project risk and failure
factors, and so on. Hence, the researcher needs to consider not only the practical
requirements and constraints from the researcher’s perspective, but also the objectives
and resource commitments of the stakeholders who are likely to be participating in,
or supporting, the case study. Also, practitioners may want to intervene in future
projects – that is, change the way things are done in future projects – on the basis
of the outcomes from the case studies, and often software engineering managers
are interested in technology interventions, such as adopting a new technology

the above content is taken from
" Case Study Research in Software Engineering: Guidelines and Examples "

Constructors in Object Oriented Programming

2013-12-06T05:05:00.001-08:00

Constructors may be a new concept for structured programmers. Although constructors are not
normally used in non-OO languages such as COBOL, C, and Basic, the struct , which is part of
C/C++, does include constructors.In some OO languages, such as Java and C#, constructors are
methods that share the same name as the class. Visual Basic .NET uses the designation New
and Objective-C uses the init keyword.
For example, a constructor for the Cabbie class would look like this:
public Cabbie(){
/* code to construct the object */
}
The compiler will recognize that the method name is identical to the class name and consider
the method a constructor.
Note that in this Java code (as with C# and C++), a constructor does not have a return value. If
you provide a return value, the compiler will not treat the method as a constructor.
For example, if you include the following code in the class, the compiler will not consider this
a constructor because it has a return value—in this case, an integer:
public int Cabbie(){
/* code to construct the object */
}
This syntax requirement can cause problems because this code will compile but will not behave
as expected.

Constructors may be a new concept for structured programmers. Although constructors are not

normally used in non-OO languages such as COBOL, C, and Basic, the struct , which is part of

C/C++, does include constructors. In the first two chapters, we alluded to these special methods

that are used to construct objects. In some OO languages, such as Java and C#, constructors are

methods that share the same name as the class. Visual Basic .NET uses the designation New

and Objective-C uses the init keyword. As usual, we will focus on the concepts of constructors

and not cover the specific syntax of all the languages. Let’s take a look at some Java code that

implements a constructor.

For example, a constructor for the Cabbie class we covered in Chapter 2 would look like this:

public Cabbie(){

/* code to construct the object */

}

The compiler will recognize that the method name is identical to the class name and consider

the method a constructor. 54 Chapter 3 Advanced Object-Oriented Concepts

Caution

Note that in this Java code (as with C# and C++), a constructor does not have a return value. If

you provide a return value, the compiler will not treat the method as a constructor.

For example, if you include the following code in the class, the compiler will not consider this

a constructor because it has a return value—in this case, an integer:

public int Cabbie(){

/* code to construct the object */

}

This syntax requirement can cause problems because this code will compile but will not behave

as expected.

Constructors may be a new concept for structured programmers. Although constructors are not

normally used in non-OO languages such as COBOL, C, and Basic, the struct , which is part of

C/C++, does include constructors. In the first two chapters, we alluded to these special methods

that are used to construct objects. In some OO languages, such as Java and C#, constructors are

methods that share the same name as the class. Visual Basic .NET uses the designation New

and Objective-C uses the init keyword. As usual, we will focus on the concepts of constructors

and not cover the specific syntax of all the languages. Let’s take a look at some Java code that

implements a constructor.

For example, a constructor for the Cabbie class we covered in Chapter 2 would look like this:

public Cabbie(){

/* code to construct the object */

}

The compiler will recognize that the method name is identical to the class name and consider

the method a constructor. 54 Chapter 3 Advanced Object-Oriented Concepts

Caution

Note that in this Java code (as with C# and C++), a constructor does not have a return value. If

you provide a return value, the compiler will not treat the method as a constructor.

For example, if you include the following code in the class, the compiler will not consider this

a constructor because it has a return value—in this case, an integer:

public int Cabbie(){

/* code to construct the object */

}

This syntax requirement can cause problems because this code will compile but will not behave

as expected.

When Is a Constructor Called?

When a new object is created, one of the first things that happens is that the constructor is

called. Check out the following code:

Cabbie myCabbie = new Cabbie();

The new keyword creates a new instance of the Cabbie class, thus allocating the required

memory. Then the constructor itself is called, passing the arguments in the parameter list. The

constructor provides the developer the opportunity to attend to the appropriate initialization.

Thus, the code new Cabbie() will instantiate a Cabbie object and call the Cabbie method,

which is the constructor.

What’s Inside a Constructor?

Perhaps the most important function of a constructor is to initialize the memory allocated

when the new keyword is encountered. In short, code included inside a constructor should set

the newly created object to its initial, stable, safe state.

For example, if you have a counter object with an attribute called count , you need to set count

to zero in the constructor:

count = 0;

The Default Constructor

If you write a class and do not include a constructor, the class will still compile, and you can

still use it. If the class provides no explicit constructor, a default constructor will be provided.

It is important to understand that at least one constructor always exists, regardless of whether

you write a constructor yourself. If you do not provide a constructor, the system will provide a

default constructor for you.

Besides the creation of the object itself, the only action that a default constructor takes is to

call the constructor of its superclass. In many cases, the superclass will be part of the language

framework, like the Object class in Java. For example, if a constructor is not provided for the

public Cabbie(){

super();

}

If you were to decompile the bytecode produced by the compiler, you would see this code. The

compiler actually inserts it.

Using Multiple Constructors

public class Count {

int count;

public Count()

{

count = 0;

}

On the one hand, we want to initialize the attribute count to count to zero: We can easily

accomplish this by having a constructor initialize count to zero as follows:

public Count()

{

count = 0;

}

On the other hand, we might want to pass an initialization parameter that allows count to be

set to various numbers:

public Count (int number){

count = number;

}

the above content is taken from the The Object-oriented Thought Process

Links and Associations

2013-12-05T10:18:00.000-08:00

A link is a physical or conceptual connection between object instances. In
OMT link is represented by a line labeled with its name as shown in Figure

association

An association describes a group of links with common structure and common

semantics between two or more classes. Association is represented by a line

labeled with the association name

Associations can have role names associated each class connection.Associations can also have qualifiers on the class connections. qualifiers are special attributes that reduce the effective multiplicity

OBJECT MODEL COMPONENTS PART 2

2013-12-05T09:48:00.000-08:00

Attribute:

An attribute is a data value held by objects in a class. Each attribute has a

value for each object instance. This value should be a pure data value, not an

object. Attributes are listed in the second part of the class box. Attributes may

or may not be shown; it depends on the level of detail desired. Each attribute

name may be followed by the optional details such as type and default value.

An object model should generally distinguish independent base attributes

from dependent derived attributes. A derived attribute is that which is derived

from other attributes. For example, age is a derived attribute, as it can be

derived from date-of-birth and current-date attributes.

operation

An operation is a function or transformation that may be applied to or by

objects in a class. Operations are listed in the third part of the class box.

Operations may or may not be shown; it depends on the level of detail

desired. Each operation may be followed by optional details such as argument

list and result type. The name and type of each argument may be given. An

empty argument list in parentheses shows explicitly that there are no

arguments. All objects in a class share the same operations. Each operation

has a target object as an implicit argument. An operation may have

arguments in addition to its target object, which parameterize the operation.

The behavior of the operation depends on the class of its target.

The same operation may be defined for several different classes. However, the

signature (i.e. output type and formal parameter list) must be the same

polymorphism

An operation may be polymorphic in nature. A polymorphic operation means

that the same operation takes on different forms in different/same classes.

Overloading of operators, overloading of functions and overriding of functions

provided by object-oriented programming languages are all examples of

polymorphic operations. A method is the implementation of an operation for a

class. The method depends only on the class of the target object.

Object model components part 1

2013-12-05T08:57:00.001-08:00

Object:
An object is a concept, abstraction, or thing with crisp boundaries and meaning for the
problem at hand. All objects have identity and are distinguishable
Objects are the physical and conceptual things we find in the universe around us. Hardware, software, documents, human beings, and even concepts are all examples of objects. For purposes of modeling his or her company, a chief executive officer could view employees, buildings, divisions, documents, and benefits packages as objects. An automotive engineer would see tires, doors, engines, top speed, and the current fuel level as objects. Atoms, molecules, volumes, and temperatures would all be objects a chemist might consider in creating an object-oriented simulation of a chemical reaction. Finally, a software engineer would consider stacks, queues, windows, and check boxes as objects.
Objects are thought of as having state. The state of an object is the condition of the object, or a set of circumstances describing the object. It is not uncommon to hear people talk about the "state information" associated with a particular object. For example, the state of a bank account object would include the current balance, the state of a clock object would be the current time, the state of an electric light bulb would be "on" or "off." For complex objects like a human being or an automobile, a complete description of the state might be very complex. Fortunately, when we use objects to model real world or imagined situations, we typically restrict the possible states of the objects to only those that are relevant to our models.
Objects are thought of as having state. The state of an object is the condition of the object, or a set of circumstances describing the object. It is not uncommon to hear people talk about the "state information" associated with a particular object. For example, the state of a bank account object would include the current balance, the state of a clock object would be the current time, the state of an electric light bulb would be "on" or "off." For complex objects like a human being or an automobile, a complete description of the state might be very complex. Fortunately, when we use objects to model real world or imagined situations, we typically restrict the possible states of the objects to only those that are relevant to our models.
We also think of the state of an object as something that is internal to an object. For example, if we place a message in a mailbox, the (internal) state of the mailbox object is changed, whereas the (internal) state of the message object remains unchanged.
An object
has the following four main characteristics:

• Unique identification
• Set of attributes
• Set of states
• Set of operations (behavior)

Unique identification, we mean every object has a unique name by which it is

identified in the system. Set of attributes, we mean every object has a set of

properties in which we are interested in. Set of states we mean values of

attributes of an object constitute the state of the object. Every object will have

a number of states but at a given time it can be in one of those states. Set of

operations we mean externally visible actions an object can perform. When an

operation is performed, the state of the object may change.

The box may/may not be divided in
particular regions. Object instances can be used in instance diagrams, which
are useful for documenting test cases and discussing examples.

Class:
A class describes a group of objects with similar properties (attributes), common behavior
(operations), common relationships to other objects, and common semantics
A class describes a collection of similar objects. It is a template where certain
basic characteristics of a set of objects are defined. A class defines the basic
attributes and the operations of the objects of that type. Defining a class does
not define any object, but it only creates a template. For objects to be actually
created, instances of the class are to be created as per the requirement of the
case.
Classes are built on the basis of abstraction, where a set of similar objects is
observed and their common characteristics are listed. Of all these, the
characteristics of concern to the system under observation are taken and the
class definition is made. The attributes of no concern to the system are left
out. This is known as abstraction. So, the abstraction is the process of hiding
superfluous details and highlighting pertinent details in respect to the system
under development.

It should be noted that the abstraction of an object varies according to its

application. For instance, while defining a pen class for a stationery shop, the

attributes of concern might be the pen color, ink color, pen type etc., whereas

a pen class for a manufacturing firm would be containing the other dimensions

of the pen like its diameter, its shape and size etc.

Each application-domain concept from the real world that is important to the

application should be modeled as an object class. Classes are arranged into

hierarchies sharing common structure and behavior and are associated with

other classes. This gives rise to the concept of inheritance.

Through inheritance, a new type of class can be defined using a similar

existing class with a few new features. For instance, a class vehicle can be

defined with the basic functionality of any vehicle and a new class called car

can be derived out of it with a few modifications. This would save the

developers time and effort as the classes already existing are reused without

much change.

ISDN

2011-11-18T08:36:00.000-08:00

ISDN (Integrated Services Digital Network) is a set of CCITT/ITU standards for digital transmission over ordinary telephone copper wire as well as over other media. Home and business users who install an ISDN adapter (in place of a telephone modem) receive Web pages at up to 128 Kbps compared with the maximum 56 Kbps rate of a modem connection. ISDN requires adapters at both ends of the transmission so your access provider also needs an ISDN adapter. ISDN is generally available from your phone company in most urban areas in the United States and Europe. In many areas where DSL and cable modem service are now offered, ISDN is no longer as popular an option as it was formerly.

Attenuation of Digital Signals

2011-10-27T00:02:00.000-07:00

Signal strength falls off with distance
• Depends on medium
• Received signal strength:
— must be enough to be detected
— must be sufficiently higher than noise to be received
without error
• Attenuation is an increasing function of
frequency
Delay Distortion

• Only in guided media
• Propagation velocity varies with frequency
Noise

• Additional signals inserted between transmitter
and receiver

• Thermal

— Due to thermal agitation of electrons
— Uniformly distributed

— White noise

• Intermodulation

— Signals that are the sum and difference of original
frequencies sharing a medium

• Crosstalk
— A signal from one line is picked up by another
• Impulse
— Irregular pulses or spikes
— e.g. External electromagnetic interference
— Short duration
— High amplitude
Channel Capacity
Data rate

In bits per second, bps (not Bps)

— Rate at which data can be communicated

Bandwidth

— In cycles per second of Hertz, Hz

— Constrained by transmitter and medium

• Convention: not all k’s are equal

— data rates are given as power of 10

• e.g., kHz is 1000Hz

— data is given in terms of power of 2

• e.g., KByte is 1024 Bytes

Nyquist Bandwidth

• If rate of signal transmission is 2B
then a signal with frequencies no
greater than B is sufficient to carry
the signal rate.
— Why? Assume we have a square wave
of repeating 101010. If a positive pulse
is a 1 and a negative pulse is 0, then
each pulse lasts 1/2 T1 (T1 = 1/f1) and
the data rate is 2f1 bits per second.

• If we limit the components to a maximum
frequency (restrict the bandwidth) we need to
make sure the signal is accurately represented.
• Based on the accuracy we require, the
bandwidth can carry a particular data rate. The
theoretical maximum communication limit is
given by the Nyquist formula:
C= 2B log2M
C = capacity or data transfer rate in bps
B = bandwidth (in hertz)
M = number of possible signaling levels
Signal Strength

— An important parameter in communication is the strength
of the signal transmitted. Even more important is the
strength being received.
— As signal propagates it will be attenuated (decreased)
— Amplifiers are inserted to increase signal strength
— Gains, losses and relative levels of signals are expressed in
decibels
• This is a logarithmic scale, but strength usually falls logarithmically
• Calculation of gains and losses involves simple addition and
subtraction
Delay Distortion

— Different frequency components of a signal
• are attenuated differently, and
• travel at different speeds through guided
media
— This may lead to delay distortion
Shannon capacity

— A transmission line may experience interference
from a number of sources, called noise. Noise is
measured in terms of signal to noise power ratio,

expressed in decibels:

Cross Talk

— near-end crosstalk (NEXT), cross talk of strong
transmit (output) signal to weak receive (input)
signal.
— adaptive NEXT canceling using op-amp

Noise

• Impulse Noise
— impulse caused by switching, lightning etc.
• Thermal Noise
— present irrespective of any external effects
— caused by thermal agitation of electrons

• White Noise

— random noise – entire spectrum
— listen:
• http://www.burninwave.com/download/whitenoise.wav
• Pink Noise
— “realistic spectrum”
— the power spectral density is inversely proportional
to the frequency
— listen:
• http://www.burninwave.com/download/pinknoise.wav

REFERENCE:-)

CS 420/520

DATA COMMUNICATION Terminology

2011-10-26T23:43:00.000-07:00

Simplex

— One direction
• e.g. Television

Half duplex
— Either direction, but only one way at a time
• e.g. police radio
• Full duplex
— Both directions at the same time
• e.g. telephone

Frequency, Spectrum and
Bandwidth
Time domain concepts

Analog signal
• Varies in a smooth way over time
— Digital signal
• Maintains a constant level then changes to another constant
level
— Periodic signal
• Pattern repeated over time
— Aperiodic signal
• Pattern not repeated over time
Analogue & Digital Signals

Periodic

Signals

Frequency Domain Concepts

Signal is usually made up of many frequencies
• Components are sine waves
• It can be shown (Fourier analysis) that any
signal is made up of component sine waves
• One can plot frequency domain functions
Data Rate and Bandwidth

• Any transmission system has a limited band of
frequencies
• This limits the data rate that can be carried

Reference :-

Data Communication

2011-10-26T23:24:00.000-07:00

Simplified File Transfer
Architecture:-
A Three Layer Model

1• Network Access Layer

2• Transport Layer

3• Application Layer

Network Access Layer

• Exchange of data between the computer and
the network
• Sending computer provides address of
destination
• May invoke levels of service
• Dependent on type of network used (LAN,
packet switched etc.)
Transport Layer

• Reliable data exchange
• Independent of network being used
• Independent of application
Application Layer

• Support for different user applications
• e.g. e-mail, file transfer

Protocol Architectures and
Networks
Addressing Requirements

• Two levels of addressing required
• Each computer needs unique network address
• Each application on a (multi-tasking) computer
needs a unique address within the computer
— The service access point or SAP
— The port on TCP/IP stacks

OSI Layers

• Network
— Transport of information
— Higher layers do not need to know about underlying technology
— Not needed on direct links
• Transport
— Exchange of data between end systems
— Error free
— In sequence
— No losses
— No duplicates
— Quality of service

• Session

— Control of dialogues between applications
— Dialogue discipline
— Grouping
— Recovery

• Presentation

— Data formats and coding
— Data compression
— Encryption
• Application
— Means for applications to access OSI environment

• Physical
— Physical interface between devices
• Mechanical
• Electrical
• Functional
• Procedural
• Data Link
— Means of activating, maintaining and deactivating a
reliable link
— Error detection and control
— Higher layers may assume error free transmission