20. JavaBeans with constrained properties ---D
 A. | Instantiate a PropertyChangeSupport object. |
| B. | Use methods of the VetoableChangeSupport class. |
| C. | Instantiate an ActionListener object. |
| D. | A and B |
| E. | None of the above |
| F. | All of the above |
Answers:
1. What do you have to do to make an instance variable into a JavaBean property? | ||
D is incorrect | Answer (B): By definition, JavaBean properties are declared as private variables. To allow other components and builder tools to access these properties, a Bean must define get and set methods for each property. See Creating a Simple Bean | |
2. An application builder tool can analyze how JavaBeans work. A tool uses what mechanism to do this? | ||
C is correct! | Answer (C): Builder tools can analyze JavaBeans through the process of introspection. JavaBeans support introspection by adhering to specific rules, called design patterns, for naming Bean features. Each Bean has a related Bean information class, and this information class provides property, method, and event information about the Bean itself. A Bean information class implements a BeanInfo interface. The class explicitly lists the Bean features that are to be exposed to application builder tools. See What Distinguishes JavaBeans from Java Classes? | |
3. Properties control what aspects of a JavaBean? | ||
B is correct! | Answer (B): By definition, a JavaBean's properties control its appearance and behavior. Because builder tools can introspect on a Bean to discover its properties and to expose them for manipulation, you can change a Bean's property at design time. See Properties | |
4. JavaBean methods are all | ||
D is correct! | Answer (D): By definition, all JavaBean methods are identical to methods of other Java classes. Like other Java methods, Bean methods can be called by other Beans or via scripting languages. See Basic Bean Concepts | |
5. A source Bean is a JavaBean that fires an event, while the Bean that receives the event is called a | ||
A is correct! | Answer: (A) Beans use events to communicate with other Beans. Source beans fire events, which means the Bean sends an event to another Bean. A Bean may receive an event, in which case it is considered a listener Bean. A listener Bean registers its interest in the event with the source Bean. See Setting Up a Property Listener | |
6. JavaBeans and widgets are both considered to be reusable software components. However, JavaBeans differ from widgets because Beans | ||
A is incorrect | Answer (B): JavaBeans add standardized interfaces and object introspection mechanisms to widgets. These mechanisms allow builder tools to query JavaBean components about their properties and behavior. The tools can determine the kinds of properties defined by the components and the kinds of events that they generate or to which they respond. See What Distinguishes JavaBeans from Widgets? | |
7. The BeanBox is a JavaBean testing tool that comes with Java's BDK (Bean Developer's Kit). The BeanBox has the following windows: | ||
A is correct! | Answer (A): When you start the BeanBox, you see three windows: the ToolBox window, the BeanBox window, and the Properties window. The ToolBox window displays the names of the JavaBeans currently installed in the BeanBox. The BeanBox window is the window in which you build your application. The Properties window displays the properties of the Bean currently selected in the BeanBox window. See Starting the BeanBox | |
8. JavaBeans communicate with each other via events, such as action events. Establish the connection between Beans by: | ||
D is correct! | Answer (D): For one JavaBean to communicate to another JavaBean using an event, a communication path must first be established between the two Beans. The simplest way to establish such a communication path is to use a builder tool, such as the BeanBox. The BeanBox provides an Events selection from its Edit menu that brings up a dialog box for connecting two Beans. You select one Bean, then use its Events dialog box and the mouse to select the event action and make the connection to the second Bean. The BeanBox then generates a special adapter class to represent the communication that should occur between the two Beans when the event happens. You can also write this special adapter class yourself, rather than having the BeanBox generate it for you. See Using the BDK BeanBox | |
9. Use the Property sheet in the BeanBox tool to | ||
D is incorrect | Answer (C): The Properties window displays the current properties for the selected Bean. (Or, if no Bean is selected, it displays the BeanBox properties.) You can use the Properties window to edit a Bean's properties. The window displays the name of the property and its current value within an editable text field. Each property has an associated property editor. Clicking a property within the Property window activates the property's property editor. See A Look at Properties | |
10. The properties of a Bean | ||
D is correct! | Answer (D): JavaBean properties are analogous to Java instance variables. However, properties are declared private, and other components can access their values only through the public get and set methods. A Bean can define its own properties or it can inherit properties from its superclass, in the same manner that any Java class can define its own instance variables or inherit its variables from its superclass. See A Look at Properties | |
11. Some JavaBeans are not meant to be visible and are referred to as invisible Beans. Such invisible Beans | ||
D is incorrect | Answer (E): Not all JavaBeans have a GUI representation. If they don't have a GUI representation, then they are not visible in an application. However, they can still operate in the background of the application. In fact, invisible Beans are often used to fire events and save persistent state in an application, all of which occurs in a manner that is invisible to the application user. However, whether they are considered invisible or not, all JavaBeans are visible in builder tools. See A Look at JavaBeans | |
12. A property defined in a JavaBean typically | ||
D is correct! | Answer (D): A JavaBean property, by definition, is defined as a private instance rather than a public variable. Other components (Beans or tools) cannot directly access a property's value (because it is private). Instead, the Bean defines get and set methods for each property to make the property available to other components. JavaBeans are also serializable (they implement the java.io.Serializable interface), which means that their state-the current property settings or values-can be saved to a persistent store, such as a database, and then later retrieved. See A Look at Properties | |
13. When you write the code for a new JavaBean, you can test it in the BeanBox. What do you have to do to be able to test the Bean in the BeanBox? | ||
E is correct! | Answer (E): Every JavaBean, like any other Java class, must first be compiled before it can be run. Once the code for the Bean successfully compiles, you create a manifest file for the Bean. The manifest file includes the name of the Bean and the fact that it is a JavaBean. The manifest file becomes part of the executable JAR file that contains the compiled JavaBean. Beans are loaded into the BeanBox as executable JAR files. The JAR file can be placed in the BeanBox's initialization directory, which ensures that the BeanBox loads the JAR file and the Bean at start-up time. Or, you can manually load the JAR file using the BeanBox's LoadJar menu option. See Testing and Editing your Bean | |
14. When you write a get method for a JavaBean property, form the method name as follows: | ||
C is correct! | Answer (C): The names of the get and set methods follow a particular format so that the Bean introspection tools work. The method names begin with either get or set and are followed by the name of the property, with the initial letter of the property name capitalized. Thus, these methods have the following format: public get public void set (parameter) Get and Set Methods | |
15. A manifest file for a JavaBean contains the following information: | ||
D is correct! | Answer (D): The manifest file is an ASCII text file that can be created in any text editor. A manifest file for a JavaBean specifies the name of the JavaBean's class file and indicates that it is a JavaBean. The manifest file is a required part of the JAR file. See Test the Bean in the BeanBox | |
16. Choose the kinds of properties that a Bean may contain: | ||
C is incorrect | Answer (B): Just about all JavaBeans contain simple properties, because properties define how a Bean looks and acts. Bound and constrained properties are simple properties that have events tied to them. These properties are still instance variables, like simple properties, but the Bean also includes code to generate events and to allow other Beans to register as event listeners. If one Bean wants other Beans to be notified of changes to one of its properties, it makes that property a bound (or constrained) property and sets up an event to be generated when the property changes. Other Beans who are interested in changes to the property register their interest in such changes with the first Bean. When the property value does change, the first Bean fires an appropriate event which is received by the interested event listeners and handled appropriately. See Constrained Properties | |
17. A JavaBean that defines bound properties typically calls what methods so that other Beans can be notified of changes to the bound property? | ||
E is correct! | Answer (E): To implement a bound property, the Bean containing the property must instantiate the java.beans.PropertyChangeSupport class and then calls its two methods for managing event listeners: addPropertyChangeListener and removePropertyChangeListener. Beans interested in changes to the bound property can register their interest by adding themselves property change listeners. In addition, when the property value does change, the Bean containing the bound property must also fire an event to notify all interested property change listeners. The Bean does this by calling the PropertyChangeSupport class's firePropertyChange method from within each set method that affects a bound property. See Setting Up Bound Properties | |
18. Bound properties appear in the BeanBox with what kind of event in the Edit -> Events menu? | ||
B is correct! | Answer (B): The BeanBox recognizes when a Bean correctly defines a bound property and it includes a propertyChange interface item or event for that Bean. The propertyChange interface item appears in the BeanBox Edit -> Events menu for the selected Bean that defines a bound property. See Connecting the Beans in the BeanBox | |
19. Constrained properties are | ||
B is correct! | Answer (B): Constrained properties are identical to bound properties except for one additional feature: an outside object, either a listener Bean or the source Bean itself, can veto a proposed property change. The JavaBeans API event mechanism for handling constrained properties is similar to the one used for bound properties. See Constrained Properties | |
20. JavaBeans with constrained properties | ||
D is correct! | Answer (D): Constrained properties are identical to bound properties except for one additional feature: an outside object, either a listener Bean or the source Bean itself, can veto a proposed property change. The JavaBeans API event mechanism for handling constrained properties is similar to the one used for bound properties. See Setting Up Constrained Properties | |
*********************************************************************
Some important urls :
http://mathbits.com/MathBits/Java/arrays/Sorting.htm
http://www.tomjewett.com/dbdesign/dbdesign.php?page=multijoin.php
http://www.examcram2.com/articles/article.asp?p=30082&seqNum=1
http://www.janeg.ca/scjp/lang/arrays.html
http://struts.apache.org/1.x/userGuide/building_controller.html
http://java.sun.com/docs/books/tutorial/essential/exceptions/QandE/questions.html
1) What is the fastest database driver among typeI,II,III,IV drivers?
Ans: Type IV
2) Type 1 driver is also known as?
Ans: JDBC-ODBC Bridge Driver
3) Select avg(column) from table from the following table;
10, 20, NULL, 0
Ans:10
4) If there are 10 not null values and 5 null values in a column then the output of the following operation select count(*) from table name
Ans: 15
5) Question on the syntax of setting a property name in JSP
6) What is the best scope among the following for maintain the data efficiently
Options are : request, session, page request, application request
7) Inner join operation will give all the values in the first table even though there are no matching data between two tables. True or false?
Ans: false
8) Question on array declaration…….. given 5 declaration statements we have to choose from the five options
9) jdbc-odbc driver supports multithreading or not? Ans; no
10) Jsp supports multithreading or not . options are like this:
a) by default it will support multithreading
b) never supports
c) partially supports
d) none
Ans: JSP documents are ultimately compiled to servlets, which are multi-threaded by default and are assumed to be thread-safe. If the code in your JSP is not thread-safe, you can request the container uses a single threaded execution of the resulting servlet using the page directive <%@ page isThreadSafe="false" %>.
In this case the container may create multiple instances of the JSP servlet to handle concurrent requests or use synchronization to control access to a single instance. Both approaches are likely to reduce the performance of the page because of the overheads of instantiation and locking respectively, so this directive should be used with caution.
11) Given around 4 questions on debugging the java code……..
12) Constructors allow inheritance ? True or false
Ans: false
13) Jsp declarations syntax
14) Read carefully the following topics:
e) redirect and forward
f) IN command in SQL
g) Got one question regarding sub queries in SQL
h) Coding regarding type casting in java ( implicit type casting)
i) Javax.servlet and javax.servlet.pagecontext packages.
15) Approximate time for retreving
j) 1 value b) 100 values from data base is.
A) same
B) cannot say
C) ‘a’ requires less time than ‘b’
D) None
16) Given some coding using tag interfaces …….. Asked to debug it.
17) Given four class names and asked to pick appropriate one taking Sun java coding standards into consideration
18) nearly 5 questions from structs ……. two based on theory and three based on application.
19) Structs is based on which design pattern?
Jakarta Struts is a framework that facilitates building servlet applications based upon the Model-View-Controller (MVC) design paradigm.
20) JSP flow……….
21) a inner join gives combines both tables true or false
Ans:true
22) a inner join combines only the table in the left and not in the right true or false
Ans: false
23) truncate command deletes the table true or false
Ans:False
24) which command retrives from the database
Ans:select
25) which one is synchronized Hashmap or hashttable
Ans; hashtable
************************************************************************
26) Read servlets and structs applications……. Object scopes in jsp………. Javax. Servlet package……..
27) not in init config method
28) Output of the following:( Answer : 0 )
i=1
do{
i--;}
while(i>2)
sop(i);
Ans: Compile err. While shud be followed by “;“
29) public class name1{
public static void main(string [] args)
{
int c;
c=0;
sys("c");
}}
i c
ii 0
iii NULL
Answer : c will be displayed
30) not valid array declaration(check box)
i)string [][]a;
ii)string []i[];
iii)string 5[][];
iV)sting [0][]b;
Ans: iii & iv
31)
( Answer : Count(*) =15 and Count(row) = 10 )
if there are 10 value and 5 null values in a row select count(row) prints?
I. 10
II. 15
III. null
32) flow how a jsp works when it gets a request..
get the request, check for the servlet, if servlet present ....
33) what is given in class.forname in a jdbc file?
i)driver manager
ii)super class of driver manager
Ans: driver manager
34) which of the following are valid?( Answer: 1 . All others throw runtime exceptions .If | is used then runtime exception for 1st option also)
i=0, j=1
if ((i==0)||(j/i==1))
if ((i==0)&&(j/i==1))
if ((i!=0)|(j/i==1))
if ((i==1)&(j/i==1))
35) There will be three codes for jdbc connection which of the three is valid?
i)in the code.. finally{
con.close}
ii) con.close inside try
iii) con.close inside finally
ANS: finally
36) components of an MVC pattern? ( 1,2,3,4)
i)model
ii)view
iii)controller
iv)all the above
37) About implicit variable
i)cant be used in bean and servlet
ii)can be used in jsp
38) class parent{
}
class child extends parent{
}
which of the following can be used before child?
i)public, protected
ii) public
iii)private
iv) ...,public
Ans: public
39) some question about action mapping...
40) which is the least valid in jsp?
i) Request – second smallest
ii) page –smallest scope (like private variable)
iii) application – highest scope like global variable
iv)session –third smallest scope(each browser maintains)
Ans : scope in ascending order (smallest to largest) page,request,session,application
41) Ways to input a value...? Which of the following is true?
<set-property..>
<init-property..>
42) if(0.0==-0.0) does it returns true or false Ans : true
43) Are doget dopost service methods thread safe Ans : No
44) given an connection prog asked abt
1. password should be encrypted
2. driver name url wrong
3. incorrect sequence access,
4…………….
45) which way is correct below:
i)<% method; return method();%>
ii) <%= method; return method(); %>
iii) <%! method; return method(); %>
Ans: Method decl
<%! Return_type meth_name(args){
Method body
Return stt
}
%>
46) Can we write xml in jsp.
static pages
dynamic pages]
both static and dynamic
Ans: A JSP can now use either traditional JSP syntax or XML syntax within its source file. However, it is important to note that a JSP source file cannot intermix JSP syntax and XML syntax. No matter which type of syntax the JSP uses, it is still saved with a .jsp extension. The container will know the difference because the JSP document has a jsp:root element that cannot exist within traditional JSP syntax. The semantic model of a JSP document is no different than the semantic model of a JSP page. The JSP document generates a response stream of characters from template data and dynamic data. Text or XML fragments are common examples of template data and scripting elements, and standard or custom actions are common examples of dynamic elements. There are many reasons why you would want to use XML syntax in your JSPs. The specification describes the following reasons:
JSP documents can be passed directly to the container.
The XML view of the JSP document can be used to validate the JSP document against a description of the set of valid pages.
JSP documents can be manipulated via XML-aware tools.
An XML transformation, like XSLT, can be used to generate a JSP document from a textual representation.
Before the JSP 1.2 specification, there was no support for validating JSPs and little IDE support for manipulating JSPs. Therefore, the new abilities to validate the JSP document and manipulate it via XML-aware tools are great benefits of using XML syntax within JSPs.
JSP document
A JSP document is a JSP page written in XML syntax. It is a namespace-aware document that uses namespaces to identify the core syntax and additional syntaxes introduced to the page through tag libraries.
XML view
An XML view is the mapping between a JSP page, written in JSP syntax or XML syntax, and an XML document that describes it.
47) 28.types of drivers in jdbc.
Ans: 4 types
48) annonymous class
49) int arr[]=new int[2]
print arr[2] ArrayIndexOutOfBoundsException
50) jsp taglibs
51) Preparestatement
52) distint in sql
53) using forward in jsp
<jsp:forward>
Forwards a client request to an HTML file, JSP file, or servlet for processing.
JSP Syntax
<jsp:forward page={"relativeURL" | "<%= expression %>"} />
or
<jsp:forward page={"relativeURL" | "<%= expression %>"} >
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" />+
</jsp:forward>
or
<jsp:forward page={"relativeURL" | "<%= expression %>"} >
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" />+
</jsp:forward>
Examples
<jsp:forward page="/servlet/login" />
<jsp:forward page="/servlet/login">
<jsp:param name="username" value="jsmith" />
</jsp:forward>
<jsp:forward page="/servlet/login">
<jsp:param name="username" value="jsmith" />
</jsp:forward>
Description
The <jsp:forward> element forwards the request object containing the client request information from one JSP file to another file. The target file can be an HTML file, another JSP file, or a servlet, as long as it is in the same application context as the forwarding JSP file. The lines in the source JSP file after the <jsp:forward> element are not processed.
You can pass parameter names and values to the target file by using a <jsp:param> clause. An example of this would be passing the parameter name username (with name="username") and the value scott (with value="scott") to a servlet login file as part of the request. If you use <jsp:param>, the target file should be a dynamic file that can handle the parameters.
Be careful when using <jsp:forward> with unbuffered output. If you have used the <%@ page %> directive with buffer=none to specify that the output of your JSP file should not be buffered, and if the JSP file has any data in the out object, using <jsp:forward> will cause an IllegalStateException.
Attributes
page="{relativeURL | <%= expression %>}"
A String or an expression representing the relative URL of the file to which you are forwarding the request. The file can be another JSP file, a servlet, or any other dynamic file that can handle a request object.
The relative URL looks like a path-it cannot contain a protocol name, port number, or domain name. The URL can be absolute or relative to the current JSP file. If it is absolute (beginning with a /), the path is resolved by your Web or application server.
<jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" />+
Sends one or more name/value pairs as parameters to a dynamic file. The target file should be dynamic, that is, a JSP file, servlet, or other file that can process the data that is sent to it as parameters.
You can use more than one <jsp:param> clause if you need to send more than one parameter to the target file. The name attribute specifies the parameter name and takes a case-sensitive literal string as a value. The value attribute specifies the parameter value and takes either a case-sensitive literal string or an expression that is evaluated at request time.
54) redirect and forward in servlets
A Controller servlet may perform either a forward or a redirect operation at the end of processing a request. It is important to understand the difference between these two cases, in particular with respect to browser reloads of web pages.
Forward
a forward is performed internally by the servlet
the browser is completely unaware that it has taken place, so its original URL remains intact
any browser reload of the resulting page will simple repeat the original request, with the original URL
Redirect
a redirect is a two step process, where the web application instructs the browser to fetch a second URL, which differs from the original
a browser reload of the second URL will not repeat the original request, but will rather fetch the second URL
redirect is marginally slower than a forward, since it requires two browser requests, not one
objects placed in the original request scope are not available to the second request
In general, a forward should be used if the operation can be safely repeated upon a browser reload of the resulting web page; otherwise, redirect must be used. Typically, if the operation performs an edit on the datastore, then a redirect, not a forward, is required. This is simply to avoid the possibility of inadvertently duplicating an edit to the database.
More explicitly :
for SELECT operations, use a forward
for INSERT, UPDATE, or DELETE operations, use a redirect
In HTML, a <FORM> tag can either GET or POST its data. In this context, a GET corresponds to a SELECT-then-forward, and a POST corresponds to an edit-then-redirect.
It is strongly recommended that forms for the input of search criteria should use GET, while forms for editing database records should use POST.
The important methods of the Servlet API are :
ServletRequest.getRequestDispatcher(String)
RequestDispatcher.forward(request, response)
HttpServletResponse.sendRedirect(String)
getRequestDispatcher
RequestDispatcher getRequestDispatcher(String path)
Returns a RequestDispatcher object that acts as a wrapper for the resource located at the given path. A RequestDispatcher object can be used to forward a request to the resource or to include the resource in a response. The resource can be dynamic or static.
The pathname specified may be relative, although it cannot extend outside the current servlet context. If the path begins with a "/" it is interpreted as relative to the current context root. This method returns null if the servlet container cannot return a RequestDispatcher.
The difference between this method and ServletContext.getRequestDispatcher(java.lang.String) is that this method can take a relative path.
Parameters:
path - a String specifying the pathname to the resource. If it is relative, it must be relative against the current servlet.
Returns:
a RequestDispatcher object that acts as a wrapper for the resource at the specified path, or null if the servlet container cannot return a RequestDispatcher
See Also:
RequestDispatcher, ServletContext.getRequestDispatcher(java.lang.String)
forward
void forward(ServletRequest request,
ServletResponse response)
throws ServletException,
IOException
Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server. This method allows one servlet to do preliminary processing of a request and another resource to generate the response.
For a RequestDispatcher obtained via getRequestDispatcher(), the ServletRequest object has its path elements and parameters adjusted to match the path of the target resource.
forward should be called before the response has been committed to the client (before response body output has been flushed). If the response already has been committed, this method throws an IllegalStateException. Uncommitted output in the response buffer is automatically cleared before the forward.
The request and response parameters must be either the same objects as were passed to the calling servlet's service method or be subclasses of the ServletRequestWrapper or ServletResponseWrapper classes that wrap them.
Parameters:
request - a ServletRequest object that represents the request the client makes of the servlet
response - a ServletResponse object that represents the response the servlet returns to the client
Throws:
ServletException - if the target resource throws this exception
IOException - if the target resource throws this exception
IllegalStateException - if the response was already committed
55) servlet context
56) jsp in relation to servlet
57) if the package name is not known
58) difference between constructor and a method..?
a.no difference.
b.constructor cant return any value bt method can. Constructor can be called only once
bt method can be called any times.method can return values r void.
c.constructor cant return values bt mathods can.
59) use of Result set..
a. Moving the cursor
b. Itering the next row till last
c....
d...
60) For shopping cart which will you prefer?
a.application
b.session
c.page
d.request
answer: session
61) send redirect on request obj is sent to the browser...
a.true
b.false
62) Question frm localization in struts,
i) Entire specification is done.....
ii) Creates specific resource for each request
c. Either i or ii
d. Neither i nor ii
e. Only i
f. Only ii
63) which are all the valid methods in jsp??
a. jspInit()
_jspService()
_ jspDestroy()
b. _JSPInit()
_JSPService()
-JSPInit()
c. _JSPService()
_JspDestroy()
_JSPdodelete()
_JSPdoget()
_JSPdopost()
64) wat will happen when init() is called?
Answer :
Just like applets, servlets can define init() and destroy() methods. A servlet's init(ServletConfig) method is called by the server immediately after the server constructs the servlet's instance. Depending on the server and its configuration, this can be at any of these times:
When the server starts
When the servlet is first requested, just before the service() method is invoked
At the request of the server administrator
In any case, init() is guaranteed to be called before the servlet handles its first request.
The init() method is typically used to perform servlet initialization--creating or loading objects that are used by the servlet in the handling of its requests. Why not use a constructor instead? Well, in JDK 1.0 (for which servlets were originally written), constructors for dynamically loaded Java classes (such as servlets) couldn't accept arguments. So, in order to provide a new servlet any information about itself and its environment, a server had to call a servlet's init() method and pass along an object that implements the ServletConfig interface. Also, Java doesn't allow interfaces to declare constructors. This means that the javax.servlet.Servlet interface cannot declare a constructor that accepts a ServletConfig parameter. It has to declare another method, like init(). It's still possible, of course, for you to define constructors for your servlets, but in the constructor you don't have access to the ServletConfig object or the ability to throw a ServletException.
This ServletConfig object supplies a servlet with information about its initialization (init) parameters. These parameters are given to the servlet itself and are not associated with any single request. They can specify initial values, such as where a counter should begin counting, or default values, perhaps a template to use when not specified by the request. In the Java Web Server, init parameters for a servlet are usually set during the registration process.
P.S : about destroy()
The server calls a servlet's destroy() method when the servlet is about to be unloaded. In the destroy() method, a servlet should free any resources it has acquired that will not be garbage collected. The destroy() method also gives a servlet a chance to write out its unsaved cached information or any persistent information that should be read during the next call to init().
65) What is required for overriding...
a.overridden cls must not least public than the original class.
b...
66) difference between shallow copy and deep copy?
g. shallow copy does not share original object.Deep copy refers original obj.
h. shallow copy shares original object. Deep copy...
Java provides a mechanism for creating copies of objects called cloning. There are two ways to make a copy of an object called shallow copy and deep copy. Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy of the values in the original object. If any of the fields of the object are references to other objects, just the references are copied. Thus, if the object you are copying contains references to yet other objects, a shallow copy refers to the same subobjects. Deep copy is a complete duplicate copy of an object. If an object has references to other objects, complete new copies of those objects are also made. A deep copy generates a copy not only of the primitive values of the original object, but copies of all subobjects as well, all the way to the bottom. If you need a true, complete copy of the original object, then you will need to implement a full deep copy for the object. Java supports shallow and deep copy with the Cloneable interface to create copies of objects. To make a clone of a Java object, you declare that an object implements Cloneable, and then provide an override of the clone method of the standard Java Object base class. Implementing Cloneable tells the java compiler that your object is Cloneable. The cloning is actually done by the clone method.
67) a)config.getresourceasstream(/web.inf/asd.zip)
b)config.inputstream(“asd.zip”);
c)context.inputstream(“asd.zip”);
d) context.getresourceasstream(/web.inf/asd.zip)
68) Name of application resource file is set by the servlet init_param named.
application resources
application
resources
messages
69) Roles of Resultset
a. Used in while loop to iterate through the resultset.
b. Resultset object maintains a cursor pointing to its current row of data.
c. Initially cursor in first row, the next method moves the cursor to next row because it returns false when there are no more rows in the Resultset object
d. All the above.
Ans: a, b
70) Stuts populate a form in struts 1.1?
a. By overriding populate bean method of Action Mapping.
b. By overriding populate method of Action Form
c. By overriding process populate method of Request processor
d. All the above
71) Access modifiers to Method.. public, protected, private
72) <html><body>The value of <%=” “%>…what will print:- The value of
73) which is not true about Tag Library Descriptor(TLD)
74) <%@page isErrorpage=”true”%>
Seesion object is available to pages that have isErrorpage set to true
Exception object is available to pages that have isErrorpage set to true
Used to mark the current JSP page as error page
None of the above
75) When JDBC connection object would released
Ans: when close() method is called on the connection object
76) Some static data is available for entire application what to do
create a singleton object to share the data
create the application object to share the data (not sure if d is correct but b is surely correct)
use some caching mechanisms
all the above
77) Output of the code say true or false
Public class client{
Public static void main(String args[]){
String name=”java”;
System.out.println(name instance of Object)
}
}
Ans: true
78) What is the output
Public class A{
Public static void main(String args[])
For(int i=0;i<2;i++){
For(int j=2;j>=0;j--){
If(i==j) break;
System.ou.println(“i=”+i+”j=”+j);
}
}
a. i=2 j=0 b. i=0 j=0
i=2 j=1 i=0 j=1
i=2 j=2 i=0 j=2
c. i=0 j=2 d. i=1 j=0
i=0 j=1 i=1 j=1
i=1 j=2 i=1 j=2
Ans: c
79) <bean:write> what this tag will do :-- see the quiz
80) when we join two or more table in query which can be easily loaded
ascending from left to right
descending from left to right
ascending from right to left
descending from left to right
Ans: C (not sure)
81) To initialize the servlet, servlet container call on………: init