Web Hosting Tomcat, Java, JSP, Servlets, J2EE, PHP, MySQL

Object-Oriented Design with UML and Java co.hire(e1, m3);

webmaster — Sat, 04 Jul 2009 07:33:25 +0000

Object-Oriented Design with UML and Java co.hire(e1, m3); co.hire(e2, m3); co.printEmployeeDetails(); } } The UML collaboration diagram of figure G.5 shows the configuration of objects and the message flows between them. The application, represented by the actor, sends the message printEmployeeDetails to the Company object with identity co. This Company object then sends the message printDetails in turn to the three employee objects. When the message printDetails is received by the manager object it executes the redefined version for this method. The method printDetails from class SalesManager prints the managers details then gets the names of the two employees that are members of that manager s team. e1 : Sales Employee e2 : Sales Employee co : Company m3 : SalesManager 2: printDetails 4: printDetails 3: printDetails 1: printEmployee Details 2.2: getName 2.1: getName Figure G.5 Collaboration diagram G.3 Interfaces An interface is a particular kind of abstract class in which all methods are deferred and for which there are no (non static) attributes. In effect, an interface is a pure abstract class. A Java interface is implicitly public as are all its methods. Further, these methods are implicitly qualified as abstract. It is permissible in Java to make these qualifications explicit, rendering additional documentation for the reader. A Java interface is permitted to contain class attributes but these must be static and final. Java interfaces are sometimes used to collect a number of related constants. Other classes can then refer to them using the class name qualifier or by subclassing to provide direct referencing. Since an interface has no state we say that any specialized class implements an interface. An abstract class or a concrete class can implement an interface. A subclass that is itself another interface is said to extend the interface superclass.

For high quality website hosting services please check cheap web hosting website.

Appendix G: Object-Oriented Programming with Java public void

webmaster — Fri, 03 Jul 2009 20:29:07 +0000

Appendix G: Object-Oriented Programming with Java public void hire(SalesEmployee sales, SalesManager man) { Iterator iter = theEmployees.iterator(); while(iter.hasNext() == true) { Employee emp = (Employee)iter.next(); if(emp instanceof SalesManager && emp == man) { SalesManager manager = (SalesManager)emp; manager.addSalesMember(sales); } } theEmployees.add(sales); } public void printEmployeeDetails() { ConsoleIO.out.println( Company: +theName); Iterator iter = theEmployees.iterator(); while(iter.hasNext() == true) { Employee emp = (Employee)iter.next(); emp.printDetails(); } } // —– Attributes —————-private String theName; private ArrayList theEmployees = new ArrayList(10); } Finally, the application is shown in Program G.3. The program run produces the output shown below. The manager Jessie Kennedy presents both her details as well as listing the names of her sales team. The other employees simply list their details. Company: Napier Manager: Jessie Kennedy, Professor, 1200, Budget: 8000 Sales member: Ken Barclay Sales member: John Savage Sales employee: Ken Barclay, Lecturer, 1000, Sales target: 2000 Sales employee: John Savage, Lecturer, 1200, Sales target: 2000 Program G.3 public class Main { public static void main(String[ ] args) { SalesEmployee e1 = new SalesEmployee( Ken Barclay , Lecturer , 1000, 5000); SalesEmployee e2 = new SalesEmployee( John Savage , Senior Lecturer , 1200, 2000); SalesManager m3 = new SalesManager( Jessie Kennedy , Professor , 1200, 10000); Company co = new Company( Napier ); co.hire(m3);

If you looking for unlimited one inclusive web hosting plan please check cheap web hosting website.

Object-Oriented Design with UML and Java Concrete subclass

webmaster — Fri, 03 Jul 2009 09:45:55 +0000

Object-Oriented Design with UML and Java Concrete subclass SalesManager and SalesEmployee must provide an implementation for printDetails. For class SalesManager we first print the details for the manager, then we cycle through the sales team members printing their name. Note also the method addSalesMember for adding a new SalesEmployee object to the team overseen by the manager. public class SalesManager extends Employee { public SalesManager(String aName, String aJobTitle, int aSalary, int aBudget) { super(aName, aJobTitle, aSalary); theBudget = aBudget; } public void addSalesMember(SalesEmployee emp) { theSalesTeam.add(emp); } public void printDetails() { ConsoleIO.out.print( SalesManager: + theName); ConsoleIO.out.print( , +theJobTitle); ConsoleIO.out.print( , +theSalary); ConsoleIO.out.println( , +theBudget); Iterator iter = theSalesTeam.iterator(); while(iter.hasNext() == true) { SalesEmployee emp = (SalesEmployee)iter.next(); ConsoleIO.out.println( tSales team member: +emp.getName()); } } // —– Attributes —————-private int theBudget; private ArrayList theSalesTeam = new ArrayList(10); } Class Company is modified from the previous version. Two hire methods are available. The first simply includes a new manager as part of the workforce. The second (overloaded) hire method includes the sales employee in the company workforce, but additionally includes her into the sales team managed by a particular team leader. To implement this we must find an existing employee that is the given manager. The code for this is: if(emp instanceof SalesManager && emp == man) { … } where the first part of the conditional checks the run-time type of the employee. public class Company { public Company(String aName) { theName = aName; } public void hire(SalesManager man) { theEmployees.add(man); }

If you looking for unlimited one inclusive web hosting plan please check unlimited web hosting website.

Appendix G: Object-Oriented Programming with Java All staff

webmaster — Thu, 02 Jul 2009 21:51:35 +0000

Appendix G: Object-Oriented Programming with Java All staff have a name, job title and salary. A SalesEmployee has a sales target set against them. A SalesManager has a budget and is a manager for any number of the sales employees. -theEmployees 0..* 0..* -theSalesTeam Company SalesManager SalesEmployee abstract Employee Operations +printDetails Figure G.4 Abstract Employee class Class Employee is abstract with a deferred method printDetails. Both concrete subclasses SalesEmployee and SalesManager must define this method. For class SalesEmployee this method gives an employee summary listing their name, job title, salary and sales target. For class SalesManager the printDetails method again lists the manager s details but additionally gives the names of the sales staff in her team. Here is class Employee: public abstract class Employee { public Employee(String aName, String aJobTitle, int aSalary) { theName = aName; theJobTitle = aJobTitle; theSalary = aSalary; } public String getName() { return theName; } public abstract void printDetails(); // DEFERRED // —– Attributes —————- protected String theName; protected String theJobTitle; protected int theSalary; } Note that the class is declared as abstract. No instances of an abstract class can be created. Observe also how the deferred operation printDetails is introduced. No method body is given, simply the operation signature giving the name, return type and formal parameters, if any. The operation is qualified as abstract.

For high quality jboss hosting services please check jboss web hosting website.

Object-Oriented Design with UML and Java The collection

webmaster — Thu, 02 Jul 2009 11:44:58 +0000

Object-Oriented Design with UML and Java The collection is, of course, a mix of Employee and Manager objects. When we select an item from the collection we cast it to some kind of Employee object. The polymorphic effect of the operation printDetails is determined dynamically at run-time according to the type of the recipient object. This is exhibited by the program s output: Company: Napier Employee: Ken Barclay, Lecturer, 1000 Manager: John Savage, Senior Lecturer, 1200, 2000 Manager: Jessie Kennedy, Reader, 1200, 3000 According to the actual object s type the correct printDetails method is executed. Program G.2 public class Main { public static void main(String[ ] args) { Employee e1 = new Employee( Ken Barclay , Lecturer , 1000); Manager m2 = new Manager( John Savage , Senior Lecturer , 1200, 2000); Manager m3 = new Manager( Jessie Kennedy , Reader , 1200, 3000); Company co = new Company( Napier ); co.hire(e1); co.hire(m2); co.hire(m3); co.printEmployeeDetails(); } } Substitution and polymorphism combine to make our designs extensible. The Employee/Manager class hierarchy of figure G.3 may be both broadened and deepened without incurring changes elsewhere. For example, we could introduce further kinds of employees or more specialized managers. No change would be necessary to the class Company. Through substitution, any of these specialized employees may be hired by the company. The company can produce a listing of all its employees through the polymorphism of the operation printDetails. G.2 Abstract classes An abstract class has one or more abstract (or deferred) methods. An abstract method does not include a method body, only a signature. The abstract methods may be introduced in the class itself or inherited from another abstract class. These abstract methods introduce a protocol that must be respected by all subclasses. Thus, a concrete subclass of an abstract superclass must present an implementation for all inherited abstract methods. Abstract classes are illustrated with the example of figure G.4. A Company has any number of employees working for it. The employees are either sales staff or sales managers.

For high quality website hosting services please check cheap web hosting website.

Appendix G: Object-Oriented Programming with Java Employee Manager

webmaster — Wed, 01 Jul 2009 23:59:10 +0000

Appendix G: Object-Oriented Programming with Java Employee Manager Company -theEmployees 0..* Figure G.3 Company/Employee class diagram The one-to-many relationship between a Company object and its Employee objects is realized by an ArrayList object as part of the Company class. The method hire in the Company class is supplied with a handle to some Employee object that is added to the ArrayList container. In program G.2 the actual parameter objects given to method hire are instances of both the Employee class and the Manager class, illustrating the use of substitution. import java.util.*; import textio.*; public class Company { public Company(String aName) { theName = aName; } public void hire(Employee emp) { theEmployees.add(emp); } public void printEmployeeDetails() { ConsoleIO.out.println( Company: +theName); Iterator iter = theEmployees.iterator(); while(iter.hasNext() == true) { Employee emp = (Employee)iter.next(); emp.printDetails(); } } // —– Attributes —————-private String theName; private ArrayList theEmployees = new ArrayList(10); } The method printEmployeeDetails from class Company cycles through the members of the collection and sends each the message printDetails. Here, we utilize the Iterator class from the Java Collections Framework classes. The various containers provide an Iterator object through the message iterator. The principal methods from this class are hasNext (which determines if there are more elements in the collection yet to visit) and next (which returns a handle to the next available item from the collection).

For high quality java hosting services please check java web hosting website.

Object-Oriented Design with UML and Java Observe how

webmaster — Wed, 01 Jul 2009 12:10:08 +0000

Object-Oriented Design with UML and Java Observe how the method printDetails is reintroduced in the subclass Manager. This is an example of method redefinition. The subclass is a more specialized version of the superclass with a budgetary responsibility, and requires a different presentation from this method. Note also how this method directly references the protected attributes theName, theJobTitle and theSalary from the superclass (but see also our discussions in chapter 5). We have said that a subclass inherits all the features of the superclass. Strictly, a subclass inherits all but the superclass constructor. This is not unreasonable since a subclass will frequently have additional attributes that will require appropriate treatment under, for example, initialization. The subclass constructor will be responsible for initializing both its own and its inherited attributes. When creating an instance of the class Employee that class constructor is employed to perform the correct initialization. In a similar manner the subclass Manager achieves proper initialization of its inherited attributes through the superclass constructor. The code is: public Manager(String aName, String aJobTitle, int aSalary, int aBudget) { super(aName, aJobTitle, aSalary); theBudget = aBudget; } The first statement is responsible for invoking the superclass constructor. The remaining statement initializes the additional subclass attribute in the usual way. Program G.1 illustrates the two classes in use. An instance of the class Employee and an instance of the class Manager are first created. Both are then sent the message printDetails, producing the output: Employee: Ken Barclay, Lecturer, 1000 Manager: John Savage, Senior Lecturer, 1200, 2000 Since class Manager has redefined this method then the new effect is exhibited by the second line of the output. Program G.1 public class Main { public static void main(String[ ] args) { Employee e1 = new Employee( Ken Barclay , Lecturer , 1000); Manager m2 = new Manager( John Savage , Senior Lecturer , 1200, 2000); e1.printDetails(); m2.printDetails(); } } This next example illustrates the principle of substitution and the polymorphic effect. The class diagram is shown in figure G.3. An organization has any number of people working for it. They are classified as plain employees or managers as described in the preceding example.

For high quality jboss hosting services please check jboss web hosting website.

Appendix G: Object-Oriented Programming with Java // —–

webmaster — Wed, 01 Jul 2009 00:06:57 +0000

Appendix G: Object-Oriented Programming with Java // —– Attributes —————-protected String theName; protected String theJobTitle; protected int theSalary; } The attributes of the class have protected visibility. Protected features behave as if they were private to other classes but public to subclasses. This means that any subclass of Employee will be able to refer to these values directly. Consider now a manager. A manager is also an employee of an organization but with added responsibilities. A manager may head up one or more projects, or have responsibility for some budgetary amount. Let us introduce class Manager as a specialization of class Employee. A class diagram for this is given in figure G.2. Employee Manager Figure G.2 Employee/Manager class diagram The corresponding code for class Manager is: public class Manager extends Employee { public Manager(String aName, String aJobTitle, int aSalary, int aBudget) { super(aName, aJobTitle, aSalary); theBudget = aBudget; } public void printDetails() { ConsoleIO.out.print( Manager: +theName); ConsoleIO.out.print( , +theJobTitle); ConsoleIO.out.print( , +theSalary); ConsoleIO.out.println( , +theBudget); } // —– Attributes —————-private int theBudget; } The keyword extends notifies that class Manager is an extension or a specialization of the class Employee. The Manager class inherits all the features of the class Employee. Since an instance of the class Employee can be sent the message getName, then so too can an instance of the class Manager.

If you looking for unlimited one inclusive web hosting plan please check unlimited web hosting website.

380 Object-Oriented Design with UML and Java superclass

webmaster — Tue, 30 Jun 2009 13:10:38 +0000

380 Object-Oriented Design with UML and Java superclass and hence an instance of the subclass can receive all the messages defined in the superclass. Further, this implies that where in our code an instance of a superclass is expected an instance of a subclass may be used. This is known as the principle of substitutability. Substitution makes our software extensible since we may substitute an instance of a subclass that may be defined later in the lifetime of the software. Careful architecting of our systems is required to gain this leverage, but it can result in the introduction of instances of a new class without recourse to wholesale changes to the existing fabric of the software. Substitutability combines with the polymorphic effect to have a profound effect on our programming style. Through polymorphism we leverage improved program code organization. Conventional procedural code is frequently concerned with obtaining an appropriate effect according to the type of some object. The polymorphic effect removes this consideration from our code. Where once we might have used a complex if or switch statement, now we have a single simple program statement. Frequently, these conditional statements would populate large parts of our code and make program maintenance a major concern. Through dynamic binding one object sends a message to another, indifferent to its actual type. Substitution means the recipient object may be an instance of any appropriate subclass. The recipient object knows to which type or class it belongs and executes the correct method. If the recipient is an instance of a subclass in which the method has been redefined, then it is this redefined method that executes. Redefined methods of various subclasses will have different effects but the sending object is decoupled from this concern and for the need to select the appropriate behaviour. G.1 Specialization Consider a class that represents an Employee of an organization. From the previous chapter this class might appear as: public class Employee { public Employee(String aName, String aJobTitle, int aSalary) { theName = aName; theJobTitle = aJobTitle; theSalary = aSalary; } public String getName() { return theName; } public void printDetails() { ConsoleIO.out.print( Employee: +theName); ConsoleIO.out.print( , +theJobTitle); ConsoleIO.out.println( , +theSalary); }

If you looking for unlimited one inclusive web hosting plan please check unlimited web hosting website.

Appendix G Object-Oriented Programming with Java In this

webmaster — Tue, 30 Jun 2009 03:17:44 +0000

Appendix G Object-Oriented Programming with Java In this appendix we focus on the use and deployment of specialization. We illustrate Java s support for class specialization, substitution, method redefinition and the polymorphic effect. Further, we review abstract classes with deferred methods and interfaces. Specialization permits a subclass to inherit features from a superclass, leveraging a measure of code reuse. Since a subclass object has all the features of a superclass object, then the former can substitute for where the latter is required. By carefully exploiting substitution we can make our software more extensible and more adaptable to change. Redefining methods in subclasses exploits the effect of dynamic binding, where a particular message adapts to the recipient s behaviour. These effects are a consequence of working to the interface described by a superclass. One of the more distinctive features of object-oriented programming languages is their support for specialization. A specialized class is one that is developed out of an existing class by inheriting all the features of that class. Further, the specialized class can introduce additional attributes, additional methods, and may choose to redefine any of the inherited methods. Specialization can lead to significant amounts of code reuse where the specialized class only implements its differences with the existing class. The specialized class is called the subclass. The class from which a specialized class is developed is referred to as the superclass. In Java the subclass is said to be an extension of the superclass. This is intended to connote the idea that the subclass has all the features of the superclass and possibly more. The subclass/superclass arrangement is usually presented in a UML class diagram as shown by figure G.1. Specialization also gives rise to the notion of isA. An instance of a subclass is an instance of a superclass. This is correct since a subclass inherits all the features of its Superclass Subclass Figure G.1 A class diagram with specialization 379

If you looking for unlimited one inclusive web hosting plan please check cheap web hosting website.