oot4

Exam zone

Model Paper Of Object Oriented Techniques (ECS-503) Time 3 Hours

Que. 1 Attempt any two parts:

Total Marks-100

(2*10=20 marks)

a) Draw the class diagram of order management System.

Ans:

b) What is the Goal of modeling? What are the elements of OOPs? Discuss in brief.

Ans: Goal: “Modeling is a way of thinking and reasoning about systems. The goal of modeling is to come up with a representation that is easy to use in describing systems in a mathematically consistent manner.�

Elements of OOPs: 1 Class: A class is a template for an object, a user-defined datatype that contains variables, properties, and methods.

2 Instance : One can have an instance of a class; the instance is the actual object created at runtime.

3 Method: Method is a set of procedural statements for achieving the desired result. It performs different kinds of operations on different data types.

4 Message passing: The process by which an object sends data to another object or asks the other object to invoke a method.

5 Inheritance: Inheritance is a process in which a class inherits all the state and behavior of another class. This type of relationship is called child-Parent or is-a relationship. "Subclasses" are more specialized versions of a class, which inherit attributes and behaviors from their parent classes, and can introduce their own.

6 Abstraction : Abstraction refers to the act of representing essential features without including the background details or explanations. Classes use the concept of abstraction and are defined as a list of abstract attributes.

7 Encapsulation : Encapsulation conceals the functional details of a class from objects that send messages to it.

8 polymorphism: Polymorphism allows the programmer to treat derived class members just like their parent class's members. More precisely, Polymorphism in object-oriented programming is the ability of objects belonging to different data types to respond to calls of methods of the same name, each one according to an appropriate type-specific behavior 9 Decoupling: Decoupling allows for the separation of object interactions from classes and inheritance into distinct layers of abstraction. A common use of decoupling is to polymorphically decouple the encapsulation.

c) Discuss the conceptual model of UML. Ans: As UML describes the real time systems it is very important to make a conceptual model and then proceed gradually. Conceptual model of UML can be mastered by learning the following three major elements:  UML building blocks  Rules to connect the building blocks  Common mechanisms of UML The building blocks of UML can be defined as:  Things  Relationships  Diagrams (1) Things: Things are the most important building blocks of UML. Things can be:  Structural  Behavioral  Grouping  Annotational 1.

Structural things: The Structural things define the static part of the model. They represent physical and conceptual elements. Following are the brief descriptions of the structural things.

Class: Class represents set of objects having similar responsibilities.

Interface: Interface defines a set of operations which specify the responsibility of a class.

Collaboration: Collaboration defines interaction between elements.

Use case: Use case represents a set of actions performed by a system for a specific goal.

Component: Component describes physical part of a system.

Node: A node can be defined as a physical element that exists at run time.

2.

Behavioral things: A behavioral thing consists of the dynamic parts of UML models. Following are the behavioral things: Interaction: Interaction is defined as a behavior that consists of a group of messages exchanged among elements to accomplish a specific task.

State machine: State machine is useful when the state of an object in its life cycle is important.

It defines the sequence of states an object goes through in response to events. Events are external factors responsible for state change.

3.

Grouping things: Grouping things can be defined as a mechanism to group elements of a UML model together. There is only one grouping thing available: Package: Package is the only one grouping thing available for gathering structural and behavioral things.

4.

Annotational things: Annotational things can be defined as a mechanism to capture remarks, descriptions, and comments of UML model elements. Note is the only one Annotational thing available.

Note:A note is used to render comments, constraints etc of an UML element.

(2) Relationship : Relationship is another most important building block of UML. It shows how elements are associated with each other and this association describes the functionality of an application.

There are four kinds of relationships available.

Dependency: Dependency is a relationship between two things in which change in one element also affects the other one.

Association:Association is basically a set of links that connects elements of an UML model. It also describes how many objects are taking part in that relationship.

Generalization:Generalization can be defined as a relationship which connects a specialized element with a generalized element. It basically describes inheritance relationship in the world of objects.

Realization:Realization can be defined as a relationship in which two elements are connected.

One element describes some responsibility which is not implemented and the other one implements them. This relationship exists in case of interfaces.

(3) UML Diagrams: UML diagrams are the ultimate output of the entire discussion. All the elements, relationships are used to make a complete UML diagram and the diagram represents a system.

The visual effect of the UML diagram is the most important part of the entire process. All the other elements are used to make it a complete one.

UML includes the following nine diagrams and the details are described in the following chapters.

1. Class diagram 2. Object diagram 3. Use case diagram 4. Sequence diagram 5. Collaboration diagram 6. Activity diagram 7. Statechart diagram 8. Deployment diagram 9. Component diagram Que. 2 Attempt any two parts:

(2*10=20 marks)

a) i) What is purpose of component diagram.

Ans: Component diagram is a special kind of diagram in UML. The purpose is also different from all other diagrams discussed so far. It does not describe the functionality of the system but it describes the components used to make those functionalities.

So from that point component diagrams are used to visualize the physical components in a system. These components are libraries, packages, files etc.

Component diagrams can also be described as a static implementation view of a system. Static implementation represents the organization of the components at a particular moment.

A single component diagram cannot represent the entire system but a collection of diagrams are used to represent the whole.

So the purpose of the component diagram can be summarized as:  Visualize the components of a system.  Construct executables by using forward and reverse engineering.  Describe the organization and relationships of the components. ii) Write a note on Deployment diagram.

Ans: Deployment diagram represents the deployment view of a system. It is related to the component diagram. Because the components are deployed using the deployment diagrams. A deployment diagram consists of nodes. Nodes are nothing but physical hardwares used to deploy the application.

Deployment diagrams are useful for system engineers. An efficient deployment diagram is very important because it controls the following parameters:  Performance  Scalability  Maintainability  Portability So before drawing a deployment diagram the following artifacts should be identified:  Nodes  Relationships among nodes The following deployment diagram is a sample to give an idea of the deployment view of order management system. Here we have shown nodes as:  Monitor  Modem  Caching server  Server The application is assumed to be a web based application which is deployed in a clustered environment using server 1, server 2 and server 3. The user is connecting to the application using internet. The control is flowing from the caching server to the clustered environment. b) Draw the usecase diagram of Restaurant Management System.

Ans:

c) Draw the sequence diagram of ‘edit item details' system use case.

Ans:

Que. 3 Attempt any four parts: a) What are the advantages of Object Oriented Approach.

Ans:

(4*5=20 marks)

Reduced Maintenance: The primary goal of object-oriented development is the assurance that the system will enjoy a longer life while having far smaller maintenance costs. Because most of the processes within the system are encapsulated, the behaviors may be reused and incorporated into new behaviors.

Real-World Modeling: Object-oriented system tend to model the real world in a more complete fashion than do traditional methods. Objects are organized into classes of objects, and objects are associated with behaviors. The model is based on objects, rather than on data and processing.

Improved Reliability and Flexibility: Object-oriented system promise to be far more reliable than traditional systems, primarily because new behaviors can be "built" from existing objects.

Because objects can be dynamically called and accessed, new objects may be created at any time. The new objects may inherit data attributes from one, or many other objects. Behaviors may be inherited from super-classes, and novel behaviors may be added without effecting existing systems functions.

High Code Reusability: When a new object is created, it will automatically inherit the data attributes and characteristics of the class from which it was spawned. b) What is DFD? Draw the DFD for the Online Booking System.

Ans: A data flow diagram (DFD) is a graphical representation of the "flow" of data through an information system. DFDs can also be used for the visualization of data processing (structured design). A DFD provides no information about the timing of processes, or about whether processes will operate in sequence or in parallel.

DFD:

reference id

USER request

response ADMINISTRATOR

Online Booking

request

System c) What are the principles of JSD(Jackson Structures Development)?

Ans: Principles of operation and steps Three basic principles of operation of JSD is that:  Development must start with describing and modelling the real world, rather than specifying or structuring the function performed by the system. A system made using JSD method performs the simulation of the real world before any direct attention is paid to function or purpose of the system.  An adequate model of a time-ordered world must itself be time-ordered. Main aim is to map progress in the real world on progress in the system that models it.



The way of implementing the system is based on transformation of specification into efficient set of processes. These processes should be designed in such a manner that it would be possible to run them on available software and hardware.

When it was originally presented by Jackson in 1983, the method consisted of six steps.[1] 1. Entity/Action Step 2. Initial Model Step 3. Interactive Function Step 4. Information Function Step 5. System Timing Step 6. System Implementation Step d) What are various steps involve in OMT? Ans: The Object Modeling Technique (OMT) software engineering methodology [#!omt!#] is another well known example of a software engineering methodology. The OMT software engineering methodology deals with object-oriented development in the analysis and design phases.

The analysis phase starts with a problem statement which includes a list of goals and a definitive enumeration of key concepts within a domain. This problem statement is then expanded into three views, or models: an object model, a dynamic model, and a functional model. The object model represents the artifacts of the system. The dynamic model represents the interaction between these artifacts represented as events, states, and transitions. The functional model represents the methods of the system from the perspective of data flow. The analysis phase generates object-model diagrams, state diagrams, event-flow diagrams, and data-flow diagrams.

The analysis phase is now complete.

The system design phase follows the analysis phase. Here the overall architecture is established.

First the system is organized into subsystems which are then allocated to processes and tasks, taking into account concurrency and collaboration. Then persistent data storage is established along with a strategy to manage shared-global information. Next, boundary situations are examined to help guide trade-off priorities.

The object design phase follows the system design phase. Here the implementation plan is established. Object classes are established along with their algorithms with special attention to the optimization of the path to persistent data. Issues of inheritance, associations, aggregation, and default values are examined.

Implementation phase involes the implementation of the above design either using database or by using Programming language. e) How can a programmer manage inheritance by OO language?

Ans Different kinds of objects often have a certain amount in common with each other. Mountain bikes, road bikes, and tandem bikes, for example, all share the characteristics of bicycles (current speed, current pedal cadence, current gear). Yet each also defines additional features that make them different: tandem bicycles have two seats and two sets of handlebars; road bikes have drop handlebars; some mountain bikes have an additional chain ring, giving them a lower gear ratio.

Object-oriented programming allows classes to inherit commonly used state and behavior from other classes. In this example, Bicycle now becomes the superclass of MountainBike, RoadBike, and TandemBike. In the Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses:

A hierarchy of bicycle classes.

The syntax for creating a subclass is simple. At the beginning of your class declaration, use the extends keyword, followed by the name of the class to inherit from: class MountainBike extends Bicycle { // new fields and methods defining a mountain bike would go here }

This gives MountainBike all the same fields and methods as Bicycle, yet allows its code to focus exclusively on the features that make it unique. This makes code for your subclasses easy to read. However, you must take care to properly document the state and behavior that each superclass defines, since that code will not appear in the source file of each subclass. f) What aspects of program should be documented?

Ans: 1. Basic usage is mostly covered in a man page.

2. More advanced usage can be achieved by listing ALL configuration options in the documentation and giving examples on how to use them (take the very good Apache documentation for example).

3. Source code, of course, because somebody may want to add features to the program.

4. Examples of usage to supply a working basic configuration file and document it heavily.

5. Installation of the program, because not all programs work with ./configure && make && make install.

6. User interface, especially if it is not a common point-and-click one.

Que 4. Attempt any two parts:

(2*10=20 marks)

a) What is the difference between overloading and Overriding? Write code to support your answer.

Ans Overloading In Java it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case,the methods are said to be overloaded, and the process is referred to as method overloading.

Method overloading is one of the ways that Java implements polymorphism. // OverLoad Demo class overload { void test(int a) { System.out.println(a*a); } void test(int a,double b) { System.out.println("overloadoutput"+(a+b)*2); } } class overloaddemo { public static void main(String args[]) { overload obj=new overload(); obj.test(2,3); obj.test(4,5); } } Overriding when a method in a subclass has the same name and type signature as a method in its superclass, then the method in the subclass is said to override the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass. //Override Demo class a { int i;int j; void show() { System.out.println(i+j); } } class b extends a { int k;

void show() { System.out.println(i+j+k); } } class override { public static void main(String ar[]) { a superobj=new a(); b subobj=new b(); superobj.i=20;superobj.j=30; subobj.i=1;subobj.j=2;subobj.k=3; subobj.show();// op-6 } } b)Write short notes on the following: (i) throw The throw keyword denotes a statement that causes an exception to be initiated. It takes the Exception object to be thrown as argument. The exception will be caught by an immediately encompassing try-catch construction or propagated further up the calling hierarchy. (ii) throws The throws keyword is a modifier of a method that designates that exceptions may come out of the mehtod, either by virtue of the method throwing the exception itself or because it fails to catch such exceptions that a method it calls may throw. (iii) finally The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling — it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated. c) Differentiate Following i) Interface and Abstract class Ans Interface Abstract class interface contains methods that must be abstract class may contain concrete abstract methods. interface contains variables that must be abstract class may contain non-final and static and final final variables. members in an interface are public by abstract class may contain non-public default members. interface is used to "implements" whereas abstract class is used to "extends".

interface can be used to achieve multiple abstract class can be used as a single inheritance inheritance. interface can "extends" another interface abstract class can "extend" another class and "implements" multiple interfaces. interface is absolutely abstract abstract class can be invoked if a main() exists. interface is more flexible than abstract class because one class can only "extends" one super class, but "implements" multiple interfaces. (ii) Swing and AWT Ans: Several consequences result from this difference between AWT and Swing. AWT is a thin layer of code on top of the OS, whereas Swing is much larger. Swing also has very much richer functionality. Using AWT, you have to implement a lot of things yourself, while Swing has them built in. For GUI-intensive work, AWT feels very primitive to work with compared to Swing. Because Swing implements GUI functionality itself rather than relying on the host OS, it can offer a richer environment on all platforms Java runs on. AWT is more limited in supplying the same functionality on all platforms because not all platforms implement the same-looking controls in the same ways. Swing components are called "lightweight" because they do not require a native OS object to implement their functionality. JDialog and JFrame are heavyweight, because they do have a peer. So components like JButton, JTextArea, etc., are lightweight because they do not have an OS peer. A "peer" is a widget provided by the operating system, such as a button object or an entry field object.

Que. 5 Attempt any two parts:

(2*10=20 marks)

a) What is a Java Bean? Discuss the advantages of Java Bean.

Ans Concept JavaBeans™ is a portable, platform-independent component model written in the Java programming language. The JavaBeans architecture was built through a collaborative industry effort and enables developers to write reusable components in the Java programming language.

With the JavaBeans API you can create reuseable, platform-independent components. Using JavaBeans-compliant application builder tools, you can combine these components into applets, applications, or composite components.

JavaBean components are known as beans. Beans are dynamic in that they can be changed or customized.

Advantages of Java Beans A software component architecture provides standard mechanisms to deal with software building blocks. The following list enumerates some of the specific benefits that Java technology provides for a component developer:  A Bean obtains all the benefits of Java's "write-once, run-anywhere" paradigm.



The properties, events, and methods of a Bean that are exposed to an application builder tool can be controlled.  A Bean may be designed to operate correctly in different locales, which makes it useful in global markets.  Auxiliary software can be provided to help a person configure a Bean. This software is only needed when the design-time parameters for that component are being set. It does not need to be included in the run-time environment.  The configuration settings of a Bean can be saved in persistent storage and restored at a later time.

A Bean may register to receive events from other objects and can generate events that are sent to other objects.

b) i). What is the servlet? What's the advantages using servlets than using CGI? Ans Servlets are modules that extend request/response-oriented servers, such as Java-enabled web servers. For example, a servlet may be responsible for taking data in an HTML order-entry form and applying the business logic used to update a company's order database. Servlets provide a way to generate dynamic documents that is both easier to write and faster to run. It is efficient, convenient, powerful, portable, secure and inexpensive. Servlets also address the problem of doing server-side programming with platform-specific APIs: they are developed with Java Servlet API, a standard Java extension. ii) What is the difference between Difference between doGet() and doPost()?

Ans A doGet() method is limited with 2k of data to be sent, and doPost() method doesn't have this limitation.

A request string for doGet() looks like the following: http://www.allapplabs.com/svt1?p1=v1&p2=v2&...&pN=vN doPost() method call doesn't need a long text tail after a servlet name in a request. All parameters are stored in a request itself, not in a request string, and it's impossible to guess the data transmitted to a servlet only looking at a request string. c) How you can use AWT controls? Write code for handling labels and CheckBox. Ans Controls are components that allow a user to interact with your application and the AWT supports the following types of controls: Labels,Push Buttons, Check Boxes, Choice Lists,Lists, Scrollbars, Text Components. These controls are subclasses of Component. // prg... to create three labels and add then on applet import java.awt.*; import java.applet.*; //defineing applet tag /*

<applet code = LabelDemo width=500 height=400> </applet> */ public class LabelDemo extends Applet { public void init() //"init()" method to initialize & add { Label l1 = new Label("1st label"); Label l2 = new Label("2nd label"); Label l3 = new Label("3rd label"); add(l1); add(l2); add(l3); } } //CheckBoxDemo import java.awt.event.*; import java.awt.*; import java.applet.*; /* <applet code="checkboxdemo" height=300 width=400 > </applet>*/ public class checkboxdemo extends Applet implements ItemListener { Checkbox c1,c2,c3;CheckboxGroup cbg;String msg=""; public void init() { cbg= new CheckboxGroup(); c1=new Checkbox("mango",cbg,true); add(c1); c1.addItemListener(this); c2=new Checkbox("apple",cbg,false);add(c2);c2.addItemListener(this); c3=new Checkbox("orange",cbg,false);add(c3);c3.addItemListener(this); }//init public void itemStateChanged(ItemEvent e) { repaint(); } public void paint (Graphics g) {

if ( cbg.getSelectedCheckbox()==c1) { msg="mango"; } g.drawString(msg,6,150); } }//checkboxgroup