Programming Katta

Whether given no. is Armstrong or not

2012-05-10T02:02:00.000+05:30

**/*Write a program to find whether given no. is Armstrong or not.**

Example : Input - 153

**Output - 1^3 + 5^3 + 3^3 = 153, so it is Armstrong no. */**

class Armstrong{

public static void main(String args[]){

int num = Integer.parseInt(args[0]);

int n = num; //use to check at last time

int check=0,remainder;

while(num > 0){

remainder = num % 10;

check = check + (int)Math.pow(remainder,3);

num = num / 10;

}

if(check == n)

System.out.println(n+" is an Armstrong Number");

else

System.out.println(n+" is not a Armstrong Number");

}

Convert given no. of days into months and days

2012-05-08T02:13:00.000+05:30

**/* Write a program to convert given no. of days into months and days.**

(Assume that each month is of 30 days)

Example :

Input - 69

**Output - 69 days = 2 Month and 9 days */**

class DayMonthDemo{

public static void main(String args[]){

int num = Integer.parseInt(args[0]);

int days = num%30;

int month = num/30;

System.out.println(num+" days = "+month+" Month and "+days+" days");

}

Program to generate a Triangle

2012-05-08T02:12:00.000+05:30

/*Write a program to generate a Triangle.

eg:

  1
  2 2
  3 3 3
  4 4 4 4

and so on as per user given number */

class Triangle{

public static void main(String args[]){

int num = Integer.parseInt(args[0]);

for(int i=1;i<=num;i++){

for(int j=1;j<=i;j++){

System.out.print(" "+i+" ");

}

System.out.print("\n");

}

Program to Swap the values

2012-05-08T01:55:00.000+05:30

**/* Write a program to Swap the values */**

class Swap{

public static void main(String args[]){

int num1 = Integer.parseInt(args[0]);

int num2 = Integer.parseInt(args[1]);

System.out.println("\n***Before Swapping***");

System.out.println("Number 1 : "+num1);

System.out.println("Number 2 : "+num2);

//Swap logic

num1 = num1 + num2;

num2 = num1 - num2;

num1 = num1 - num2;

System.out.println("\n***After Swapping***");

System.out.println("Number 1 : "+num1);

System.out.println("Number 2 : "+num2);

}

Program to Display Multiplication Table

2012-05-08T01:53:00.000+05:30

**/* Program to Display Multiplication Table */**

class MultiplicationTable{

public static void main(String args[]){

int num = Integer.parseInt(args[0]);

System.out.println("*****MULTIPLICATION TABLE*****");

for(int i=1;i<=num;i++){

for(int j=1;j<=num;j++){

System.out.print(" "+i*j+" ");

}

System.out.print("\n");

}

Concatenate string using for Loop

2012-05-08T01:50:00.000+05:30

**/* Write a program to Concatenate string using for Loop Example: Input - 5 Output - 1 2 3 4 5 */**

class Join{

public static void main(String args[]){

int num = Integer.parseInt(args[0]);

String result = " ";

for(int i=1;i<=num;i++){

result = result + i + " ";

}

System.out.println(result);

}

JavaServer Pages

2012-05-06T13:55:00.001+05:30

Java Server Pages (JSP)

It is a Java technology that allows software developers to dynamically generate HTML, XML or other types of documents in response to a Web client request. The technology allows Java code and certain pre-defined actions to be embedded into static content.

The JSP syntax adds additional XML-like tags, called JSP actions, to be used to invoke built-in functionality. Additionally, the technology allows for the creation of JSP tag libraries that act as extensions to the standard HTML or XML tags. Tag libraries provide a platform independent way of extending the capabilities of a Web server. JSPs are compiled into Java Servlets by a JSP compiler. A JSP compiler may generate a servlet in Java code that is then compiled by the Java compiler, or it may generate byte code for the servlet directly.
"JavaServer Pages" is a technology released by Sun.

JSP and Servlets

Architecturally speaking, JSP can be viewed as a high-level abstraction of servlets that is implemented as an extension of the Servlet 2.1 API. Both servlets and JSPs were originally developed at Sun Microsystems, initially created by Anselm Baird-Smith and later elaborated on as a specification by Satish Dharmaraj. Starting with version 1.2 of the JSP specification, JavaServer Pages have been developed under the Java Community Process. JSR 53 defines both the JSP 1.2 and Servlet 2.3 specifications and JSR 152 defines the JSP 2.0 specification. As of May 2006 the JSP 2.1 specification has been released under JSR 245 as part of Java EE 5.

JSP Syntax:
A JavaServer Page may be broken down into the following pieces:

* static data such as HTML,
* JSP directives such as the include directive,
* JSP scripting elements and variables,
* JSP actions,
* custom tags

Static data

Static data is written out to the HTTP response exactly as it appears in the input file. Thus a normal HTML page with no embedded java or actions would be valid JSP input. In that case, the same data would be sent in the response each and every time by the web server to the browser.

JSP directives
JSP directives control how the JSP compiler generates the servlet. The following directives are available:

* include – The include directive informs the JSP compiler to include a complete file into the current file. It is as if the contents of the included file were pasted directly into the original file. This functionality is similar to the one provided by the C preprocessor. Included files generally have the extension "jspf" (for JSP Fragment):

<%@ include file="somefile.jspf" %>

* page – There are several options to the page directive.

import results in a Java import statement being inserted into the resulting file
contentType specifies the content that is generated. This should be used if HTML is not used or if the character set is not the default character set.
errorPage indicates the page that will be shown if an exception occurs while processing the HTTP request.
isErrorPage if set to true, it indicates that this is the error page.
isThreadSafe indicates if the resulting servlet is thread safe.

<%@ page import="java.util.*" %> //example import
<%@ page contentType="text/html" %> //example contentType
<%@ page isErrorPage=false %> //example for non error page
<%@ page isThreadSafe=true %> //example for a thread safe JSP

Note: Only the "import" page directive can be used multiple times in the same JSP.

* taglib – The taglib directive indicates that a JSP tag library is to be used. The directive requires that a prefix be specified (much like a namespace in C++) and the URI for the tag library description.

<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>

JSP scripting elements and objects

JSP Implicit Objects

The following JSP implicit objects are exposed by the JSP container and can be referenced by the programmer:

* out – The JSPWriter used to write the data to the response stream.
* page – The servlet itself.
* pageContext – A PageContext instance that contains data associated with the whole page. A given HTML page may be passed among multiple JSPs.
* request – The HTTP request object.
* response – The HTTP response object.
* session – The HTTP session object that can be used to track information about a user from one request to another.
* config – Provides servlet configuration data.
* application – Data shared by all JSPs and servlets in the application.
* exception – Exceptions not caught by application code.

Scripting elements

There are three basic kinds of scripting elements that allow java code to be inserted directly into the servlet.

* A declaration tag places a variable definition inside the body of the java servlet class. Static data members may be defined as well.

<%! int serverInstanceVariable = 1; %>

* A scriptlet tag places the contained statements inside the _jspService() method of the java servlet class.

<% int localStackBasedVariable = 1;
out.println(localStackBasedVariable); %>

* An expression tag places an expression to be evaluated inside the java servlet class. Expressions should not be terminated with a semi-colon .

<%= "expanded inline data " + 1 %>

JSP actions

JSP actions are XML tags that invoke built-in web server functionality. The following actions are provided:

jsp:include Similar to a subroutine, the Java servlet temporarily hands the request and response off to the specified JavaServer Page. Control will then return to the current JSP, once the other JSP has finished. Using this, JSP code will be shared between multiple other JSPs, rather than duplicated.
jsp:param Can be used inside a jsp:include, jsp:forward or jsp:params block. Specifies a parameter that will be added to the request's current parameters.
jsp:forward Used to hand off the request and response to another JSP or servlet. Control will never return to the current JSP.
jsp:plugin Older versions of Netscape Navigator and Internet Explorer used different tags to embed an applet. This action generates the browser specific tag needed to include an applet.
jsp:fallback The content to show if the browser does not support applets.
jsp:getProperty Gets a property from the specified JavaBean.
jsp:setProperty Sets a property in the specified JavaBean.
jsp:useBean Creates or re-uses a JavaBean available to the JSP page.

Examples of tags

jsp:include

<html>
<head></head>
<body>
<jsp:include page="mycommon.jsp" >
<jsp:param name="extraparam" value="myvalue" />
</jsp:include>
name:<%=request.getParameter("extraparam")%>
</body></html>

jsp:forward

<jsp:forward page="subpage.jsp" >
<jsp:param name="forwardedFrom" value="this.jsp" />
</jsp:forward>

In this forwarding example, the request is forwarded to "subpage.jsp". The request handling does not return to this page.

jsp:plugin

<jsp:plugin type=applet height="100%" width="100%"
archive="myjarfile.jar,myotherjar.jar"
codebase="/applets"
code="com.foo.MyApplet" >
<jsp:params>
<jsp:param name="enableDebug" value="true" />
</jsp:params>
<jsp:fallback>
Your browser does not support applets.
</jsp:fallback>
</jsp:plugin>

The plugin example illustrates a <html> uniform way of embedding applets in a web page. Before the advent of the <OBJECT> tag, there was no common way of embedding applets. This tag is poorly designed and hopefully future specs will allow for dynamic attributes (height="${param.height}", code="${chart}", etc) and dynamic parameters. Currently, the jsp:plugin tag does not allow for dynamically called applets. For example, if you have a charting applet that requires the data points to be passed in as parameters, you can't use jsp:params unless the number of data points are constant. You can't, for example, loop through a ResultSet to create the jsp:param tags. You have to hand code each jsp:param tag. Each of those jsp:param tags however can have a dynamic name and a dynamic value.

jsp:useBean

<jsp:useBean id="myBean" class="com.foo.MyBean" scope="request" />
<jsp:getProperty name="myBean" property="lastChanged" />
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />

The scope attribute can be request, page, session or application. It has the following meanings:

* request — the attribute is available for the lifetime of the request. Once the request has been processed by all of the JSPs, the attribute will be de-referenced.
* page — the attribute is available for the current page only.
* session — the attribute is available for the lifetime of the user's session.
* application — the attribute is available to every instance and is never de-referenced. Same as a global variable.

The example above will use a Bean Manager to create an instance of the class com.foo.MyBean and store the instance in the attribute named "myBean". The attribute will be available for the life-time of the request. It can be shared among all of the JSPs that were included or forwarded-to from the main JSP that first received the request.

JSP tag libraries

In addition to the pre-defined JSP actions, developers may add their own custom actions using the JSP Tag Extension API. Developers write a Java class that implements one of the Tag interfaces and provide a tag library XML description file that specifies the tags and the java classes that implement the tags.

Consider the following JSP.

<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>
...
<myprefix:myaction> <%-- the start tag %>
...
</myprefix:myaction> <%-- the end tag %>
...

The JSP compiler will load the mytaglib.tld XML file and see that the tag 'myaction' is implemented by the java class 'MyActionTag'. The first time the tag is used in the file, it will create an instance of 'MyActionTag'. Then (and each additional time that the tag is used), it will invoke the method doStartTag() when it encounters the starting tag. It looks at the result of the start tag, and determines how to process the body of the tag. The body is the text between the start tag and the end tag. The doStartTag() method may return one of the following:

* SKIP_BODY - the body between the tag is not processed
* EVAL_BODY_INCLUDE - evaluate the body of the tag
* EVAL_BODY_TAG - evaluate the body of the tag and push the result onto stream (stored in the body content property of the tag).

Note: If tag extends the BodyTagSupport class, the method doAfterBody() will be called when the body has been processed just prior to calling the doEndTag(). This method is used to implement looping constructs.

When it encounters the end tag, it invokes the doEndTag() method. The method may return one of two values:

* EVAL_PAGE - this indicates that the rest of the JSP file should be processed.
* SKIP_PAGE - this indicates that no further processing should be done. Control leaves the JSP page. This is what is used for the forwarding action.

The myaction tag above would have an implementation class that looked like something below:

public class MyActionTag extends TagSupport {
//Releases all instance variables.
public void release() {...}

public MyActionTag() { ... }

//called for the start tag
public int doStartTag() { ... }

//called at the end tag
public int doEndTag(){ ... }
}

Add Body Tag description.

Internationalization

Internationalization in JSP is accomplished the same way as in a normal Java application, that is by using resource bundles.

JSP 2.0

The new version of the JSP specification includes new features meant to improve programmer productivity. Namely:

* An Expression Language (EL) which allows developers to create Velocity-style templates (among other things).
* A faster/easier way to create new tags.

Hello, ${param.visitor} <%-- same as: Hello, <%=request.getParameter("visitor")%> --%>

Model-view-controller paradigm

Sun recommends that the Model-view-controller pattern be used with the JSP files in order to split the presentation from request processing and data storage. Either regular servlets or separate JSP files are used to process the request. After the request processing has finished, control is passed to a JSP used only for creating the output. There are several platforms based on Model-view-controller pattern for web tiers (such as Apache Struts and Spring framework).

Example

Regardless of whether the JSP compiler generates Java source code for a servlet or emits the byte code directly, it is helpful to understand how the JSP compiler transforms the page into a Java servlet. For an example, consider the following input JSP and its resulting generated Java Servlet.

Input JSP

<%@ page errorPage="myerror.jsp" %>
<%@ page import="com.foo.bar" %>

<html>
<head>
<%! int serverInstanceVariable = 1;%>
...
<% int localStackBasedVariable = 1; %>
<table>
<tr><td><%= "expanded inline data " + 1 %></td></tr>
...

Resulting servlet

package jsp_servlet;
import java.util.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;

import com.foo.bar; //imported as a result of <%@ page import="com.foo.bar" %>
import ...

class _myservlet implements javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
//inserted as a
//result of <%! int serverInstanceVariable = 1;%>
int serverInstanceVariable = 1;
...

public void _jspService( javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response )
throws javax.servlet.ServletException,
java.io.IOException
{
javax.servlet.ServletConfig config = ...;//get the servlet config
Object page = this;
PageContext pageContext = ...;//get the page context for this request
javax.servlet.jsp.JspWriter out = pageContext.getOut();
HttpSession session = request.getSession( true );
try {
out.print( "<html>\r\n" );
out.print( "<head>\r\n" );
...
//from <% int localStackBasedVariable = 1; %>
int localStackBasedVariable = 1;
...
out.print( "<table>\r\n" );
out.print( " <tr><td>" );
//note, toStringOrBlank() converts the expression into a string or if
// the expression is null, it uses the empty string.
//from <%= "expanded inline data " + 1 %>
out.print( toStringOrBlank( "expanded inline data " + 1 ) );
out.print( " </td></tr>\r\n" );
...
} catch ( Exception _exception ) {
//clean up and redirect to error page in <%@ page errorPage="myerror.jsp" %>
}
}
}

Java Servlet

2012-05-06T13:54:00.001+05:30

Java Servlet

The Servlet API, contained in the Java package hierarchy javax.servlet, defines the expected interactions of a web container and a servlet. A web container is essentially the component of a web server that interacts with the servlets. The web container is responsible for managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access rights.

A Servlet is an object that receives requests (ServletRequest) and generates a response (ServletResponse) based on the request. The API package javax.servlet.http defines HTTP subclasses of the generic servlet (HttpServlet) request (HttpServletRequest) and response (HttpServletResponse) as well as an (HttpSession) that tracks multiple requests and responses between the web server and a client. Servlets may be packaged in a WAR file as a Web application.

Moreover, servlets can be generated automatically by JavaServer Pages (JSP), or alternately by template engines such as WebMacro. Often servlets are used in conjunction with JSPs in a pattern called "Model 2", which is a flavor of the model-view-controller pattern.

History
The original servlet specification was created by Sun Microsystems (version 1.0 was finalized in June 1997). Starting with version 2.3, the servlet specification was developed under the Java Community Process. JSR 53 defined both the Servlet 2.3 and JavaServer Page 1.2 specifications. JSR 154 specifies the Servlet 2.4 and 2.5 specifications. As of May 10, 2006, the current version of the servlet specification is 2.5.

In his blog on java.net, Sun veteran and GlassFish lead Jim Driscoll details the history of servlet technology. James Gosling first thought of servlets in the early days of Java, but the concept did not become a product until Sun shipped the Java Web Server product. This was before what is now the Java Platform, Enterprise Edition was made into a specification.

Web containers
A Web container is a computer program that runs Web applications. Web containers are also sometimes called Web engines. Like the other Java APIs, different vendors provide their own implementation. Below is a list of some of the free web containers. (Note that 'free' means that commercial use is free. Some of the commercial containers, e.g. Resin and Orion, make ideal development containers and are also free to use in a server environment for non-profit organizations).

Non-commercial web containers

* Java System Application Server is developed by Sun.
* Apache Tomcat (formerly Jakarta Tomcat) is an open source web container available free of charge under the Apache Software License. It is used in the official reference implementation and has a reputation for being stable.
* Jetty
* Jaminid contains a higher abstraction than servlets.
* Enhydra
* jo!
* Winstone supports specification v2.4, has a focus on minimal configuration and the ability to strip the container down to only what you need.
* tjws spec 2.4, small footprint, modular design

Flow control and Exception in java

2012-05-03T21:49:00.000+05:30

Flow Control and Exceptions

Unreachable statements produce a compile-time error.

while (false) { x = 3; } // won't compile

for (;false;) { x =3; } // won't compile

if (false) {x = 3; } // will compile, to provide the ability to conditionally compile the code.

· Local variables already declared in an enclosing block, therefore visible in a nested block cannot be re-declared inside the nested block.

· A local variable in a block may be re-declared in another local block, if the blocks are disjoint.

· Method parameters cannot be re-declared.

1. Loop constructs

· 3 constructs - for, while, do

· All loops are controlled by a boolean expression.

· In while and for, the test occurs at the top, so if the test fails at the first time, body of the loop might not be executed at all.

· In do, test occurs at the bottom, so the body is executed at least once.

· In for, we can declare multiple variables in the first part of the loop separated by commas, also we can have multiple statements in the third part separated by commas.

· In the first section of for statement, we can have a list of declaration statements or a list of expression statements, but not both. We cannot mix them.

· All expressions in the third section of for statement will always execute, even if the first expression makes the loop condition false. There is no short -circuit here.

2. Selection Statements

· if takes a boolean arguments. Parenthesis required. else part is optional. else if structure provides multiple selective branching.

· switch takes an argument of byte, short, char or int.(assignment compatible to int)

· case value should be a constant expression that can be evaluated at compile time.

· Compiler checks each case value against the range of the switch expression's data type. The following code won't compile.

byte b;

switch (b) {

case 200: // 200 not in range of byte

default:

}

· We need to place a break statement in each case block to prevent the execution to fall through other case blocks. But this is not a part of switch statement and not enforced by the compiler.

· We can have multiple case statements execute the same code. Just list them one by one.

· default case can be placed anywhere. It'll be executed only if none of the case values match.

· switch can be nested. Nested case labels are independent, don't clash with outer case labels.

· Empty switch construct is a valid construct. But any statement within the switch block should come under a case label or the default case label.

3. Branching statements

· break statement can be used with any kind of loop or a switch statement or just a labeled block.

· continue statement can be used with only a loop (any kind of loop).

· Loops can have labels. We can use break and continue statements to branch out of multiple levels of nested loops using labels.

· Names of the labels follow the same rules as the name of the variables.(Identifiers)

· Labels can have the same name, as long as they don't enclose one another.

· There is no restriction against using the same identifier as a label and as the name of a package, class, interface, method, field, parameter, or local variable.

4. Exception Handling

· An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions.

· There are 3 main advantages for exceptions:

1. Separates error handling code from "regular" code

2. Propagating errors up the call stack (without tedious programming)

3. Grouping error types and error differentiation

· An exception causes a jump to the end of try block. If the exception occurred in a method called from a try block, the called method is abandoned.

· If there's a catch block for the occurred exception or a parent class of the exception, the exception is now considered handled.

· At least one 'catch' block or one 'finally' block must accompany a 'try' statement. If all 3 blocks are present, the order is important. (try/catch/finally)

· finally and catch can come only with try, they cannot appear on their own.

· Regardless of whether or not an exception occurred or whether or not it was handled, if there is a finally block, it'll be executed always. (Even if there is a return statement in try block).

· System.exit() and error conditions are the only exceptions where finally block is not executed.

· If there was no exception or the exception was handled, execution continues at the statement after the try/catch/finally blocks.

· If the exception is not handled, the process repeats looking for next enclosing try block up the call hierarchy. If this search reaches the top level of the hierarchy (the point at which the thread was created), then the thread is killed and message stack trace is dumped to System.err.

· Use throw new xxxException() to throw an exception. If the thrown object is null, a NullPointerException will be thrown at the handler.

· If an exception handler re-throws an exception (throw in a catch block), same rules apply. Either you need to have a try/catch within the catch or specify the entire method as throwing the exception that's being re-thrown in the catch block. Catch blocks at the same level will not handle the exceptions thrown in a catch block - it needs its own handlers.

· The method fillInStackTrace() in Throwable class throws a Throwable object. It will be useful when re-throwing an exception or error.

· The Java language requires that methods either catch or specify all checked exceptions that can be thrown within the scope of that method.

· All objects of type java.lang.Exception are checked exceptions. (Except the classes under java.lang.RuntimeException) If any method that contains lines of code that might throw checked exceptions, compiler checks whether you've handled the exceptions or you've declared the methods as throwing the exceptions. Hence the name checked exceptions.

· If there's no code in try block that may throw exceptions specified in the catch blocks, compiler will produce an error. (This is not the case for super-class Exception)

· Java.lang.RuntimeException and java.lang.Error need not be handled or declared.

· An overriding method may not throw a checked exception unless the overridden method also throws that exception or a super-class of that exception. In other words, an overriding method may not throw checked exceptions that are not thrown by the overridden method. If we allow the overriding methods in sub-classes to throw more general exceptions than the overridden method in the parent class, then the compiler has no way of checking the exceptions the sub-class might throw. (If we declared a parent class variable and at runtime it refers to sub-class object) This violates the concept of checked exceptions and the sub-classes would be able to by-pass the enforced checks done by the compiler for checked exceptions. This should not be allowed.

Here is the exception hierarchy.

Object

Throwable
| |

| |

| Error

Exception-->ClassNotFoundException, ClassNotSupportedException, IllegalAccessException, InstantiationException, IterruptedException, NoSuchMethodException,RuntimeException, AWTException, IOException

RuntimeException-->EmptyStackException, NoSuchElementException, ArithmeticException, ArrayStoreException, ClassCastException, IllegalArgumentException, IllegalMonitorStateException,

IndexOutOfBoundsException, NegativeArraySizeException, NullPointerException, SecurityException.

IllegalArgumentException-->IllegalThreadStateException, NumberFormatException

IndexOutOfBoundsException-->ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException

IOException-->EOFException, FileNotFoundException, InterruptedIOException, UTFDataFormatException, MalformedURLException, ProtocolException, SockException, UnknownHostException, UnknownServiceException.

Hardware Basics

2012-04-30T20:05:00.000+05:30

1. Which of the following components found on a motherboard is the most visible?

A. Keyboard connector
B. BIOS chip
C. Expansion slots
D. Power connectors

2. Which of the following BEST describes the difference between the "baby" AT and ATX motherboards?

A. The "baby" AT motherboard allows for the installation of more than two full- length expansion cards whereas the ATX motherboard allows for only one or two.
B. The processor, memory, and expansion slots are all in line with each other on a "baby" AT motherboard, whereas the ATX motherboard has the processor and memory slots at right angles to the expansion cards.
C. The ATX motherboard allows for the installation of more than two full-lengthexpansion cards, whereas the "baby" AT allows for only one or two.
D. The "baby" AT motherboard has a 20-pin power connector while the ATX has a12-pin power connector.
(Select two options)

3. Which of the following memory module form factors are commonly used for laptops?

A. Dual Inline Memory Modules (DIMMs)
B. Small Outline DIMMs (SODIMMs)
C. Single Inline Memory Modules (SIMMs)
D. Rambus Inline Memory Modules (RIMMs)

4. Which of the following are SCSI types that allow for 16 devices, including theadapter, to be connected on a single shared cable?

A. Ultra Wide SCSI

B. Fast SCSI

C. Ultra SCSI

D. Fast Wide SCSI

E. Ultra 2 SCSI

(Select two options)

5. What do you call the part of a CD-ROM drive's head assembly that moves acrossthe disk to read it?

A. Read/Write Actuator.

B. The Mechanical Frame.

C. The Head Actuator.

D. The Disk Spindle

6. What is clock speed of the AGPx8 expansion slot?

A. 66 MHz

B. 133 MHz

C. 266 MHz

D. 533 MHz

7. Which of the following components on the motherboard usually house the IDEconnectors?

A. PCI bus

B. North Bridge.

C. ISA bus.

D. South Bridge.

8 When a technician upgrades firmware on a motherboard he has to ______.

A. flash the BIOS

B. replace the CMOS chip

C. replace the BIOS

D. reset the CMOS

9 In which of the following is the output from a power supply rated?

A. Voltage.

B. Watts.

C. Hertz.

D. Ohms

10. When connecting the power cable of an AT power supply to the mother board,which two wires on the power connectors (P8/P9) should be together?

A. The green wires.

B. The white wires.

C. The black wires.

D. The brown wires.

Modifiers in java

2012-04-27T10:23:00.001+05:30

1. Modifiers are Java keywords that provide information to compiler about the nature of the code, data and classes.

2. Access modifiers - public, protected, private

· Only applied to class level variables. Method variables are visible only inside the method.

· Can be applied to class itself (only to inner classes declared at class level, no such thing as protected or private top level class)

· Can be applied to methods and constructors.

· If a class is accessible, it doesn't mean, the members are also accessible. Members' accessibility determines what is accessible and what is not. But if the class is not accessible, the members are not accessible, even though they are declared public.

· If no access modifier is specified, then the accessibility is default package visibility. All classes in the same package can access the feature. It's called as friendly access. But friendly is not a Java keyword. Same directory is same package in Java's consideration.

· 'private' means only the class can access it, not even sub-classes. So, it'll cause access denial to a sub-class's own variable/method.

· These modifiers dictate, which classes can access the features. An instance of a class can access the private features of another instance of the same class.

· 'protected' means all classes in the same package (like default) and sub-classes in any package can access the features. But a subclass in another package can access the protected members in the super-class via only the references of subclass or its subclasses. A subclass in the same package doesn't have this restriction. This ensures that classes from other packages are accessing only the members that are part of their inheritance hierarchy.

· Methods cannot be overridden to be more private. Only the direction shown in following figure is permitted from parent classes to sub-classes.

private à friendly (default) à protected à public

Parent classes Sub-classes

3. final

· final features cannot be changed.

· The final modifier applies to classes, methods, and variables.

· final classes cannot be sub-classed.

· You can declare a variable in any scope to be final.

· You may, if necessary, defer initialization of a final local variable. Simply declare the local variable and initialize it later (for final instance variables. You must initialize them at the time of declaration or in constructor).

· final variables cannot be changed (result in a compile-time error if you do so )

· final methods cannot be overridden.

· Method arguments marked final are read-only. Compiler error, if trying to assign values to final arguments inside the method.

· Member variables marked final are not initialized by default. They have to be explicitly assigned a value at declaration or in an initializer block. Static finals must be assigned to a value in a static initializer block, instance finals must be assigned a value in an instance initializer or in every constructor. Otherwise the compiler will complain.

· A blank final is a final variable whose declaration lacks an initializer.

· Final variables that are not assigned a value at the declaration and method arguments that are marked final are called blank final variables. They can be assigned a value at most once.

· Local variables can be declared final as well.

· If a final variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object.

· This applies also to arrays, because arrays are objects; if a final variable holds a reference to an array, then the components of the array may be changed by operations on the array, but the variable will always refer to the same array

· A blank final instance variable must be definitely assigned at the end of every constructor of the class in which it is declared; otherwise a compile-time error occurs.

· A class can be declared final if its definition is complete and no subclasses are desired or required.

· A compile-time error occurs if the name of a final class appears in the extends clause of another class declaration; this implies that a final class cannot have any subclasses.

· A compile-time error occurs if a class is declared both final and abstract, because the implementation of such a class could never be completed.

· Because a final class never has any subclasses, the methods of a final class are never overridden

4. abstract

· Can be applied to classes and methods.

· For deferring implementation to sub-classes.

· Opposite of final, final can't be sub-classed, abstract must be sub-classed.

· A class should be declared abstract,

1. if it has any abstract methods.

2. if it doesn't provide implementation to any of the abstract methods it inherited

3. if it doesn't provide implementation to any of the methods in an interface that it says implementing.

· Just terminate the abstract method signature with a ';', curly braces will give a compiler error.

· A class can be abstract even if it doesn't have any abstract methods.

5. static

· Can be applied to nested classes, methods, variables, free floating code-block (static initializer)

· Static variables are initialized at class load time. A class has only one copy of these variables.

· Static methods can access only static variables. (They have no this)

· Access by class name is a recommended way to access static methods/variables.

· Static initializer code is run at class load time.

· Static methods may not be overridden to be non-static.

· Non-static methods may not be overridden to be static.

· Abstract methods may not be static.

· Local variables cannot be declared as static.

· Actually, static methods are not participating in the usual overriding mechanism of invoking the methods based on the class of the object at runtime. Static method binding is done at compile time, so the method to be invoked is determined by the type of reference variable rather than the actual type of the object it holds at runtime.

Let's say a sub-class has a static method which 'overrides' a static method in a parent class. If you have a reference variable of parent class type and you assign a child class object to that variable and invoke the static method, the method invoked will be the parent class method, not the child class method. The following code explains this.

public class StaticOverridingTest {

public static void main(String s[]) {

Child c = new Child();

c.doStuff(); // This will invoke Child.doStuff()

Parent p = new Parent();

p.doStuff(); // This will invoke Parent.doStuff()

p = c;

p.doStuff(); // This will invoke Parent.doStuff(), rather than Child.doStuff()

}

class Parent {

static int x = 100;

public static void doStuff() {

System.out.println("In Parent..doStuff");

System.out.println(x);

}

class Child extends Parent {

static int x = 200;

public static void doStuff() {

System.out.println("In Child..doStuff");

System.out.println(x);

}

6. native

· Can be applied to methods only. (static methods also)

· Written in a non-Java language, compiled for a single machine target type.

· Java classes use lot of native methods for performance and for accessing hardware Java is not aware of.

· Native method signature should be terminated by a ';', curly braces will provide a compiler error.

· native doesn't affect access qualifiers. Native methods can be private.

· Can pass/return Java objects from native methods.

· System.loadLibrary is used in static initializer code to load native libraries. If the library is not loaded when the static method is called, an UnsatisfiedLinkError is thrown.

7. transient

· Can be applied to class level variables only.(Local variables cannot be declared transient)

· Transient variables may not be final or static.(But compiler allows the declaration, since it doesn't do any harm. Variables marked transient are never serialized. Static variables are not serialized anyway.)

· Not stored as part of object's persistent state, i.e. not written out during serialization.

· Can be used for security.

8. synchronized

· Can be applied to methods or parts of methods only.

· Used to control access to critical code in multi-threaded programs.

9. volatile

· Can be applied to variables only.

· Can be applied to static variables.

· Cannot be applied to final variables.

· Declaring a variable volatile indicates that it might be modified asynchronously, so that all threads will get the correct value of the variable.

· Used in multi-processor environments.

Modifier	Class	Inner classes (Except local and anonymous classes)	Variable	Method		Constructor	Free floating Code block
public	Y	Y	Y	Y	Y		N
protected	N	Y	Y	Y	Y		N
(friendly) No access modifier	Y	Y (OK for all)	Y	Y	Y		N
private	N	Y	Y	Y	Y		N
final	Y	Y (Except anonymous classes)	Y	Y	N		N
abstract	Y	Y (Except anonymous classes)	N	Y	N		N
static	N	Y	Y	Y	N		Y (static initializer)
native	N	N	N	Y	N		N
transient	N	N	Y	N	N		N
synchronized	N	N	N	Y	N		Y (part of method, also need to specify an object on which a lock should be obtained)
volatile	N	N	Y	N	N		N

Check the below links for

JAVA Fundamentals

Operators and assignments in java

Some basic java programs:

Sum of integers between 100 to 200 divisible by 7
Fibonacci series
Reverse a given number
Factorial of an given number
Find sum and product of a given digit
Greet message using Switch case
Generate random number between 1 to 100
Read float and print o/p as shown
Minimum of two numbers
Max of two numbers

Reactions before the final engineering viva

2012-04-26T12:46:00.003+05:30

Final day of Engineering VIVA

Sayali desai before her Final viva

Engrossed in studies

HCI--We hate this subject

Operators and assignments in java

2012-04-26T11:06:00.006+05:30

The Java programming language has included five simple arithmetic operators like + (addition), - (subtraction), * (multiplication), / (division)

Check JAVA Fundamentals before this.

1. Unary operators

1.1 Increment and Decrement operators ++ --

We have postfix and prefix notation. In post-fix notation value of the variable/expression is modified after the value is taken for the execution of statement. In prefix notation, value of the variable/expression is modified before the value is taken for the execution of statement.

x = 5; y = 0; y = x++; Result will be x = 6, y = 5

x = 5; y = 0; y = ++x; Result will be x = 6, y = 6

Implicit narrowing conversion is done, when applied to byte, short or char.

1.2 Unary minus and unary plus + -

+ has no effect than to stress positivity.

- negates an expression's value. (2's complement for integral expressions)

1.3 Negation !

Inverts the value of a boolean expression.

1.4 Complement ~

Inverts the bit pattern of an integral expression. (1's complement - 0s to 1s and 1s to 0s)

Cannot be applied to non-integral types.

1.5 Cast ()

Persuades compiler to allow certain assignments. Extensive checking is done at compile and runtime to ensure type-safety.

Check JAVA Fundamentals before this.

2. Arithmetic operators - *, /, %, +, -

· Can be applied to all numeric types.

· Can be applied to only the numeric types, except '+' - it can be applied to Strings as well.

· All arithmetic operations are done at least with 'int'. (If types are smaller, promotion happens. Result will be of a type at least as wide as the wide type of operands)

· Accuracy is lost silently when arithmetic overflow/error occurs. Result is a nonsense value.

· Integer division by zero throws an exception.

· % - reduce the magnitude of LHS by the magnitude of RHS. (continuous subtraction)

· % - sign of the result entirely determined by sign of LHS

· 5 % 0 throws an ArithmeticException.

· Floating point calculations can produce NaN (square root of a negative no) or Infinity ( division by zero). Float and Double wrapper classes have named constants for NaN and infinities.

· NaN's are non-ordinal for comparisons. x == Float.NaN won't work. Use Float.IsNaN(x) But equals method on wrapper objects(Double or Float) with NaN values compares Nan's correctly.

· Infinities are ordinal. X == Double.POSITIVE_INFINITY will give expected result.

· + also performs String concatenation (when any operand in an expression is a String). The language itself overloads this operator. toString method of non-String object operands are called to perform concatenation. In case of primitives, a wrapper object is created with the primitive value and toString method of that object is called. ("Vel" + 3 will work.)

· Be aware of associativity when multiple operands are involved.

System.out.println( 1 + 2 + "3" ); // Prints 33

System.out.println( "1" + 2 + 3 ); // Prints 123

Check JAVA Fundamentals before this.

3. Shift operators - <<, >>, >>>

· << performs a signed left shift. 0 bits are brought in from the right. Sign bit (MSB) is preserved. Value becomes old value * 2 ^ x where x is no of bits shifted.

· >> performs a signed right shift. Sign bit is brought in from the left. (0 if positive, 1 if negative. Value becomes old value / 2 ^ x where x is no of bits shifted. Also called arithmetic right shift.

· >>> performs an unsigned logical right shift. 0 bits are brought in from the left. This operator exists since Java doesn't provide an unsigned data type (except char). >>> changes the sign of a negative number to be positive. So don't use it with negative numbers, if you want to preserve the sign. Also don't use it with types smaller than int. (Since types smaller than int are promoted to an int before any shift operation and the result is cast down again, so the end result is unpredictable.)

· Shift operators can be applied to only integral types.

· -1 >> 1 is -1, not 0. This differs from simple division by 2. We can think of it as shift operation rounding down.

· 1 << 31 will become the minimum value that an int can represent. (Value becomes negative, after this operation, if you do a signed right shift sign bit is brought in from the left and the value remains negative.)

· Negative numbers are represented in two's complement notation. (Take one's complement and add 1 to get two's complement)

· Shift operators never shift more than the number of bits the type of result can have. ( i.e. int 32, long 64) RHS operand is reduced to RHS % x where x is no of bits in type of result.

int x;

x = x >> 33; // Here actually what happens is x >> 1

Check JAVA Fundamentals before this.

4. Comparison operators - all return boolean type.

4.1 Ordinal comparisons - <, <=, > , >=

· Only operate on numeric types. Test the relative value of the numeric operands.

· Arithmetic promotions apply. char can be compared to float.

4.2 Object type comparison - instanceof

· Tests the class of an object at runtime. Checking is done at compile and runtime same as the cast operator.

· Returns true if the object denoted by LHS reference can be cast to RHS type.

· LHS should be an object reference expression, variable or an array reference.

· RHS should be a class (abstract classes are fine), an interface or an array type, castable to LHS object reference. Compiler error if LHS & RHS are unrelated.

· Can't use java.lang.Class or its String name as RHS.

· Returns true if LHS is a class or subclass of RHS class

· Returns true if LHS implements RHS interface.

· Returns true if LHS is an array reference and of type RHS.

· x instanceof Component[] - legal.

· x instanceof [] - illegal. Can't test for 'any array of any type'

· Returns false if LHS is null, no exceptions are thrown.

· If x instanceof Y is not allowed by compiler, then Y y = (Y) x is not a valid cast expression. If x instanceof Y is allowed and returns false, the above cast is valid but throws a ClassCastException at runtime. If x instanceof Y returns true, the above cast is valid and runs fine.

4.3 Equality comparisons - ==, !=

· For primitives it's a straightforward value comparison. (promotions apply)

· For object references, this doesn't make much sense. Use equals method for meaningful comparisons. (Make sure that the class implements equals in a meaningful way, like for X.equals(Y) to be true, Y instance of X must be true as well)

· For String literals, == will return true, this is because of compiler optimization.

Check JAVA Fundamentals before this.

5. Bit-wise operators - &, ^, |

· Operate on numeric and boolean operands.

· & - AND operator, both bits must be 1 to produce 1.

· | - OR operator, any one bit can be 1 to produce 1.

· ^ - XOR operator, any one bit can be 1, but not both, to produce 1.

· In case of booleans true is 1, false is 0.

· Can't cast any other type to boolean.

Check JAVA Fundamentals before this.

6. Short-circuit logical operators - &&, ||

· Operate only on boolean types.

· RHS might not be evaluated (hence the name short-circuit), if the result can be determined only by looking at LHS.

· false && X is always false.

· true || X is always true.

· RHS is evaluated only if the result is not certain from the LHS.

· That's why there's no logical XOR operator. Both bits need to be known to calculate the result.

· Short-circuiting doesn't change the result of the operation. But side effects might be changed. (i.e. some statements in RHS might not be executed, if short-circuit happens. Be careful)

Check JAVA Fundamentals before this.

7. Ternary operator

· Format a = x ? b : c ;

· x should be a boolean expression.

· Based on x, either b or c is evaluated. Both are never evaluated.

· b will be assigned to a if x is true, else c is assigned to a.

· b and c should be assignment compatible to a.

· b and c are made identical during the operation according to promotions.

Check JAVA Fundamentals before this.

8. Assignment operators.

· Simple assignment =.

· op= calculate and assign operators extended assignment operators.

· *=, /=, %=, +=, -=

· x += y means x = x + y. But x is evaluated only once. Be aware.

· Assignment of reference variables copies the reference value, not the object body.

· Assignment has value, value of LHS after assignment. So a = b = c = 0 is legal. c = 0 is executed first, and the value of the assignment (0) assigned to b, then the value of that assignment (again 0) is assigned to a.

· Extended assignment operators do an implicit cast. (Useful when applied to byte, short or char)

byte b = 10;

b = b + 10; // Won't compile, explicit cast required since the expression evaluates to an int

b += 10; // OK, += does an implicit cast from int to byte

9. General

· In Java, No overflow or underflow of integers happens. i.e. The values wrap around. Adding 1 to the maximum int value results in the minimum value.

· Always keep in mind that operands are evaluated from left to right, and the operations are executed in the order of precedence and associativity.

· Unary Postfix operators and all binary operators (except assignment operators) have left to right assoiciativity.

· All unary operators (except postfix operators), assignment operators, ternary operator, object creation and cast operators have right to left assoiciativity.

· Inspect the following code.

public class Precedence {

final public static void main(String args[]) {

int i = 0;

i = i++;

i = i++;

i = i++;

System.out.println(i); // prints 0, since = operator has the lowest precedence.

int array[] = new int[5];

int index = 0;

array[index] = index = 3; // 1st element gets assigned to 3, not the 4th element

for (int c = 0; c < array.length; c++)

System.out.println(array[c]);

System.out.println("index is " + index); // prints 3

}

}

Type of Operators	Operators	Associativity
Postfix operators	[] . (parameters) ++ --	Left to Right
Prefix Unary operators	++ -- + - ~ !	Right to Left
Object creation and cast	new (type)	Right to Left
Multiplication/Division/Modulus	* / %	Left to Right
Addition/Subtraction	+ -	Left to Right
Shift	>> >>> <<	Left to Right
Relational	< <= > >= instanceof	Left to Right
Equality	== !=	Left to Right
Bit-wise/Boolean AND	&	Left to Right
Bit-wise/Boolean XOR	^	Left to Right
Bit-wise/Boolean OR	\|	Left to Right
Logical AND (Short-circuit or Conditional)	&&	Left to Right
Logical OR (Short-circuit or Conditional)	\|\|	Left to Right
Ternary	? :	Right to Left
Assignment	= += -= *= /= %= <<= >>= >>>= &= ^= \|=	Right to Left

Click below link for Related post:

JAVA Fundamentals

Some basic java programs:

Java Fundamentals

2012-04-22T12:13:00.001+05:30

Java fundamentals

The Java programming language has includes five simple arithmetic operators like are + (addition), - (subtraction), * (multiplication), / (division), and % (modulo). The following table summarizes them:

1. Source file's elements (in order)

·
Package declaration

·
Import statements

·
Class definitions

2. Importing packages doesn't recursively import sub-packages.

3. Sub-packages are really different packages, happen to live within an enclosing package. Classes in sub-packages cannot access classes in enclosing package with default access.

4. Comments can appear anywhere. Can't be nested. No matter what type of comments.

5. At most one public class definition per file. This class name should match the file name. If there are more than one public class definitions, compiler will accept the class with the file's name and give an error at the line where the other class is defined.

6. It's not required having a public class definition in a file. Strange, but true. J In this case, the file's name should be different from the names of classes and interfaces (not public obviously).

7. Even an empty file is a valid source file.

8. An identifier must begin with a letter, dollar sign ($) or underscore (_). Subsequent characters may be letters, $, _ or digits.

9. An identifier cannot have a name of a Java keyword. Embedded keywords are OK. true, false and null are literals (not keywords), but they can't be used as identifiers as well.

10. const and goto are reserved words, but not used.

11. Unicode characters can appear anywhere in the source code. The following code is valid.

ch\u0061r a = 'a';

char \u0062 = 'b';

char c = '\u0063';

12. Java has 8 primitive data types.

Data Type	Size (bits)	Initial Value	Min Value	Max Value
boolean	1	false	false	true
byte	8	0	-128 (-2⁷)	127 (2⁷ - 1)
short	16	0	-2¹⁵	2¹⁵ - 1
char	16	'\u0000'	'\u0000' (0)	'\uFFFF' (2¹⁶ - 1)
int	32	0	-2³¹	2³¹ - 1
long	64	0L	-2⁶³	2⁶³ - 1
float	32	0.0F	1.4E-45	3.4028235E38
double	64	0.0	4.9E-324	1.7976931348623157E308

13. All numeric data types are signed. char is the only unsigned integral type.

14. Object reference variables are initialized to null.

15. Octal literals begin with zero. Hex literals begin with 0X or 0x.

16. Char literals are single quoted characters or unicode values (begin with \u).

17. A number is by default an int literal, a decimal number is by default a double literal.

18. 1E-5d is a valid double literal, E2d is not (since it starts with a letter, compiler thinks that it's an identifier)

19. Two types of variables.

a.

Member variables

·
Accessible anywhere in the class.

·
Automatically initialized before invoking any constructor.

·
Static variables are initialized at class load time.

·
Can have the same name as the class.

b.

Automatic variables method local

· Must be initialized explicitly. (Or, compiler will catch it.) Object references can be initialized to null to make the compiler happy. The following code won't compile. Specify else part or initialize the local variable explicitly.

public String testMethod ( int a) {

String tmp;

if ( a > 0 ) tmp = "Positive";

return tmp;

}

· Can have the same name as a member variable, resolution is based on scope.

20. Arrays are Java objects.

If you create an array of 5 Strings, there will be 6 objects created.

21. Arrays should be

·
Declared. (int[] a; String b[]; Object []c; Size should not be specified now)

·
Allocated (constructed). ( a = new int[10]; c = new String[arraysize] )

·
Initialized. for (int i = 0; i < a.length; a[i++] = 0)

22. The above three can be done in one step.

int a[] = { 1, 2, 3 }; (or )

int a[] = new int[] { 1, 2, 3 }; But never specify the size with the new statement.

23. Java arrays are static arrays. Size has to be specified at compile time. Array.length returns array's size. (Use Vectors for dynamic purposes).

24. Array size is never specified with the reference variable, it is always maintained with the array object. It is maintained in array.length, which is a final instance variable.

25. Anonymous arrays can be created and used like this: new int[] {1,2,3} or new int[10]

26. Arrays with zero elements can be created. args array to the main method will be a zero element array if no command parameters are specified. In this case args.length is 0.

27. Comma after the last initializer in array declaration is ignored.

int[] i = new int[2] { 5, 10}; // Wrong

int i[5] = { 1, 2, 3, 4, 5}; // Wrong

int[] i[] = {{}, new int[] {} }; // Correct

int i[][] = { {1,2}, new int[2] }; // Correct

int i[] = { 1, 2, 3, 4, } ; // Correct

28. Array indexes start with 0. Index is an int data type.

29. Square brackets can come after datatype or before/after variable name. White spaces are fine. Compiler just ignores them.

30. Arrays declared even as member variables also need to be allocated memory explicitly.

static int a[];

static int b[] = {1,2,3};

public static void main(String s[]) {

System.out.println(a[0]); // Throws a null pointer exception

System.out.println(b[0]); // This code runs fine

System.out.println(a); // Prints 'null'

System.out.println(b); // Prints a string which is returned by toString

}

31. Once declared and allocated (even for local arrays inside methods), array elements are automatically initialized to the default values.

32. If only declared (not constructed), member array variables default to null, but local array variables will not default to null.

33. Java doesn't support multidimensional arrays formally, but it supports arrays of arrays. From the specification - "The number of bracket pairs indicates the depth of array nesting." So this can perform as a multidimensional array. (no limit to levels of array nesting)

34. In order to be run by JVM, a class should have a main method with the following signature.

public static void main(String args[])

static public void main(String[] s)

35. args array's name is not important. args[0] is the first argument. args.length gives no. of arguments.

36. main method can be overloaded.

37. main method can be final.

38. A class with a different main signature or w/o main method will compile. But throws a runtime error.

39. A class without a main method can be run by JVM, if its ancestor class has a main method. (main is just a method and is inherited)

40. Primitives are passed by value.

41. Objects (references) are passed by reference. The object reference itself is passed by value. So, it can't be changed. But, the object can be changed via the reference.

42. Garbage collection is a mechanism for reclaiming memory from objects that are no longer in use, and making the memory available for new objects.

43. An object being no longer in use means that it can't be referenced by any 'active' part of the program.

44. Garbage collection runs in a low priority thread. It may kick in when memory is too low. No guarantee.

45. It's not possible to force garbage collection. Invoking System.gc may start garbage collection process.

46. The automatic garbage collection scheme guarantees that a reference to an object is always valid while the object is in use, i.e. the object will not be deleted leaving the reference "dangling".

47. There are no guarantees that the objects no longer in use will be garbage collected and their finalizers executed at all. gc might not even be run if the program execution does not warrant it. Thus any memory allocated during program execution might remain allocated after program termination, unless reclaimed by the OS or by other means.

48. There are also no guarantees on the order in which the objects will be garbage collected or on the order in which the finalizers are called. Therefore, the program should not make any decisions based on these assumptions.

49. An object is only eligible for garbage collection, if the only references to the object are from other objects that are also eligible for garbage collection. That is, an object can become eligible for garbage collection even if there are references pointing to the object, as long as the objects with the references are also eligible for garbage collection.

50. Circular references do not prevent objects from being garbage collected.

51. We can set the reference variables to null, hinting the gc to garbage collect the objects referred by the variables. Even if we do that, the object may not be gc-ed if it's attached to a listener. (Typical in case of AWT components) Remember to remove the listener first.

52. All objects have a finalize method. It is inherited from the Object class.

53.finalize method is used to release system resources other than memory.(such as file handles and network connections) The order in which finalize methods are called may not reflect the order in which objects are created. Don't rely on it. This is the signature of the finalize method.

protected void finalize() throws Throwable { }

In the descendents this method can be protected or public. Descendents can restrict the exception list that can be thrown by this method.

54. finalize is called only once for an object. If any exception is thrown in finalize, the object is still eligible for garbage collection (at the discretion of gc)

55. gc keeps track of unreachable objects and garbage-collects them, but an unreachable object can become reachable again by letting know other objects of its existence from its finalize method (when called by gc). This 'resurrection' can be done only once, since finalize is called only one for an object.

56.finalize can be called explicitly, but it does not garbage collect the object.

57.finalize can be overloaded, but only the method with original finalize signature will be called by gc.

58. finalize is not implicitly chained. A finalize method in sub-class should call finalize in super class explicitly as its last action for proper functioning. But compiler doesn't enforce this check.

59.System.runFinalization

can be used to run the finalizers (which have not been executed before) for the objects eligible for garbage collection.

Fundamental programs

Sum of integers between 100 to 200 divisible by 7

2012-04-22T12:12:00.001+05:30

/* Write a program to find sum of all integers greater than 100 and

less than 200 that are divisible by 7 */

class SumOfDigit{

public static void main(String args[]){

int result=0;

for(int i=100;i<=200;i++){

if(i%7==0)

result+=i;

}

System.out.println("Output of Program is : "+result);

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Fibonacci series

2012-04-22T12:11:00.001+05:30

/*Write a program to find Fibonacci series of a given no.

Example :

Input - 8

Output - 1 1 2 3 5 8 13 21

class Fibonacci{

public static void main(String args[]){

int num = Integer.parseInt(args[0]); //taking no. as command line argument.

System.out.println("*****Fibonacci Series*****");

int f1, f2=0, f3=1;

for(int i=1;i<=num;i++){

System.out.print(" "+f3+" ");

f1 = f2;

f2 = f3;

f3 = f1 + f2;

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Reverse a given number

2012-04-22T12:04:00.001+05:30

/*Write a program to Reverse a given no. */

class Reverse{

public static void main(String args[]){

int num = Integer.parseInt(args[0]); //take argument as command line

int remainder, result=0;

while(num>0){

remainder = num%10;

result = result * 10 + remainder;

num = num/10;

}

System.out.println("Reverse number is : "+result);

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Factorial of an given number

2012-04-22T12:03:00.001+05:30

/*Write a program to Find Factorial of Given no. */

class Factorial{

public static void main(String args[]){

int num = Integer.parseInt(args[0]); //take argument as command line

int result = 1;

while(num>0){

result = result * num;

num--;

}

System.out.println("Factorial of Given no. is : "+result);

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Find sum and product of a given digit

2012-04-22T12:02:00.001+05:30

/*Write a program to find SUM AND PRODUCT of a given Digit. */

class Sum_Product_ofDigit{

public static void main(String args[]){

int num = Integer.parseInt(args[0]); //taking value as command line argument.

int temp = num,result=0;

//Logic for sum of digit

while(temp>0){

result = result + temp;

temp--;

}

System.out.println("Sum of Digit for "+num+" is : "+result);

//Logic for product of digit

temp = num;

result = 1;

while(temp > 0){

result = result * temp;

temp--;

}

System.out.println("Product of Digit for "+num+" is : "+result);

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Greet message using Switch case

2012-04-22T12:01:00.001+05:30

/* Write a program to display a greet message according to

Marks obtained by student.

class SwitchDemo{

public static void main(String args[]){

int marks = Integer.parseInt(args[0]); //take marks as command line argument.

switch(marks/10){

case 10:

case 9:

case 8:

System.out.println("Excellent");

break;

case 7:

System.out.println("Very Good");

break;

case 6:

System.out.println("Good");

break;

case 5:

System.out.println("Work Hard");

break;

case 4:

System.out.println("Poor");

break;

case 3:

case 2:

case 1:

case 0:

System.out.println("Very Poor");

break;

default:

System.out.println("Invalid value Entered");

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Generate random number between 1 to 100

2012-04-22T12:00:00.001+05:30

/*Write a program to generate 5 Random nos. between 1 to 100, and it

should not follow with decimal point.

class RandomDemo{

public static void main(String args[]){

for(int i=1;i<=5;i++){

System.out.println((int)(Math.random()*100));

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Read float and print o/p as shown

2012-04-22T11:58:00.001+05:30

/* Write a program that will read a float type value from the keyboard and print the following output.

->Small Integer not less than the number.

->Given Number.

->Largest Integer not greater than the number.

class ValueFormat{

public static void main(String args[]){

double i = 34.32; //given number

System.out.println("Small Integer not greater than the number : "+Math.ceil(i));

System.out.println("Given Number : "+i);

System.out.println("Largest Integer not greater than the number : "+Math.floor(i));

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Minimum of two numbers

2012-04-22T11:57:00.000+05:30

Find Minimum of 2 nos. using conditional operator

class Minof2{

public static void main(String args[]){

//taking value as command line argument.

//Converting String format to Integer value

int i = Integer.parseInt(args[0]);

int j = Integer.parseInt(args[1]);

int result = (i<j)?i:j;

System.out.println(result+" is a minimum value");

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Max of two numbers

2012-04-22T11:55:00.001+05:30

Find Maximum of 2 nos.

class Maxof2{

public static void main(String args[]){

//taking value as command line argument.

//Converting String format to Integer value

int i = Integer.parseInt(args[0]);

int j = Integer.parseInt(args[1]);

if(i > j)

System.out.println(i+" is greater than "+j);

else

System.out.println(j+" is greater than "+i);

}

Fundamental programs

Sum of integers between 100 to 200 divisible by 7  Fibonacci series  Reverse a given number

Factorial of an given number  Find sum and product of a given digit  Greet message using Switch case

Generate random number between 1 to 100   Read float and print o/p as shown   Minimum of two numbers Max of two numbers

Java interview Questions 1.2

2012-04-17T19:28:00.006+05:30

Check links 1.0 and 1.1 for earlier questions

21. If a class is located in a package, what do you need to change in the OS environment to be able to use it?
You need to add a directory or a jar file that contains the package directories to the CLASSPATH environment variable. Let's say a class Employee belongs to a package com.xyz.hr; and is located in the file c:\dev\com\xyz\hr\Employee.javIn this case, you'd need to add c:\dev to the variable CLASSPATH. If this class contains the method main(), you could test it from a command prompt window as follows:
c:\>java com.xyz.hr.Employee

22. What's the difference between J2SDK 1.5 and J2SDK 5.0?There's no difference, Sun Microsystems just re-branded this version.

23. Does it matter in what order catch statements for FileNotFoundException and IOExceptipon are written?

Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's subclasses have to be caught first.

24. Name the containers which uses Border Layout as their default layout?
Containers which uses Border Layout as their default are: window, Frame and Dialog classes.

25. You are planning to do an indexed search in a list of objects. Which of the two Java collections should you use:
ArrayList or LinkedList?
ArrayList

26. When should the method invokeLater()be used?
This method is used to ensure that Swing components are updated through the event-dispatching thread.

27. How can a subclass call a method or a constructor defined in a superclass?

Use the following syntax: super.myMethod(); To call a constructor of the superclass, just write super(); in the first line of the subclass's constructor.

28. What do you understand by Synchronization?
Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner that only one thread can access one resource at a time. In non synchronized multithreaded application, it is possible for one thread to modify a shared object while another thread is in the process of using or updating the object's value. Synchronization prevents such type of data corruption.
E.g. Synchronizing a function:
public synchronized void Method1 () {
    // Appropriate method-related code.
}
E.g. Synchronizing a block of code inside a function:
public myFunction (){
    synchronized (this) {
    // Synchronized code here.
}
}

29. What's the difference between a queue and a stack?
Stacks works by last-in-first-out rule (LIFO), while queues use the FIFO rule

30. You can create an abstract class that contains only abstract methods. On the other hand, you can create an interface that declares the same methods. So can you use abstract classes instead of interfaces?
Sometimes. But your class may be a descendent of another class and in this case the interface is your only option.

Related post:

Java interview Questions 1.0 Java interview Questions 1.1

Basic java programs

Link Up Directory

Programming Katta

Whether given no. is Armstrong or not

/*Write a program to find whether given no. is Armstrong or not.

Example : Input - 153

Output - 1^3 + 5^3 + 3^3 = 153, so it is Armstrong no. */

Convert given no. of days into months and days

/* Write a program to convert given no. of days into months and days.

(Assume that each month is of 30 days)

Example :

Input - 69

Output - 69 days = 2 Month and 9 days */

Program to generate a Triangle

/*Write a program to generate a Triangle.

eg:

1 2 2 3 3 3 4 4 4 4

and so on as per user given number */

Program to Swap the values

/* Write a program to Swap the values */

Program to Display Multiplication Table

/* Program to Display Multiplication Table */

Concatenate string using for Loop

/* Write a program to Concatenate string using for Loop Example: Input - 5 Output - 1 2 3 4 5 */

JavaServer Pages

Java Server Pages (JSP)

Java Servlet

Java Servlet

Flow control and Exception in java

Flow Control and Exceptions

1. Loop constructs

2. Selection Statements

3. Branching statements

4. Exception Handling

Hardware Basics

1. Which of the following components found on a motherboard is the most visible?

2. Which of the following BEST describes the difference between the "baby" AT and ATX motherboards?

3. Which of the following memory module form factors are commonly used for laptops?

4. Which of the following are SCSI types that allow for 16 devices, including theadapter, to be connected on a single shared cable?

5. What do you call the part of a CD-ROM drive's head assembly that moves acrossthe disk to read it?

6. What is clock speed of the AGPx8 expansion slot?

7. Which of the following components on the motherboard usually house the IDEconnectors?

8 When a technician upgrades firmware on a motherboard he has to ______.

9 In which of the following is the output from a power supply rated?

10. When connecting the power cable of an AT power supply to the mother board,which two wires on the power connectors (P8/P9) should be together?

Modifiers in java

Reactions before the final engineering viva

Final day of Engineering VIVA

Sayali desai before her Final viva

Operators and assignments in java

1. Unary operators

3. Shift operators - <<, >>, >>>

4. Comparison operators - all return boolean type.

5. Bit-wise operators - &, ^, |

6. Short-circuit logical operators - &&, ||

7. Ternary operator

8. Assignment operators.

9. General

Java Fundamentals

Java fundamentals

Fundamental programs

Sum of integers between 100 to 200 divisible by 7

Fundamental programs

Fibonacci series

Fundamental programs

Reverse a given number

Fundamental programs

Factorial of an given number

Fundamental programs

Find sum and product of a given digit

Fundamental programs

Greet message using Switch case

Fundamental programs

Generate random number between 1 to 100

Fundamental programs

Read float and print o/p as shown

Fundamental programs

Minimum of two numbers

Fundamental programs

Max of two numbers

Fundamental programs

Java interview Questions 1.2

**/*Write a program to find whether given no. is Armstrong or not.**

**Output - 1^3 + 5^3 + 3^3 = 153, so it is Armstrong no. */**

**/* Write a program to convert given no. of days into months and days.**

**Output - 69 days = 2 Month and 9 days */**

1
2 2
3 3 3
4 4 4 4

**/* Write a program to Swap the values */**

**/* Program to Display Multiplication Table */**

**/* Write a program to Concatenate string using for Loop Example: Input - 5 Output - 1 2 3 4 5 */**