# What does the command ‘use strict’ do and why should you use it?

# What do the symbols $ @ and % mean when prefixing a variable?

# What elements of the Perl language could you use to structure your code to allow for maximum re-use and maximum readability?

# What are the characteristics of a project that is well suited to Perl?

# Why do you program in Perl?

# Explain the difference between my and local.

# Explain the difference between use and require.

# What’s your favorite module and why?

# What is a hash?

# Write a simple (common) regular expression to match an IP address, e-mail address, city-state-zipcode combination.

# What purpose does each of the following serve: -w, strict, -T ?

# What is the difference between for & foreach, exec & system?

# Where do you go for Perl help?

# Name an instance where you used a CPAN module.

# How do you open a file for writing?

# How would you replace a char in string and how do you store the number of replacements?

# When would you not use Perl for a project?

via Perl interview questions and answers | TechInterviews.

# What is a Windows Service and how does its lifecycle differ from a “standard” EXE?

# What is the maximum amount of memory any single process on Windows can address? Is this different than the maximum virtual memory for the system? How would this affect a system design?

# What is the difference between an EXE and a DLL?

# What is strong-typing versus weak-typing? Which is preferred? Why?

# What’s wrong with a line like this? DateTime.Parse(myString

# What are PDBs? Where must they be located for debugging to work?

# What is cyclomatic complexity and why is it important?

# Write a standard lock() plus double check to create a critical section around a variable access.

# What is FullTrust? Do GAC’ed assemblies have FullTrust?

# What benefit does your code receive if you decorate it with attributes demanding specific Security permissions?

# What does this do? gacutil /l | find /i “about”

# What does this do? sn -t foo.dll

# What ports must be open for DCOM over a firewall? What is the purpose of Port 135?

# Contrast OOP and SOA. What are tenets of each

# How does the XmlSerializer work? What ACL permissions does a process using it require?

# Why is catch(Exception) almost always a bad idea?

# What is the difference between Debug.Write and Trace.Write? When should each be used?

# What is the difference between a Debug and Release build? Is there a significant speed difference? Why or why not?

# Does JITting occur per-assembly or per-method? How does this affect the working set?

# Contrast the use of an abstract base class against an interface?

# What is the difference between a.Equals(b) and a == b?

# In the context of a comparison, what is object identity versus object equivalence?

# How would one do a deep copy in .NET?

# Explain current thinking around IClonable.

# What is boxing?

# Is string a value type or a reference type?

via ASP.NET interview questions and answers | TechInterviews.

via C# interview questions and answers | TechInterviews.

Differences between VB.Net and C#, related to OOPS concepts?

VB.NET is a windows application

Where as C# is a console

1)What is the difference between vb and vb.net ?
vb is object based and vb.net is object oriented.In VB.net ,oops concept is used

How can i extract the formated word(bold,italic,underline,font,color etc) from the msword file.

using CommonDialog class

eg:

the code to invoke the default font dialog box by using the FontDialog control is given below:

private sub displayfont_click(byval sender as system.object,byval e as system.eventargs) handles displayfont.click

fontdialog.showDialog()

textbox1.font=fontdialog1.font

end sub

the code to invoke the default font dialog box by instantiating the fontdialog class is:

dim fdialog as new fontdialog()

private sub displayfont_click(byval sender as system.object,byval e as system.eventargs) handles displayfont.click

fdialog.showDialog()

textbox1.font=fontdialog1.font

end sub

How does CLR solves dll hell?

Unlike VB6; .net does not require to generate GUID for the dll’s. The dll’s are hosted thru applications ,IIS or windows services. These things internally refer to the physical locations of the file thus even if the dll is updated with certain functionalities the older application can still refer to the previous version of the Dll.

How to send xml file on server using HTTP protocol?

Through SOAP Protocol

What is different between Web.Config and Machine.Config and Where it will be ?

the settings made in the web.config file are applied to that particular web application only whereas the settings of machine.config file are applied to the whole asp.net application.

Whats the difference bt. .dll extension and .exe extension files?

The main difference between .dll and .exe is

.dll is the In process component where it take up the client’s memory space to run. So the communication between the application and component(dll) is very fast.

.EXE is the Out of process component. It uses its own memory(not application memory) to run the component. The communication between the application and component is slow when compared to .dll

What is the base class of .net?

System.Object is the base class of .NET

It Supports all classes in the .NET Framework class hierarchy and provides low-level services to derived classes. This is the ultimate superclass of all classes in the .NET Framework; it is the root of the type hierarchy.

How to store and retrieve images in sql server database through VB.NET

SQL Server supports the ability for clients to store objects within tables

What are Jagged Arrarys ?
The other type of multidimensional array is the jagged array. A two dimensional jagged array can be thought of as a table where each row can have a different number of columns. Take for example, a table where families are the rows and family members are the columns. Unless each family has the same number of members, each row will have a variable number of columns. You can use a jagged array to represent such a table.

A jagged array is really an array of arrays. To create a jagged array, you declare the array of arrays with multiple sets of parentheses or brackets and indicate the size of the jagged array in the first set of brackets (parentheses).

How can we remove Handlers at Run time ?

RemoveHandler myobj.myEvent, AddressOf MyEventHandler

What are Satellite Assemblies?

Satellite assemblies are user for localizing the applications resources.
A satellite assembly is a DLL that contains only resource strings
.we typically have one satellite assembly DLL for each language. Because these satellite assembly DLLs are separated from the main assembly (an .exe or DLL), it is easier to drop in multi-language support as we progress in your development process.

What do you mean by ‘Option Strict On’ ?

Option Strict

Visual Basic language in general does not require explicit syntax to be used when performing operations that might not be optimally efficient (e.g. late binding) or that might fail at run time (e.g. narrowing conversions). This permissive semantics often prevents detection of coding errors and also affects the performance of the application.

VB.NET enables a programmer to enforce strict semantics by setting this option to “On”. When used, this option should appear before any other code. This option can be set to “On” or “Off”. If this statement is not specified, by default, it is set to “Off”.

Syntax: Option Strict [On / Off]
When it is set to “On”, it disallows any narrowing conversions to occur without an explicit cast operator, late binding and does not let the programmer omit “As” clause in the declaration statement. Since setting it to “On” requires explicit conversion, it also requires that the compiler be able to determine the type of each variable. Thus it is implied that Option Strict also means Option Explicit.

Visual Basic .NET allows implicit conversions of any data type to any other data type. However, data loss can occur if the value of one data type is converted to a data type with less precision or a smaller capacity. Setting this option to “On” ensures compile-time notification of these types of conversions so they may be avoided.

How VB Implements the Disonnected Architecture as like VB.Net?
In VB to implement a disconnected recordset, after you have filled the recordset with the data, set its active connection property to “Nothing”. That breaks the connection to the database.You can locally also save the data of the recordset by using its Save function.

* more here

1. How do you register a component? Expected answer: Compiling the component, running REGSVR32 MyDLL.dll
2. Name and explain the different compatibility types when creating a COM component.Expected answer: No Compatibility ? New GUID created, references from other components will not workProject Compatibility ? Default for a new component <Not as critical to mention this one>Binary Compatibility ? GUID does not change, references from other components will work
3. Why iss it important to use source control software for source code? Expected answer:Modification history.Code ownership: Multiple people can not modify the same code at the same time.
4. What two methods are called from the ObjectContext object to inform MTS that the transaction was successful or unsuccessful? Expected answer: SetComplete and SetAbort.
5. What is the tool used to configure the port range and protocols for DCOM communications? Expected answer: DCOMCONFIG.EXE
6. What does Option Explicit refer to? Expected answer: All variables must be declared before use. Their type is not required.
7. What are the different ways to Declare and Instantiate an object in Visual Basic 6?Expected answer: Dim obj as OBJ.CLASS with eitherSet obj = New OBJ.CLASS orSet obj = CreateObject(?OBJ.CLASS?) orSet obj = GetObject( ,? OBJ.CLASS?)orDim obj as New OBJ.CLASS
8. Name the four different cursor types in ADO and describe them briefly. Expected answer:The cursor types are listed from least to most resource intensive.Forward Only ? Fastest, can only move forward in recordset Static ? Can move to any record in the recordset. Data is static and never changes.KeySet ? Changes are detectable, records that are deleted by other users are unavailable, and records created by other users are not detectedDynamic ? All changes are visible.
9. Name the four different locking type in ADO and describe them briefly. Expected answer:LockPessimistic ? Locks the row once after any edits occur.LockOptimistic ? Locks the row only when Update is called.LockBatchOptimistic ? Allows Batch Updates.LockReadOnly ? Read only. Can not alter the data.
10. Describe Database Connection pooling (relative to MTS ) Expected answer: This allows MTS to reuse database connections. Database connections are put to ?sleep? as opposed to being created and destroyed and are activated upon request.
11. What are the ADO objects? Explain them. Provide a scenario using three of them to return data from a database. Expected answer: Connection ? Connects to a data source; contains the Errors collectionCommand ? Executes commands to the data source. Is the only object that can accept parameters for a stored procedure.Recordset ? The set of data returned from the database.Scenario: There are many possibilities. The most likely is as follows:Dim conn As ADODB.ConnectionDim rs As ADODB.RecordsetDim Cmd As ADODB.Commandconn.ConnectionString = ?CONNECTION STRING?conn.OpenSet Cmd.ActiveConnection = connCmd.CommandText = ?SQL STATEMENT?Set rs = Cmd.ExecuteSet rs.ActiveConnection = Nothingconn.Close
12. Under the ADO Command Object, what collection is responsible for input to stored procedures? Expected answer: The Parameters collection.
13. What are some benefits of using MTS? Expected answer: Database Pooling, Transactional operations, Deployment, Security, Remote Execution.
14. What is the benefit of wrapping database calls into MTS transactions? Expected answer:If database calls are made within the context of a transaction, aborting the transaction will undo and changes that occur within that transaction. This removes the possibility of stranded, or partial data.
15. Describe and In Process vs. Out of Process component. Which is faster? Expected answer:An in-process component is implemented as a DLL, and runs in the same process space as its client app, enabling the most efficient communication between client and component.Each client app that uses the component starts a new instance of it.An out of process component is implemented as an EXE, and unlike a dll, runs in its own process space. As a result, exe’s are slower then dll’s because communications between client and component must be marshalled across process boundaries. A single instance of an out of process component can service many clients.
16. What are the main components of the ADO object model? How are they used? Expected answer:Connection: Used to make a connection between your app and an external data source, ie, sql server.Command: Used to build queries, including user-specific parameters, to access records from a data source (which are returned in a Recordset)Recordset:Used to access records returned from an SQL query. With a recordset, you can navigate returned records. You can also add, modify or delete records.

* more here ]]> http://www.freequestionbank.com/question/visual-basic-interview-questions/feed/ 0 http://www.freequestionbank.com/question/c-interview-questions/ http://www.freequestionbank.com/question/c-interview-questions/#comments Thu, 26 Mar 2009 07:43:04 +0000 admin http://www.freequestionbank.com/?p=420 1.Difference between arrays and pointers?
- Pointers are used to manipulate data using the address. Pointers use * operator to access the data pointed to by them

- Arrays use subscripted variables to access and manipulate data.Array variables can be equivalently written using pointer expression.

2. What are the advantages of the functions?

Answer – Debugging is easier

- It is easier to understand the logic involved in the program
- Testing is easier
- Recursive call is possible
- Irrelevant details in the user point of view are hidden in functions
- Functions are helpful in generalizing the program

3 How can I open a file so that other programs can update it at the same time?

Answer Your C compiler library contains a low-level file function called sopen() that can be used to open a file in shared mode. Beginning with DOS 3.0, files could be opened in shared mode by loading a special program named SHARE.EXE. Shared mode, as the name implies, allows a file to be shared with other programs as well as your own.

Using this function, you can allow other programs that are running to update the same file you are updating.

The sopen() function takes four parameters: a pointer to the filename you want to open, the operational
mode you want to open the file in, the file sharing mode to use, and, if you are creating a file, the mode to create the file in. The second parameter of the sopen() function, usually referred to as the “operation flag”parameter, can have the following values assigned to it:

Constant Description O_APPEND Appends all writes to the end of the file

O_BINARY Opens the file in binary (untranslated) mode
O_CREAT If the file does not exist, it is created
O_EXCL If the O_CREAT flag is used and the file exists, returns an error
O_RDONLY Opens the file in read-only mode
O_RDWR Opens the file for reading and writing
O_TEXT Opens the file in text (translated) mode
O_TRUNC Opens an existing file and writes over its contents
O_WRONLY Opens the file in write-only mode

The third parameter of the sopen() function, usually referred to as the “sharing flag,” can have the following values assigned to it:

Constant Description
SH_COMPAT No other program can access the file
SH_DENYRW No other program can read from or write to the file
SH_DENYWR No other program can write to the file
SH_DENYRD No other program can read from the file
SH_DENYNO Any program can read from or write to the file

If the sopen() function is successful, it returns a non-negative number that is the file’s handle. If an error occurs, –1 is returned, and the global variable errno is set to one of the following values:

Constant Description
ENOENT File or path not found
EMFILE No more file handles are available
EACCES Permission denied to access file
EINVACC Invalid access code
Constant Description

4. Can static variables be declared in a header file?

You can’t declare a static variable without defining it as well (this is because the storage class modifiers
static and extern are mutually exclusive). A static variable can be defined in a header file, but this would cause each source file that included the header file to have its own private copy of the variable, which is probably not what was intended.
6.How can you check to see whether a symbol is defined?

You can use the #ifdef and #ifndef preprocessor directives to check whether a symbol has been defined
(#ifdef) or whether it has not been defined (#ifndef).

7.How do you override a defined macro?

Answer
You can use the #undef preprocessor directive to undefine (override) a previously defined macro.

10. Can a variable be both const and volatile?

Yes. The const modifier means that this code cannot change the value of the variable, but that does not mean that the value cannot be changed by means outside this code. For instance, in the example in
FAQ 8, the timer structure was accessed through a volatile const pointer. The function itself did not change the value of the timer, so it was declared const. However, the value was changed by hardware on the computer, so it was declared volatile. If a variable is both const and volatile, the two modifiers can appear in either order.
11. Can include files be nested?

Yes. Include files can be nested any number of times. As long as you use precautionary measures , you can avoid including the same file twice. In the past, nesting header files was seen as bad programming practice, because it complicates the dependency tracking function of the MAKE program and thus slows down compilation. Many of today’s popular compilers make up for this difficulty by implementing a concept called precompiled headers, in which all headers and associated dependencies are stored in
a precompiled state.

Many programmers like to create a custom header file that has #include statements for every header needed for each module. This is perfectly acceptable and can help avoid potential problems relating to #include files, such as accidentally omitting an #include file in a module.

12. Can static variables be declared in a header file?
Yes there is difference between declaring a static variable as global and local. If it is local, it can be accessed only in the function where it’s declared. But if it is global, all functions can access it. But, what ever be the case, its value will be retained between functions.

13. When does the compiler not implicitly generate the address of the first element of an array?

Whenever an array name appears in an expression such as

- array as an operand of the sizeof operator

- array as an operand of & operator

- array as a string literal initializer for a character array

Then the compiler does not implicitly generate the address of the address of the first element of an array.

14.What is the difference between #include <file> and #include “file”?

When writing your C program, you can include files in two ways. The first way is to surround the file you
want to include with the angled brackets < and >. This method of inclusion tells the preprocessor to look for the file in the predefined default location. This predefined default location is often an INCLUDE environment variable that denotes the path to your include files. For instance, given the INCLUDE variable

INCLUDE=C:\COMPILER\INCLUDE;S:\SOURCE\HEADERS;

using the #include <file> version of file inclusion, the compiler first checks the C:\COMPILER\INCLUDE
directory for the specified file. If the file is not found there, the compiler then checks the
S:\SOURCE\HEADERS directory. If the file is still not found, the preprocessor checks the current directory.

The second way to include files is to surround the file you want to include with double quotation marks. This method of inclusion tells the preprocessor to look for the file in the current directory first, then look for it in the predefined locations you have set up. Using the #include “file” version of file inclusion and applying it to the preceding example, the preprocessor first checks the current directory for the specified file. If the file is not found in the current directory, the C:COMPILERINCLUDE directory is searched. If the file is still not found, the preprocessor checks the S:SOURCEHEADERS directory.
The #include <file> method of file inclusion is often used to include standard headers such as stdio.h or
stdlib.h. This is because these headers are rarely (if ever) modified, and they should always be read from your compiler’s standard include file directory.

The #include “file” method of file inclusion is often used to include nonstandard header files that you have created for use in your program. This is because these headers are often modified in the current directory, and you will want the preprocessor to use your newly modified version of the header rather than the older, unmodified version.

15.When function say abc() calls another function say xyz(), what happens in stack?
When some function xyz() calls function abc(). all the local variables, static links, dynamic links and function return value goes on the top of all elements of function xyz() in the stack. when abc() exit it’s return value has been assigned to xyz().

16.How do you print an address?
we can print the address of a variable or a function using the following specifiers %u,%p here %u prints address in decimal form and %p prints in hexa decimal form,but remember these two format specifiers print only offset adress but they doesn’t print code segment address

there is a another specifier %Fp which prints both the code segment and offset address

18.How to find entered number is EVEN or ODD without using conditional statement(not using if.. else,if.. , else if..,while, do… while…., for….)
We can find a number is odd or even by a simple programmain(){int a[2],i;a[0]=0; //0–means Even Numbera[1]=1; //1–means Odd numberscanf(“%d”,&i);printf(“%d”,a[i%2]);getch();}

19.How to break cycle in circular single link list?
we can delete an intermediate one

20.How can I convert a number to a string?
We can convert number to string using built in function itoa().

21.How to swap the content oftwo variables without a temporary variable
void swap(int a,int b)

{

a =a+b;

b=a-b;

a=a-b;

}

22. How can send unlimited no of arguments to a function, eg printf function can take any no of arguments

using va_list variables in stdarg.h headerfile

23.What is the benefit of using #define to declare a constant?
Using the #define method of declaring a constant enables you to declare a constant in one place and use it throughout your program. This helps make your programs more maintainable, because you need to maintain only the #define statement and not several instances of individual constants throughout your program.

For instance, if your program used the value of pi (approximately 3.14159) several times, you might want to declare a constant for pi as follows:

#define PI 3.14159

Using the #define method of declaring a constant is probably the most familiar way of declaring constants to traditional C programmers. Besides being the most common method of declaring constants, it also takes up the least memory. Constants defined in this manner are simply placed directly into your source code, with no variable space allocated in memory. Unfortunately, this is one reason why most debuggers cannot inspect constants created using the #define method.

24.How do you write a C program which can calculate lines of code but not counting comments?

Using file concept with Command line arguments.declare a variable (lcnt) used to count the no of lines.Open a file in read made and then using while loop check the condition for not equal to EOF.Later using if condition check check for new line and increment the variable for counting the lines.

Then using while,check for the character ‘/’,'*’ (as the comments start with these characters) and end with (‘*’ and ‘/’).if condition of this is true then break and come out of the block else increment the line.

25.How can I search for data in a linked list?

Unfortunately, the only way to search a linked list is with a linear search, because the only way a linked list’s members can be accessed is sequentially. Sometimes it is quicker to take the data from a linked list and store it in a different data structure so that searches can be more efficient.

26.How to write a C program to find the power of 2 in a normal way and in single step?

U can take logarithm base 2, and check the result is in interger form or floating point form, u can check whether it is power of 2 or not.

27.What is hashing?
To hash means to grind up, and that’s essentially what hashing is all about. The heart of a hashing algorithm is a hash function that takes your nice, neat data and grinds it into some random-looking integer.

The idea behind hashing is that some data either has no inherent ordering (such as images) or is expensive to compare (such as images). If the data has no inherent ordering, you can’t perform comparison searches.

If the data is expensive to compare, the number of comparisons used even by a binary search might be too many. So instead of looking at the data themselves, you’ll condense (hash) the data to an integer (its hash value) and keep all the data with the same hash value in the same place. This task is carried out by using the hash value as an index into an array.

To search for an item, you simply hash it and look at all the data whose hash values match that of the data you’re looking for. This technique greatly lessens the number of items you have to look at. If the parameters are set up with care and enough storage is available for the hash table, the number of comparisons needed to find an item can be made arbitrarily close to one.

One aspect that affects the efficiency of a hashing implementation is the hash function itself. It should ideally distribute data randomly throughout the entire hash table, to reduce the likelihood of collisions. Collisions occur when two different keys have the same hash value. There are two ways to resolve this problem. In “open addressing,” the collision is resolved by the choosing of another position in the hash table for the element inserted later. When the hash table is searched, if the entry is not found at its
hashed position in the table, the search continues checking until either the element is found or an empty position in the table is found

The second method of resolving a hash collision is called “chaining.” In this method, a “bucket” or linked list holds all the elements whose keys hash to the same value.

When the hash table is searched, the list must be searched linearly.

28.Diffence arrays and pointers?

To access data using pointers we use the *.

to access data stored in array we use indexes such as a[0].

30.Can a variable be both const and volatile?

This is possible and mostly used in embedded system.The example is Interrupt Status Register.As it is a status register , in the program we should not modify this variable.So it should be a constant.But this variable can be changed by the processor or hardware based on the interrupt condition.So when in the program ,we want to read the value of this varible , it should read the actual value with out any optimisation.For this reason ,the variable can be declared as volatile too

31.Why should we assign NULL to the elements (pointer) after freeing them?

Answer
This is paranoia based on long experience. After a pointer has been freed, you can no longer use the pointed-to data. The pointer is said to “dangle”; it doesn’t point at anything useful. If you “NULL out” or “zero out” a pointer immediately after freeing it, your program can no longer get in trouble by using that pointer. True, you might go indirect on the null pointer instead, but that’s something your debugger might be able to help you with immediately. Also, there still might be copies of the pointer that refer
to the memory that has been deallocated; that’s the nature of C. Zeroing out pointers after freeing them won’t solve all problems;

32.What is a “null pointer assignment” error? What are bus errors, memory faults, and core dumps?
These are all serious errors, symptoms of a wild pointer or subscript.

Null pointer assignment is a message you might get when an MS-DOS program finishes executing. Some
such programs can arrange for a small amount of memory to be available “where the NULL pointer points to” (so to speak). If the program tries to write to that area, it will overwrite the data put there by the compiler.

When the program is done, code generated by the compiler examines that area. If that data has been changed, the compiler-generated code complains with null pointer assignment.

This message carries only enough information to get you worried. There’s no way to tell, just from a null
pointer assignment message, what part of your program is responsible for the error. Some debuggers, and some compilers, can give you more help in finding the problem.

Bus error: core dumped and Memory fault: core dumped are messages you might see from a program running under UNIX. They’re more programmer friendly. Both mean that a pointer or an array subscript was wildly out of bounds. You can get these messages on a read or on a write. They aren’t restricted to null pointer problems.

The core dumped part of the message is telling you about a file, called core, that has just been written in your current directory. This is a dump of everything on the stack and in the heap at the time the program was running. With the help of a debugger, you can use the core dump to find where the bad pointer was used.

That might not tell you why the pointer was bad, but it’s a step in the right direction. If you don’t have write permission in the current directory, you won’t get a core file, or the core dumped message.

33.What are storage class in c

Answer
There r of 4 type of storage class in C

static

auto

register

extern

34.Following declarations are different from one another
const char *const s;
char const *const s;

Answer
There is no difference between the two declarations.

35.When should a type cast be used?

There are two situations in which to use a type cast. The first use is to change the type of an operand to an arithmetic operation so that the operation will be performed properly.

The second case is to cast pointer types to and from void * in order to interface with functions that expect or return void pointers. For example, the following line type casts the return value of the call to malloc() to be a pointer to a foo structure.

struct foo *p = (struct foo *) malloc(sizeof(struct foo));

36.What is a null pointer?

There are times when it’s necessary to have a pointer that doesn’t point to anything. The macro NULL, defined in <stddef.h>, has a value that’s guaranteed to be different from any valid pointer. NULL is a literal zero, possibly cast to void* or char*. Some people, notably C++ programmers, prefer to use 0 rather than NULL.

The null pointer is used in three ways:

1) To stop indirection in a recursive data structure

2) As an error value

3) As a sentinel value

36.What is a const pointer?

There are cases when you need to define a constant pointer to a variable/object; for instance, when taking a function address, or when you want to protect a pointer from unintended modifications such as assignment of new address, pointer arithmetic, etc. In fact, an object’s this is a constpointer. A constant pointer is declared:

37.when should the volatile modifier be used?

The volatile modifier is a directive to the compiler’s optimizer that operations involving this variable should not be optimized in certain ways. There are two special cases in which use of the volatile modifier is desirable. The first case involves memory-mapped hardware (a device such as a graphics adaptor that appears to the computer’s hardware as if it were part of the computer’s memory), and the second involves shared memory (memory used by two or more programs running simultaneously).

Most computers have a set of registers that can be accessed faster than the computer’s main memory. A good compiler will perform a kind of optimization called “redundant load and store removal.” The compiler looks for places in the code where it can either remove an instruction to load data from memory because the value is already in a register, or remove an instruction to store data to memory because the value can stay in a register until it is changed again anyway.

If a variable is a pointer to something other than normal memory, such as memory-mapped ports on a
peripheral, redundant load and store optimizations might be detrimental. For instance, here’s a piece of code that might be used to time some operation:

time_t time_addition(volatile const struct timer *t, int a)
{
int n;
int x;
time_t then;
x = 0;
then = t->value;
for (n = 0; n < 1000; n++)
{
x = x + a;
}
return t->value – then;
}

In this code, the variable t->value is actually a hardware counter that is being incremented as time passes. The function adds the value of a to x 1000 times, and it returns the amount the timer was incremented by while the 1000 additions were being performed. Without the volatile modifier, a clever optimizer might assume that the value of t does not change during the execution of the function, because there is no statement that explicitly changes it. In that case, there’s no need to read it from memory a second time and subtract it, because the answer will always be 0. The compiler might therefore “optimize” the function by making it always return 0.

If a variable points to data in shared memory, you also don’t want the compiler to perform redundant load and store optimizations. Shared memory is normally used to enable two programs to communicate with each other by having one program store data in the shared portion of memory and the other program read the same portion of memory. If the compiler optimizes away a load or store of shared memory, communication between the two programs will be affected.

38.What is the benefit of using an enum rather than a #define constant?

The use of an enumeration constant (enum) has many advantages over using the traditional symbolic constant style of #define. These advantages include a lower maintenance requirement, improved program readability, and better debugging capability.

1) The first advantage is that enumerated constants are generated automatically by the compiler. Conversely, symbolic constants must be manually assigned values by the programmer.

For instance, if you had an enumerated constant type for error codes that could occur in your program, your enum definition could look something like this:

enum Error_Code
{
OUT_OF_MEMORY,
INSUFFICIENT_DISK_SPACE,
LOGIC_ERROR,
FILE_NOT_FOUND
};

In the preceding example, OUT_OF_MEMORY is automatically assigned the value of 0 (zero) by the compiler because it appears first in the definition. The compiler then continues to automatically assign numbers to the enumerated constants, making INSUFFICIENT_DISK_SPACE equal to 1, LOGIC_ERROR equal to 2, and FILE_NOT_FOUND equal to 3, so on.

If you were to approach the same example by using symbolic constants, your code would look something like this:

#define OUT_OF_MEMORY 0
#define INSUFFICIENT_DISK_SPACE 1
#define LOGIC_ERROR 2
#define FILE_NOT_FOUND 3

values by the programmer. Each of the two methods arrives at the same result: four constants assigned numeric values to represent error codes. Consider the maintenance required, however, if you were to add two constants to represent the error codes DRIVE_NOT_READY and CORRUPT_FILE. Using the enumeration constant method, you simply would put these two constants anywhere in the enum definition. The compiler would generate two unique values for these constants. Using the symbolic constant method, you would have to manually assign two new numbers to these constants. Additionally, you would want to ensure that the numbers you assign to these constants are unique.

2) Another advantage of using the enumeration constant method is that your programs are more readable and thus can be understood better by others who might have to update your program later.

3) A third advantage to using enumeration constants is that some symbolic debuggers can print the value of an enumeration constant. Conversely, most symbolic debuggers cannot print the value of a symbolic constant. This can be an enormous help in debugging your program, because if your program is stopped at a line that uses an enum, you can simply inspect that constant and instantly know its value. On the other hand, because most debuggers cannot print #define values, you would most likely have to search for that value by manually looking it up in a header file.

39.When is a switch statement better than multiple if statements?

The switch statement is better than multiple if statements when there are more than two alternatives to be selected whether the case value matches to the variable of either character or integer type.

40.What is the difference between a string copy (strcpy) and a memory copy (memcpy)? When should each be used?
The strcpy() function is designed to work exclusively with strings. It copies each byte of the source string to the destination string and stops when the terminating null character () has been moved. On the other hand, the memcpy() function is designed to work with any type of data. Because not all data ends with a null character, you must provide the memcpy() function with the number of bytes you want to copy from the source to the destination.

41.How can I convert a string to a number?

The standard C library provides several functions for converting strings to numbers of all formats (integers, longs, floats, and so on) and vice versa.

The following functions can be used to convert strings to numbers:

Function Name Purpose

atof() Converts a string to a double-precision floating-point value.

atoi() Converts a string to an integer.

atol() Converts a string to a long integer.

strtod() Converts a string to a double-precision floating-point value and reports any “leftover” numbers that could not be converted.

strtol() Converts a string to a long integer and reports any “leftover” numbers that could not be converted.

strtoul() Converts a string to an unsigned long integer and reports any “leftover” numbers that could not be converted.

41.How can I convert a number to a string?

The standard C library provides several functions for converting numbers of all formats (integers, longs, floats, and so on) to strings and vice versa The following functions can be used to convert integers to strings:

Function Name Purpose

itoa() Converts an integer value to a string.

ltoa() Converts a long integer value to a string.

ultoa() Converts an unsigned long integer value to a string.

The following functions can be used to convert floating-point values to strings:

Function Name Purpose

ecvt() Converts a double-precision floating-point value to a string without an embedded decimal point.

fcvt() Same as ecvt(), but forces the precision to a specified number of digits.

gcvt() Converts a double-precision floating-point value to a string with an embedded decimal point.

42.Is it possible to execute code even after the program exits the main() function?

The standard C library provides a function named atexit() that can be used to perform “cleanup” operations when your program terminates. You can set up a set of functions you want to perform automatically when your program exits by passing function pointers to the atexit() function.

What is the stack?
The stack is where all the functions’ local (auto) variables are created. The stack also contains some
information used to call and return from functions.

A “stack trace” is a list of which functions have been called, based on this information. When you start using a debugger, one of the first things you should learn is how to get a stack trace.

The stack is very inflexible about allocating memory; everything must be deallocated in exactly the reverse order it was allocated in. For implementing function calls, that is all that’s needed. Allocating memory off the stack is extremely efficient. One of the reasons C compilers generate such good code is their heavy use of a simple stack.

There used to be a C function that any programmer could use for allocating memory off the stack. The
memory was automatically deallocated when the calling function returned. This was a dangerous function to call; it’s not available anymore.

How do you print an address?
The safest way is to use printf() (or fprintf() or sprintf()) with the %P specification. That prints a void
pointer (void*). Different compilers might print a pointer with different formats. Your compiler will pick
a format that’s right for your environment.

If you have some other kind of pointer (not a void*) and you want to be very safe, cast the pointer to a void*:

printf( “%Pn”, (void*) buffer );

45.When should the register modifier be used? Does it really help?

The register modifier hints to the compiler that the variable will be heavily used and should be kept in the CPU’s registers, if possible, so that it can be accessed faster.

There are several restrictions on the use of the register modifier.

First, the variable must be of a type that can be held in the CPU’s register. This usually means a single value of a size less than or equal to the size of an integer. Some machines have registers that can hold floating-point numbers as well.

Second, because the variable might not be stored in memory, its address cannot be taken with the unary & operator. An attempt to do so is flagged as an error by the compiler. Some additional rules affect how useful the register modifier is. Because the number of registers is limited, and because some registers can hold only certain types of data (such as pointers or floating-point numbers), the number and types of register modifiers that will actually have any effect are dependent on what machine the
program will run on. Any additional register modifiers are silently ignored by the compiler.

Also, in some cases, it might actually be slower to keep a variable in a register because that register
then becomes unavailable for other purposes or because the variable isn’t used enough to justify the overhead of loading and storing it.

So when should the register modifier be used? The answer is never, with most modern compilers. Early C compilers did not keep any variables in registers unless directed to do so, and the register modifier was a valuable addition to the language. C compiler design has advanced to the point, however, where the compiler will usually make better decisions than the programmer about which variables should be stored in registers.

In fact, many compilers actually ignore the register modifier, which is perfectly legal, because it is only a hint and not a directive.

46.Can a file other than a .h file be included with #include?

The preprocessor will include whatever file you specify in your #include statement. Therefore, if you have the line

#include <macros.inc>

in your program, the file macros.inc will be included in your precompiled program. It is, however, unusual programming practice to put any file that does not have a .h or .hpp extension in an #include statement.

You should always put a .h extension on any of your C files you are going to include. This method makes it easier for you and others to identify which files are being used for preprocessing purposes. For instance, someone modifying or debugging your program might not know to look at the macros.inc file for macro definitions. That person might try in vain by searching all files with .h extensions and come up empty. If your file had been named macros.h, the search would have included the macros.h file, and the searcher would have been able to see what macros you defined in it.

47.What is Preprocessor?

The preprocessor is used to modify your program according to the preprocessor directives in your source code. Preprocessor directives (such as #define) give the preprocessor specific instructions on how to modify your source code. The preprocessor reads in all of your include files and the source code you are compiling and creates a preprocessed version of your source code. This preprocessed version has all of its macros and constant symbols replaced by their corresponding code and value assignments. If your source code contains any conditional preprocessor directives (such as #if), the preprocessor evaluates the condition and modifies your source code accordingly.

The preprocessor contains many features that are powerful to use, such as creating macros, performing conditional compilation, inserting predefined environment variables into your code, and turning compiler features on and off. For the professional programmer, in-depth knowledge of the features of the preprocessor can be one of the keys to creating fast, efficient programs.

48.How can you restore a redirected standard stream?
The preceding example showed how you can redirect a standard stream from within your program. But what if later in your program you wanted to restore the standard stream to its original state? By using the standard C library functions named dup() and fdopen(), you can restore a standard stream such as stdout to its original state.

The dup() function duplicates a file handle. You can use the dup() function to save the file handle
corresponding to the stdout standard stream. The fdopen() function opens a stream that has been
duplicated with the dup() function.

53.What is the heap?
The heap is where malloc(), calloc(), and realloc() get memory.

Getting memory from the heap is much slower than getting it from the stack. On the other hand, the heap is much more flexible than the stack. Memory can be allocated at any time and deallocated in any order. Such memory isn’t deallocated automatically; you have to call free().

Recursive data structures are almost always implemented with memory from the heap. Strings often come from there too, especially strings that could be very long at runtime. If you can keep data in a local variable (and allocate it from the stack), your code will run faster than if you put the data on the heap. Sometimes you can use a better algorithm if you use the heap—faster, or more robust, or more flexible. It’s a tradeoff.

If memory is allocated from the heap, it’s available until the program ends. That’s great if you remember to deallocate it when you’re done. If you forget, it’s a problem. A “memory leak” is some allocated memory that’s no longer needed but isn’t deallocated. If you have a memory leak inside a loop, you can use up all the memory on the heap and not be able to get any more. (When that happens, the allocation functions return a null pointer.) In some environments, if a program doesn’t deallocate everything it allocated, memory stays unavailable even after the program ends.

54.How do you use a pointer to a function?

The hardest part about using a pointer-to-function is declaring it.

Consider an example. You want to create a pointer, pf, that points to the strcmp() function.

The strcmp() function is declared in this way:

int strcmp(const char *, const char * )

To set up pf to point to the strcmp() function, you want a declaration that looks just like the strcmp() function’s declaration, but that has *pf rather than strcmp:

int (*pf)( const char *, const char * );

After you’ve gotten the declaration of pf, you can #include <string.h> and assign the address of strcmp() to pf: pf = strcmp;

55.What is the purpose of realloc( )?
The function realloc(ptr,n) uses two arguments.the first argument ptr is a pointer to a block of memory for which the size is to be altered.The second argument n specifies the
new size.The size may be increased or decreased.If n is greater than the old size and if sufficient space is not available subsequent to the old region, the function realloc( )
may create a new region and all the old data are moved to the new region.

56.What is the purpose of main( ) function?

The function main( ) invokes other functions within it.It is the first function to be called when the program starts execution.

- It is the starting function

- It returns an int value to the environment that called the program

- Recursive call is allowed for main( ) also.

- It is a user-defined function

- Program execution ends when the closing brace of the function main( ) is reached.

- It has two arguments 1)argument count and 2) argument vector (represents strings passed).

- Any user-defined name can also be used as parameters for main( ) instead of argc and argv

* more here ]]> http://www.freequestionbank.com/question/c-interview-questions/feed/ 0 http://www.freequestionbank.com/question/interview/html-interview-questions/ http://www.freequestionbank.com/question/interview/html-interview-questions/#comments Tue, 24 Mar 2009 03:20:59 +0000 admin http://www.freequestionbank.com/?p=368 1. How do I indent the first line in my paragraphs?
This isn’t really possible in a reliable way, until style sheets are more widely supported. At this moment, there are several browser-specific kludges and tricks available, but these are not guaranteed to work.

1) Use a number of   ( ) characters. Netscape and related browsers do not collapse these, like normal spaces, so this appears as an indent in these browsers. Other browsers can display it as one space.

2) Put a DD at the beginning of the line. This is syntactically invalid, but Netscape works around this by indenting the line at this ball. Of course, other browsers will handle this differently, and there is no guarantee that Netscape will keep doing this.
3) Use a blank, transparent GIF, using WIDTH and HEIGHT to indicate the desired white space. This is a very ugly solution, as it only works if you have image loading on, otherwise you get the “Image” icon at the beginning of the line. Not all browsers support resizing using these attributes, and you can only “indent” a certain number of pixels, not characters. So the amount of “indentation” varies with the font size used to display your document.

2. How do I indent a lot of text?
Again, there is no reliable way to do this. Netscape will indent text inside a , but other browsers don’t have to do this. These could show the text in italics, or perhaps with quotation marks around the text. This could come out very strange.
An alternative is to use DL without DT and DD, which is invalid HTML, but several browsers work around this error by indenting the text inside it. This is not guaranteed to work.

If you are willing to use tables for layout purposes, there is another option. Create a one-cell table, as follows:

A drawback to this solution is that very long blocks inside a table may take a while to download and may not appear until the entire table has been downloaded. Another drawback is that it may force users to resize their viewing window after they have become accustomed to their preferred settings.
3. Can I put markup in ALT text?
No. Character entities (©, &#nnn; and such) are permitted, though.

If you want to know how to write good ALT texts without markup, please see Alan Flavell’s essay on choosing ALT texts.

4. How do I include one file in another?
Use server-side includes, if your server supports them. Ask your Webmaster if this is the case, and if so, what the exact syntax is for your server.
Since server-side includes make the document slower, they are not always desirable. If your documents only have a static footer, which doesn’t change every day, you might be better off by using an editor which can insert files in the current document, or a preprocessor. The C preprocessor can do this, but there are also several HTML-specific preprocessors available.

5. How do I get scrolling text in the status bar?
This is not an HTML question, it’s done with a Javascript. Check any page which has this feature, and copy the script from the source.

This script has two big problems. One, usually it uses the decrement operator (c–) at some ball. The “–” sequence in a comment actually closes it on some browsers, so your code may “leak” on those browsers. The same goes for “>”.

Second, keep in mind that many people consider this even worse than , and that it also suppresses the status information which normally appears there. It prevents people from knowing where a link goes to.

6. How do I hide my source?
You can’t. The source is necessary for the browser to display your document. You have to send the complete, unencrypted source to the browser. Even if a particular browser doesn’t have a “View source” option, there are many that do, and you can always retrieve the document by hand (using telnet) to get its source. Or check the browser’s cache.
You can of course put a few hundred empty lines above the actual source, then newbies who don’t see the scrollbars will think there is nothing there.
7. How can I make a custom rule, or a list with custom bullets?
There was a proposal in the now-expired HTML 3 draft to handle exactly this: just add SRC to the HR or UL tag, indicating where the image can be found. But until this is more widely supported, you have to use IMG for the rule, with a lot of “–” characters as ALT text for text browsers, and using a DL with only DD tags for each item. Make sure you use ALIGN for the image, which should go at the beginning of the item, of course. This isn’t as beautiful as a “real” list.
An alternative is using a two column table, with the bullets in the left column, and the text in the right. But this won’t work well on non-table supporting browsers.

8. How do I display the current date or time in my document?
With server-side includes. Ask your webmaster if this is supported, and what the exact syntax is for your server. But this will display the local time on the server, not for the client. And if the document is cached, the date will of course be incorrect after some time.
JavaScript can be used to display the local time for the client, but as most people already have one or more clocks on their screen, why display another one?

9. For what screen size should I write?
HTML does not depend on screen size. The text will be wrapped by the browser when the end of the screen is encountered. The only exception to this is when you use -formatted text, which will only wrap at the line breaks you indicate. So make sure these lines are no longer than 70 characters, otherwise text mode users will see ugly line breaks on their terminals. And users of graphical browsers might have to scroll horizontally to see the rest, which is one of the most hated things to do when you read a document.

Of course, an image cannot be wrapped, so you have to be careful with that. It seems that 400 or 500 pixels is a reasonable width; anything above 600 will mean a certain percentage of users will have to scroll to see the rightmost bit. This percentage increases with your image width. Keep in mind that not everyone runs his browser at full screen!

10. How do I get my visitor’s e-mail addresses?
You can’t. Although each request for a document is usually logged with the name or address of the remote host, the actual username is almost never logged as well. This is mostly because of performance reasons, as it would require that the server uses the ident protocol to see who is on the other end. This takes time. And if a cache proxy is doing the request, you don’t get anything sensible.
In Netscape 2.0, it was possible to automatically submit a form with a mailto as action, using Javascript. This would send e-mail to the document’s owner, with the address the visitor configured in the From line. Of course, that can be “mickey.mouse@disney.com”. This is fixed in Netscape 2.01.
The most reliable way is to put up a form, asking the visitor to fill in his e-mail address. If you offer him something in return, he will most likely do it.

11. How do I do a pagebreak?
You don’t. HTML is not a page layout language. It’s up to the browser to decide where and how to insert page breaks when the document is being printed.

However, style sheets (not widely supported yet, although Microsoft’s Internet Explorer is beginning to use it) will include support to indicate preferred balls for page breaks, probably somewhat like the way LaTeX handles this.

12. How do I make a table which looks good on AOL and Prodigy?
The best way is probably to include a version in preformatted text. This can be seen by any browser, including Lynx.

If you absolutely must have a table, check out Alan Flavell’s document on tables for a good discussion.

13. How do I center a table?
The “correct” way of doing it is TABLE ALIGN=CENTER, but this doesn’t work in several popular browsers. Put CENTER around the entire table for these browsers.

This causes some problems with browser that do support CENTER but not tables, such as Lynx. In these browsers, the contents of the cells is now displayed centered, which is not what is intended. To avoid this, you can put the cell’s contents in P ALIGN=left or DIV ALIGN=left depending on the amount of text in the cell.

14. How do I make animated GIFs?
Ask on the comp.infosystems.www.authoring.images group.

15. Is there a way to get indexed better by the search engines?
Yes. Put these two statements in the HEAD part of your documents:

Both may contain up to 1022 characters. If a keyword is used more than 7 times the keywords tag will be ignored altogether. Also, you can’t put markup (other than entities) in the description or keywords list. Infoseek and Alta Vista are using this.

16. How do I redirect someone to my new page?
The most reliable way is to configure the server to send out a redirection instruction when the old URL is requested. Then the browser will automatically get the new URL. This is the fastest way to do this. You can of course also simply put up a small page with a text like “This page has moved to http://new.url/, please adjust your bookmarks”.

A Netscape-only solution, which doesn’t work on other browsers, and screws up the “back” button in Netscape, is

META HTTP-EQUIV=”Refresh” CONTENT=”x; URL=new.URL”

which will load the new URL after x seconds. This should go in the HEAD of the document. But if you do this, also include a short text saying “Document moved to new URL so-and-so” for other browsers.

(The screwing-up bit refers to the fact that if you press “Back” after you have been redirected, you will be taken to the document with the META refresh. Then the refresh will be activated, and so you’ll jump to the page you just tried to leave.)

17. How do I get a back button on my page?
In HTML, this is impossible. Going “back” means that you go to the previous page in your history. You might be able to create a link to the URL specified in the “HTTP_REFERER” environment variable in your document, but that only creates a link to a new location in your history. Even worse, the information in that variable can be plain wrong. Some browsers incorrectly send the variable when you use a bookmark or type in an URL manually, and some don’t send that variable at all. Then you would end up with an empty link.
A JavaScript could use “history.back()” to do this, but this only works in Netscape 2.

18. How do I force a download?
You can’t. When someone downloads a document, the server tells the browser what type of file it is. The browser then picks the appropriate helper application, or displays it himself. If the server doesn’t know the file type, it tells the browser that the file is “text/plain”, or just plain text. You will have to ask your server admin to configure this particular file with the MIME type you want.

“Forcing” a download is not what you are supposed to do. After all, what is more convenient than having the proper application started when I download a particular file? Browsing through a download directory can be quite a pain. And most browsers allow the user to download to disk if they want to.

If the file must be saved to disk, as there is absolutely NO other way to handle it, the MIME type should be “application/octet-stream”.

19. Why is my binary file not downloaded, but shown on the screen?
Actually, the browser has downloaded the document, it is just treating it as a plain text file. This is because the server said it was a plain text file. To get the file in the helper application (or plug-in), you will have to configure the server to send out the right MIME type, and the browser to start the appropriate helper application for files with that MIME type.

20. How do I use an image instead of the standard submit button?
Use INPUT NAME=foo TYPE=image SRC=”http://url.to/image.gif” instead of the normal submit tag. There is no way to do this for the reset button.

Note that some browsers will also send the x and y coordinates of the location where the user clicked on the image to the server. They are available as “foo.x=000&foo.y=000″ in the CGI input.

21. How do I get a so-and-so character in my HTML?
HTML text is supposed to be written in the ISO Latin-1 character set. A complete overview of all the characters in this set is available from:

o http://www.w3.org/pub/WWW/MarkUp/html3/latin1.html

o http://ppewww.ph.gla.ac.uk/%7Eflavell/iso8859/

o http://uts.cc.utexas.edu/%7Echurchh/latin1.html

22. How do I get a counter?
Either ask your Webmaster for access to the log files, or for a server-side include which can do this, or use one of the freeware counters available at the CGI archives. There is no HTML tag to do this.
Counters are quite ball less, though. They can be set to any value the owner wants, so they don’t give you any information. Because of the delay that often occurs when using an external counter, your visitors may get annoyed with the long loading time of your document. The server’s log file provides a lot more reliable information for you, and you don’t have to bother your readers with it.

23. How do I detect what browser is being used?
Many browsers identify themselves when they request a document. A CGI script will have this information available in the HTTP_USER_AGENT environment variable, and it can use that to send out a version of the document which is optimized for that browser.
Keep in mind not all browsers identify themselves correctly. Microsoft Internet Explorer, for example, claims to be “Mozilla 1.2″ to get at Netscape enhanced documents.
And of course, if a cache proxy keeps the Netscape enhanced document, someone with an other browser will also get this document if he goes through the cache.

24. I want to get an audio file to play automatically when someone visits my site!
Bleh. What if I visit your site at 3am, and there’s someone sleeping in the next room?

For Netscape, this is done using the EMBED tag. You can also do this with the Netscape META refresh tag, as described earlier. Just put the URL of the audio file in the CONTENT field.

There is also a MS Internet Explorer specific tag to do this: BGSOUND SRC=URL which plays the file specified in the SRC attribute automatically. You can add LOOP followed by a value or the keyword “INFINITE” to indicate how many times the sound should be played.

25. Should I put quotes around attribute values or not?
It depends. It is never wrong to use them, but you don’t have to if the attribute value consists only of letters, digits, periods and/or hyphens. This is explained in the HTML 2.0 specs.
Oh, and keep in mind that if you use double quotes, you should escape any quotes inside the value with “"” so you don’t accidentally terminate the value prematurely.

26. Should I use lower case or upper case for tags?
Tags are case insensitive, so it doesn’t matter. This is just a matter of style. Many people prefer upper case, as it makes the tags “stand out” better amongst the text.

28. My images/hyperlinks are coming out all wrong, or don’t load! What’s up?
Most likely you forgot to close a quote at the end of an HREF or SRC. Alternatively, perhaps you used a “>” character in an ALT text or somewhere else inside a tag. Although this is legal, several older browsers will think the tag ends there, so the rest is displayed as normal text.

This especially happens if you use comment tags to “comment out” text with HTML tags. Although the correct syntax is (without “–” occurring anywhere inside the comment), some browsers will think the comment ends at the first > they see.

29. How do I get a button which takes me to a new page?
This is done with a small form:

If you want to line up buttons next to each other, you will have to put them in a one-row table, with each button in a separate cell.

*more here

These keywords are for allowing privileges to components such as java methods and variables.
Public: accessible to all classes
Private: accessible only to the class to which they belong
Protected: accessible to the class to which they belong and any subclasses.
Access specifiers are keywords that determines the type of access to the member of a class. These are:
* Public
* Protected
* Private
* Defaults

2. What’s the difference between an interface and an abstract class? Also discuss the similarities. (Very Important)

Abstract class is a class which contain one or more abstract methods, which has to be implemented by sub classes. Interface is a Java Object containing method declaration and doesn’t contain implementation. The classes which have implementing the Interfaces must provide the method definition for all the methods
Abstract class is a Class prefix with a abstract keyword followed by Class definition. Interface is a Interface which starts with interface keyword.
Abstract class contains one or more abstract methods. where as Interface contains all abstract methods and final declarations
Abstract classes are useful in a situation that Some general methods should be implemented and specialization behavior should be implemented by child classes. Interfaces are useful in a situation that all properties should be implemented.

Differences are as follows:

* Interfaces provide a form of multiple inheritance. A class can extend only one other class.
* Interfaces are limited to public methods and constants with no implementation. Abstract classes can have a partial implementation, protected parts, static methods, etc.
* A Class may implement several interfaces. But in case of abstract class, a class may extend only one abstract class.
* Interfaces are slow as it requires extra indirection to to find corresponding method in in the actual class. Abstract classes are fast.

Similarities:

* Neither Abstract classes or Interface can be instantiated.

How to define an Abstract class?
A class containing abstract method is called Abstract class. An Abstract class can’t be instantiated.
Example of Abstract class:

abstract class testAbstractClass {
protected String myString;
public String getMyString() {
return myString;
}
public abstract string anyAbstractFunction();
}

How to define an Interface?
Answer: In Java Interface defines the methods but does not implement them. Interface can include constants. A class that implements the interfaces is bound to implement all the methods defined in Interface.
Example of Interface:

public interface sampleInterface {
public void functionOne();
public long CONSTANT_ONE = 1000;
}

3. Question: How you can force the garbage collection?

Garbage collection automatic process and can’t be forced. You could request it by calling System.gc(). JVM does not guarantee that GC will be started immediately.

Garbage collection is one of the most important feature of Java, Garbage collection is also called automatic memory management as JVM automatically removes the unused variables/objects (value is null) from the memory. User program can’t directly free the object from memory, instead it is the job of the garbage collector to automatically free the objects that are no longer referenced by a program. Every class inherits finalize() method from java.lang.Object, the finalize() method is called by garbage collector when it determines no more references to the object exists. In Java, it is good idea to explicitly assign null into a variable when no more in use. I Java on calling System.gc() and Runtime.gc(), JVM tries to recycle the unused objects, but there is no guarantee when all the objects will garbage collected.

4. What’s the difference between constructors and normal methods?

Constructors must have the same name as the class and can not return a value. They are only called once while regular methods could be called many times and it can return a value or can be void.

5. Can you call one constructor from another if a class has multiple constructors

Yes. Use this() to call a constructor from an other constructor.

6. Explain the usage of Java packages.

This is a way to organize files when a project consists of multiple modules. It also helps resolve naming conflicts when different packages have classes with the same names. Packages access level also allows you to protect data from being used by the non-authorized classes.

7. Explain in your own words the “bottom line” benefits of the use of an interface.

The interface makes it possible for a method in one class to invoke methods on objects of other classes, without the requirement to know the true class of those objects, provided that those objects are all instantiated from classes that implement one or more specified interfaces. In other words, objects of classes that implement specified interfaces can be passed into methods of other objects as the generic type Object, and the methods of the other objects can invoke methods on the incoming objects by first casting them as the interface type.

8. What are some advantages and disadvantages of Java Sockets?

Some advantages of Java Sockets:
Sockets are flexible and sufficient. Efficient socket based programming can be easily implemented for general communications. Sockets cause low network traffic. Unlike HTML forms and CGI scripts that generate and transfer whole web pages for each new request, Java applets can send only necessary updated information.

Some disadvantages of Java Sockets:
Security restrictions are sometimes overbearing because a Java applet running in a Web browser is only able to establish connections to the machine where it came from, and to nowhere else on the network Despite all of the useful and helpful Java features, Socket based communications allows only to send packets of raw data between applications. Both the client-side and server-side have to provide mechanisms to make the data useful in any way.

9. Explain the usage of the keyword transient?

Transient keyword indicates that the value of this member variable does not have to be serialized with the object. When the class will be de-serialized, this variable will be initialized with a default value of its data type (i.e. zero for integers).

10. What’s the difference between the methods sleep() and wait()

The code sleep(1000); puts thread aside for exactly one second. The code wait(1000), causes a wait of up to one second. A thread could stop waiting earlier if it receives the notify() or notifyAll() call. The method wait() is defined in the class Object and the method sleep() is defined in the class Thread.

11. What would you use to compare two String variables – the operator == or the method equals()?

I’d use the method equals() to compare the values of the Strings and the == to check if two variables point at the same instance of a String object.

12. Why would you use a synchronized block vs. synchronized method?

Synchronized blocks place locks for shorter periods than synchronized methods.

13. What access level do you need to specify in the class declaration to ensure that only classes from the same directory can access it?

You do not need to specify any access level, and Java will use a default package access level.

14. Can an inner class declared inside of a method access local variables of this method?

It’s possible if these variables are final.

15. What can go wrong if you replace && with & in the following code:
String a=null; if (a!=null && a.length()>10) {…}

A single ampersand here would lead to a NullPointerException.

16. What’s the main difference between a Vector and an ArrayList?

Java Vector class is internally synchronized and ArrayList is not synchronized.

17. Describe the wrapper classes in Java.

Wrapper class is wrapper around a primitive data type. An instance of a wrapper class contains, or wraps, a primitive value of the corresponding type.

Following table lists the primitive types and the corresponding wrapper classes:
Primitive Wrapper
boolean – java.lang.Boolean
byte – java.lang.Byte
char – java.lang.Character
double – java.lang.Double
float – java.lang.Float
int – java.lang.Integer
long – java.lang.Long
short – java.lang.Short
void – java.lang.Void

18. How could Java classes direct program messages to the system console, but error messages, say to a file?

The class System has a variable out that represents the standard output, and the variable err that represents the standard error device. By default, they both point at the system console. This how the standard output could be re-directed:
Stream st = new Stream(new FileOutputStream(“output.txt”)); System.setErr(st); System.setOut(st);

19. How do you know if an explicit object casting is needed?

If you assign a superclass object to a variable of a subclass’s data type, you need to do explicit casting. For example:
Object a; Customer b; b = (Customer) a;

20. When you assign a subclass to a variable having a supeclass type, the casting is performed automatically. Can you write a Java class that could be used both as an applet as well as an application?

Yes. Add a main() method to the applet.

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.

31. If you’re overriding the method equals() of an object, which other method you might also consider?

hashCode()

32. What is Collection API?

The Collection API is a set of classes and interfaces that support operation on collections of objects. These classes and interfaces are more flexible, more powerful, and more regular than the vectors, arrays, and hashtables if effectively replaces.
Example of classes: HashSet, HashMap, ArrayList, LinkedList, TreeSet and TreeMap.
Example of interfaces: Collection, Set, List and Map.

33. How would you make a copy of an entire Java object with its state?

Have this class implement Cloneable interface and call its method clone().

34. How can you minimize the need of garbage collection and make the memory use more effective?

Use object pooling and weak object references.

35. There are two classes: A and B. The class B need to inform a class A when some important event has happened. What Java technique would you use to implement it?

If these classes are threads I’d consider notify() or notifyAll(). For regular classes you can use the Observer interface.

36. Explain the Encapsulation principle.

Encapsulation is a process of binding or wrapping the data and the codes that operates on the data into a single entity. This keeps the data safe from outside interface and misuse. One way to think about encapsulation is as a protective wrapper that prevents code and data from being arbitrarily accessed by other code defined outside the wrapper.

37. Explain the Inheritance principle.

Inheritance is the process by which one object acquires the properties of another object.

38. Explain the Polymorphism principle.

The meaning of Polymorphism is something like one name many forms. Polymorphism enables one entity to be used as as general category for different types of actions. The specific action is determined by the exact nature of the situation. The concept of polymorphism can be explained as “one interface, multiple methods”.
From a practical programming viewpoint, polymorphism exists in three distinct forms in Java:

* Method overloading
* Method overriding through inheritance
* Method overriding through the Java interface

39. Is Iterator a Class or Interface? What is its use?

Iterator is an interface which is used to step through the elements of a Collection.

40. Explain the user defined Exceptions?

User defined Exceptions are the separate Exception classes defined by the user for specific purposed. An user defined can created by simply sub-classing it to the Exception class. This allows custom exceptions to be generated (using throw) and caught in the same way as normal exceptions.
Example:

class myCustomException extends Exception {
/ The class simply has to exist to be an exception
}

41. What is OOPS?

OOP is the common abbreviation for Object-Oriented Programming.
There are three main principals of oops which are called Polymorphism, Inheritance and Encapsulation.

39. Read the following program:

public class test {
public static void main(String [] args) {
int x = 3;
int y = 1;
if (x = y)
System.out.println(“Not equal”);
else
System.out.println(“Equal”);
}
}

What is the result?
The output is “Equal”
B. The output in “Not Equal”
C. An error at ” if (x = y)” causes compilation to fall.
D. The program executes but no output is show on console.
Answer: C
Answer: Transient variable can’t be serialize. For example if a variable is declared as transient in a Serializable class and the class is written to an ObjectStream, the value of the variable can’t be written to the stream instead when the class is retrieved from the ObjectStream the value of the variable becomes null.

*more here

* 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′;
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.
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.
Unary Numeric Promotion

Contexts:

· Operand of the unary arithmetic operators + and -

· Operand of the unary integer bit-wise complement operator ~

· During array creation, for example new int[x], where the dimension expression x must evaluate to an int value.

· Indexing array elements, for example table['a'], where the index expression must evaluate to an int value.

· Individual operands of the shift operators.

Binary numeric promotion

Contexts:

· Operands of arithmetic operators *, / , %, + and -

· Operands of relational operators <, <= , > and >=

· Numeric Operands of equality operators == and !=

· Integer Operands of bit-wise operators &, ^ and |

Conversion of Primitives
1. 3 types of conversion – assignment conversion, method call conversion and arithmetic promotion

2. boolean may not be converted to/from any non-boolean type.

3. Widening conversions accepted. Narrowing conversions rejected.

4. byte, short can’t be converted to char and vice versa. ( but can be cast )

5. Arithmetic promotion

5.1 Unary operators

· if the operand is byte, short or char {

convert it to int;

}

else {

do nothing; no conversion needed;

}

5.2 Binary operators

· if one operand is double {

all double; convert the other operand to double;

}

else if one operand is float {

all float; convert the other operand to float;

}

else if one operand is long {

all long; convert the other operand to long;

}

else {

all int; convert all to int;

}

6. When assigning a literal value to a variable, the range of the variable’s data type is checked against the value of the literal and assignment is allowed or compiler will produce an error.

char c = 3; // this will compile, even though a numeric literal is by default an int since the range of char will accept the value

int a = 3;

char d = a; // this won’t compile, since we’re assigning an int to char

char e = -1; // this also won’t compile, since the value is not in the range of char

float f = 1.3; // this won’t compile, even though the value is within float range. Here range is not important, but precision is. 1.3 is by default a double, so a specific cast or f = 1.3f will work.

float f = 1/3; // this will compile, since RHS evaluates to an int.

Float f = 1.0 / 3.0; // this won’t compile, since RHS evaluates to a double.

7. Also when assigning a final variable to a variable, even if the final variable’s data type is wider than the variable, if the value is within the range of the variable an implicit conversion is done.

byte b;

final int a = 10;

b = a; // Legal, since value of ‘a’ is determinable and within range of b

final int x = a;

b = x; // Legal, since value of ‘x’ is determinable and within range of b

int y;

final int z = y;

b = z; // Illegal, since value of ‘z’ is not determinable

8. Method call conversions always look for the exact data type or a wider one in the method signatures. They will not do narrowing conversions to resolve methods, instead we will get a compile error.

Here is the figure of allowable primitive conversion.

byte à short à int à long à float à double

­

char

Casting of Primitives

9. Needed with narrowing conversions. Use with care – radical information loss. Also can be used with widening conversions, to improve the clarity of the code.

10. Can cast any non-boolean type to another non-boolean type.

11. Cannot cast a boolean or to a boolean type.

Conversion of Object references

12. Three types of reference variables to denote objects – class, interface or array type.

13. Two kinds of objects can be created – class or array.

14. Two types of conversion – assignment and method call.

15. Permitted if the direction of the conversion is ‘up’ the inheritance hierarchy. Means that types can be assigned/substituted to only super-types – super-classes or interfaces. Not the other way around, explicit casting is needed for that.

16. Interfaces can be used as types when declaring variables, so they participate in the object reference conversion. But we cannot instantiate an interface, since it is abstract and doesn’t provide any implementation. These variables can be used to hold objects of classes that implement the interface. The reason for having interfaces as types may be, I think, several unrelated classes may implement the same interface and if there’s a need to deal with them collectively one way of treating them may be an array of the interface type that they implement.

17. Primitive arrays can be converted to only the arrays of the same primitive type. They cannot be converted to another type of primitive array. Only object reference arrays can be converted / cast.

18. Primitive arrays can be converted to an Object reference, but not to an Object[] reference. This is because all arrays (primitive arrays and Object[]) are extended from Object.

Casting of Object references

19. Allows super-types to be assigned to subtypes. Extensive checks done both at compile and runtime. At compile time, class of the object may not be known, so at runtime if checks fail, a ClassCastException is thrown.

20. Cast operator, instanceof operator and the == operator behave the same way in allowing references to be the operands of them. You cannot cast or apply instanceof or compare unrelated references, sibling references or any incompatible references.

Compile-time Rules

· When old and new types are classes, one class must be the sub-class of the other.

· When old and new types are arrays, both must contain reference types and it must be legal to cast between those types (primitive arrays cannot be cast, conversion possible only between same type of primitive arrays).

· We can always cast between an interface and a non-final object.

Run-time rules

· If new type is a class, the class of the expression being converted must be new type or extend new type.

· If new type is an interface, the class of the expression being converted must implement the interface.

An Object reference can be converted to: (java.lang.Object)

· an Object reference

· a Cloneable interface reference, with casting, with runtime check

· any class reference, with casting, with runtime check

· any array referenece, with casting, with runtime check

· any interface reference, with casting, with runtime check

A Class type reference can be converted to:

· any super-class type reference, (including Object)

· any sub-class type reference, with casting, with runtime check

· an interface reference, if the class implements that interface

· any interface reference, with casting, with runtime check (except if the class is final and doesn’t implement the interface)

An Interface reference can be converted to:

· an Object reference

· a super-interface reference

· any interface/class reference with casting, with runtime check (except if the class is final and doesn’t implement the interface)

A Primitive Array reference can be converted to:

· an Object reference

· a Cloneable interface reference

· a primitive array reference of the same type

An Object Array reference can be converted to:

· an Object reference

· a Cloneable interface reference

· a super-class Array reference, including an Object Array reference

· any sub-class Array reference with casting, with runtime check
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.
Implementing OO relationships

· “is a” relationship is implemented by inheritance (extends keyword)

· “has a” relationship is implemented by providing the class with member variables.

Overloading and Overriding

· Overloading is an example of polymorphism. (operational / parametric)

· Overriding is an example of runtime polymorphism (inclusive)

· A method can have the same name as another method in the same class, provided it forms either a valid overload or override

Overloading :
Signature has to be different. Just a difference in return type is not enough.
Accessibility may vary freely.
Exception list may vary freely.
Just the name is reused. Methods are independent methods. Resolved at compile-time based on method signature.
Can call each other by providing appropriate argument list.
Methods can be static or non-static. Since the methods are independent, it doesn’t matter. But if two methods have the same signature, declaring one as static and another as non-static does not provide a valid overload. It’s a compile time error.
There’s no limit on number of overloaded methods a class can have.
Overriding :
Signature has to be the same. (including the return type)
Overriding methods cannot be more private than the overridden methods.
Overriding methods may not throw more checked exceptions than the overridden methods.
Related directly to sub-classing. Overrides the parent class method. Resolved at run-time based on type of the object.
Overriding method can call overridden method by super.methodName(), this can be used only to access the immediate super-class’s method. super.super won’t work. Also, a class outside the inheritance hierarchy can’t use this technique.
static methods don’t participate in overriding, since they are resolved at compile time based on the type of reference variable. A static method in a sub-class can’t use ’super’ (for the same reason that it can’t use ‘this’ for) Remember that a static method can’t be overridden to be non-static and a non-static method can’t be overridden to be static. In other words, a static method and a non-static method cannot have the same name and signature (if signatures are different, it would have formed a valid overload)
Each parent class method may be overridden at most once in any sub-class. (That is, you cannot have two identical methods in the same class)

· Variables can also be overridden, it’s known as shadowing or hiding. But, member variable references are resolved at compile-time. So at the runtime, if the class of the object referred by a parent class reference variable, is in fact a sub-class having a shadowing member variable, only the parent class variable is accessed, since it’s already resolved at compile time based on the reference variable type. Only methods are resolved at run-time.
· Also, methods access variables only in context of the class of the object they belong to. If a sub-class method calls explicitly a super class method, the super class method always will access the super-class variable. Super class methods will not access the shadowing variables declared in subclasses because they don’t know about them. (When an object is created, instances of all its super-classes are also created.) But the method accessed will be again subject to dynamic lookup. It is always decided at runtime which implementation is called. (Only static methods are resolved at compile-time)
· With OO languages, the class of the object may not be known at compile-time (by virtue of inheritance). JVM from the start is designed to support OO. So, the JVM insures that the method called will be from the real class of the object (not with the variable type declared). This is accomplished by virtual method invocation (late binding). Compiler will form the argument list and produce one method invocation instruction – its job is over. The job of identifying and calling the proper target code is performed by JVM.

· JVM knows about the variable’s real type at any time since when it allocates memory for an object, it also marks the type with it. Objects always know ‘who they are’. This is the basis of instanceof operator.

· Sub-classes can use super keyword to access the shadowed variables in super-classes. This technique allows for accessing only the immediate super-class. super.super is not valid. But casting the ‘this’ reference to classes up above the hierarchy will do the trick. By this way, variables in super-classes above any level can be accessed from a sub-class, since variables are resolved at compile time, when we cast the ‘this’ reference to a super-super-class, the compiler binds the super-super-class variable. But this technique is not possible with methods since methods are resolved always at runtime, and the method gets called depends on the type of object, not the type of reference variable. So it is not at all possible to access a method in a super-super-class from a subclass.
· An inherited method, which was not abstract on the super-class, can be declared abstract in a sub-class (thereby making the sub-class abstract). There is no restriction.

· In the same token, a subclass can be declared abstract regardless of whether the super-class was abstract or not.

· Private members are not inherited, but they do exist in the sub-classes. Since the private methods are not inherited, they cannot be overridden. A method in a subclass with the same signature as a private method in the super-class is essentially a new method, independent from super-class, since the private method in the super-class is not visible in the sub-class.
· Constructors are not inherited as normal methods, they have to be defined in the class itself.

· If you define no constructors at all, then the compiler provides a default constructor with no arguments. Even if, you define one constructor, this default is not provided.

· We can’t compile a sub-class if the immediate super-class doesn’t have a no argument default constructor, and sub-class constructors are not calling super or this explicitly (and expect the compiler to insert an implicit super() call )

· A constructor can call other overloaded constructors by ‘this (arguments)’. If you use this, it must be the first statement in the constructor. This construct can be used only from within a constructor.

· A constructor can’t call the same constructor from within. Compiler will say ‘ recursive constructor invocation’

· A constructor can call the parent class constructor explicitly by using ’super (arguments)’. If you do this, it must be first the statement in the constructor. This construct can be used only from within a constructor.

· Obviously, we can’t use both this and super in the same constructor. If compiler sees a this or super, it won’t insert a default call to super().

· Constructors can’t have a return type. A method with a class name, but with a return type is not considered a constructor, but just a method by compiler. Expect trick questions using this.

· Constructor body can have an empty return statement. Though void cannot be specified with the constructor signature, empty return statement is acceptable.

· Only modifiers that a constructor can have are the accessibility modifiers.

· Constructors cannot be overridden, since they are not inherited.

· Initializers are used in initialization of objects and classes and to define constants in interfaces. These initializers are :

1. Static and Instance variable initializer expressions.

§ Literals and method calls to initialize variables.

§ Static variables can be initialized only by static method calls.

§ Cannot pass on the checked exceptions. Must catch and handle them.

2. Static initializer blocks.

§ Used to initialize static variables and load native libraries.

§ Cannot pass on the checked exceptions. Must catch and handle them.

3. Instance initializer blocks.

§ Used to factor out code that is common to all the constructors.

§ Also useful with anonymous classes since they cannot have constructors.

§ All constructors must declare the uncaught checked exceptions, if any.

§ Instance Initializers in anonymous classes can throw any exception.

· In all the initializers, forward referencing of variables is not allowed. Forward referencing of methods is allowed.

· Order of code execution (when creating an object) is a bit tricky.

1. static variables initialization.

2. static initializer block execution. (in the order of declaration, if multiple blocks found)

3. constructor header ( super or this – implicit or explicit )

4. instance variables initialization / instance initializer block(s) execution

5. rest of the code in the constructor
Interfaces:

· All methods in an interface are implicitly public, abstract, and never static.

· All variables in an interface are implicitly static, public, final. They cannot be transient or volatile. A class can shadow the variables it inherits from an interface, with its own variables.

· A top-level interface itself cannot be declared as static or final since it doesn’t make sense.

· Declaring parameters to be final is at method’s discretion, this is not part of method signature.

· Same case with final, synchronized, native. Classes can declare the methods to be final, synchronized or native whereas in an interface they cannot be specified like that. (These are implementation details, interface need not worry about this)

· But classes cannot implement an interface method with a static method.

· If an interface specifies an exception list for a method, then the class implementing the interface need not declare the method with the exception list. (Overriding methods can specify sub-set of overridden method’s exceptions, here none is a sub-set). But if the interface didn’t specify any exception list for a method, then the class cannot throw any exceptions.

· All interface methods should have public accessibility when implemented in class.

· Interfaces cannot be declared final, since they are implicitly abstract.

· A class can implement two interfaces that have a method with the same signature or variables with the same name.

Inner Classes

· A class can be declared in any scope. Classes defined inside of other classes are known as nested classes. There are four categories of nested classes.

1. Top-level nested classes / interfaces

· Declared as a class member with static modifier.

· Just like other static features of a class. Can be accessed / instantiated without an instance of the outer class. Can access only static members of outer class. Can’t access instance variables or methods.

· Very much like any-other package level class / interface. Provide an extension to packaging by the modified naming scheme at the top level.

· Classes can declare both static and non-static members.

· Any accessibility modifier can be specified.

· Interfaces are implicitly static (static modifier also can be specified). They can have any accessibility modifier. There are no non-static inner, local or anonymous interfaces.

2. Non-static inner classes

· Declared as a class member without static.

· An instance of a non-static inner class can exist only with an instance of its enclosing class. So it always has to be created within a context of an outer instance.

· Just like other non-static features of a class. Can access all the features (even private) of the enclosing outer class. Have an implicit reference to the enclosing instance.

· Cannot have any static members.

· Can have any access modifier.

3. Local classes

· Defined inside a block (could be a method, a constructor, a local block, a static initializer or an instance initializer). Cannot be specified with static modifier.

· Cannot have any access modifier (since they are effectively local to the block)

· Cannot declare any static members.(Even declared in a static context)

· Can access all the features of the enclosing class (because they are defined inside the method of the class) but can access only final variables defined inside the method (including method arguments). This is because the class can outlive the method, but the method local variables will go out of scope – in case of final variables, compiler makes a copy of those variables to be used by the class. (New meaning for final)

· Since the names of local classes are not visible outside the local context, references of these classes cannot be declared outside. So their functionality could be accessed only via super-class references (either interfaces or classes). Objects of those class types are created inside methods and returned as super-class type references to the outside world. This is the reason that they can only access final variables within the local block. That way, the value of the variable can be always made available to the objects returned from the local context to outside world.

· Cannot be specified with static modifier. But if they are declared inside a static context such as a static method or a static initializer, they become static classes. They can only access static members of the enclosing class and local final variables. But this doesn’t mean they cannot access any non-static features inherited from super classes. These features are their own, obtained via the inheritance hierarchy. They can be accessed normally with ‘this’ or ’super’.

4. Anonymous classes

· Anonymous classes are defined where they are constructed. They can be created wherever a reference expression can be used.

· Anonymous classes cannot have explicit constructors. Instance initializers can be used to achieve the functionality of a constructor.

· Typically used for creating objects on the fly.

· Anonymous classes can implement an interface (implicit extension of Object) or explicitly extend a class. Cannot do both.

Syntax: new interface name() { } or new class name() { }

· Keywords implements and extends are not used in anonymous classes.

· Abstract classes can be specified in the creation of an anonymous class. The new class is a concrete class, which automatically extends the abstract class.

· Discussion for local classes on static/non-static context, accessing enclosing variables, and declaring static variables also holds good for anonymous classes. In other words, anonymous classes cannot be specified with static, but based on the context, they could become static classes. In any case, anonymous classes are not allowed to declare static members. Based on the context, non-static/static features of outer classes are available to anonymous classes. Local final variables are always available to them.

· One enclosing class can have multiple instances of inner classes.

· Inner classes can have synchronous methods. But calling those methods obtains the lock for inner object only not the outer object. If you need to synchronize an inner class method based on outer object, outer object lock must be obtained explicitly. Locks on inner object and outer object are independent.

· Nested classes can extend any class or can implement any interface. No restrictions.

· All nested classes (except anonymous classes) can be abstract or final.

· Classes can be nested to any depth. Top-level static classes can be nested only within other static top-level classes or interfaces. Deeply nested classes also have access to all variables of the outer-most enclosing class (as well the immediate enclosing class’s)

· Member inner classes can be forward referenced. Local inner classes cannot be.

· An inner class variable can shadow an outer class variable. In this case, an outer class variable can be referred as (outerclassname.this.variablename).

· Outer class variables are accessible within the inner class, but they are not inherited. They don’t become members of the inner class. This is different from inheritance. (Outer class cannot be referred using ’super’, and outer class variables cannot be accessed using ‘this’)

· An inner class variable can shadow an outer class variable. If the inner class is sub-classed within the same outer class, the variable has to be qualified explicitly in the sub-class. To fully qualify the variable, use classname.this.variablename. If we don’t correctly qualify the variable, a compiler error will occur. (Note that this does not happen in multiple levels of inheritance where an upper-most super-class’s variable is silently shadowed by the most recent super-class variable or in multiple levels of nested inner classes where an inner-most class’s variable silently shadows an outer-most class’s variable. Problem comes only when these two hierarchy chains (inheritance and containment) clash.)

· If the inner class is sub-classed outside of the outer class (only possible with top-level nested classes) explicit qualification is not needed (it becomes regular class inheritance)

· Java is fundamentally multi-threaded.

· Every thread corresponds to an instance of java.lang.Thread class or a sub-class.

· A thread becomes eligible to run, when its start() method is called. Thread scheduler co-ordinates between the threads and allows them to run.

· When a thread begins execution, the scheduler calls its run method.

Signature of run method – public void run ()

· When a thread returns from its run method (or stop method is called – deprecated in 1.2), its dead. It cannot be restarted, but its methods can be called. (it’s just an object no more in a running state)

· If start is called again on a dead thread, IllegalThreadStateException is thrown.

· When a thread is in running state, it may move out of that state for various reasons. When it becomes eligible for execution again, thread scheduler allows it to run.

· There are two ways to implement threads.

1. Extend Thread class

· Create a new class, extending the Thread class.

· Provide a public void run method, otherwise empty run in Thread class will be executed.

· Create an instance of the new class.

· Call start method on the instance (don’t call run – it will be executed on the same thread)

2. Implement Runnable interface

· Create a new class implementing the Runnable interface.

· Provide a public void run method.

· Create an instance of this class.

· Create a Thread, passing the instance as a target – new Thread(object)

· Target should implement Runnable, Thread class implements it, so it can be a target itself.

· Call the start method on the Thread.

· JVM creates one user thread for running a program. This thread is called main thread. The main method of the class is called from the main thread. It dies when the main method ends. If other user threads have been spawned from the main thread, program keeps running even if main thread dies. Basically a program runs until all the user threads (non-daemon threads) are dead.

· A thread can be designated as a daemon thread by calling setDaemon(boolean) method. This method should be called before the thread is started, otherwise IllegalThreadStateException will be thrown.

· A thread spawned by a daemon thread is a daemon thread.

· Threads have priorities. Thread class have constants MAX_PRIORITY (10), MIN_PRIORITY (1), NORM_PRIORITY (5)

· A newly created thread gets its priority from the creating thread. Normally it’ll be NORM_PRIORITY.

· getPriority and setPriority are the methods to deal with priority of threads.

· Java leaves the implementation of thread scheduling to JVM developers. Two types of scheduling can be done.

1. Pre-emptive Scheduling.

Ways for a thread to leave running state -

· It can cease to be ready to execute ( by calling a blocking i/o method)

· It can get pre-empted by a high-priority thread, which becomes ready to execute.

· It can explicitly call a thread-scheduling method such as wait or suspend.

· Solaris JVM’s are pre-emptive.

· Windows JVM’s were pre-emptive until Java 1.0.2

2. Time-sliced or Round Robin Scheduling

· A thread is only allowed to execute for a certain amount of time. After that, it has to contend for the CPU (virtual CPU, JVM) time with other threads.

· This prevents a high-priority thread mono-policing the CPU.

· The drawback with this scheduling is – it creates a non-deterministic system – at any point in time, you cannot tell which thread is running and how long it may continue to run.

· Macintosh JVM’s

· Windows JVM’s after Java 1.0.2

· Different states of a thread:

1. Yielding

· Yield is a static method. Operates on current thread.

· Moves the thread from running to ready state.

· If there are no threads in ready state, the yielded thread may continue execution, otherwise it may have to compete with the other threads to run.

· Run the threads that are doing time-consuming operations with a low priority and call yield periodically from those threads to avoid those threads locking up the CPU.

2. Sleeping

· Sleep is also a static method.

· Sleeps for a certain amount of time. (passing time without doing anything and w/o using CPU)

· Two overloaded versions – one with milliseconds, one with milliseconds and nanoseconds.

· Throws an InterruptedException. (must be caught)

· After the time expires, the sleeping thread goes to ready state. It may not execute immediately after the time expires. If there are other threads in ready state, it may have to compete with those threads to run. The correct statement is the sleeping thread would execute some time after the specified time period has elapsed.

· If interrupt method is invoked on a sleeping thread, the thread moves to ready state. The next time it begins running, it executes the InterruptedException handler.

3. Suspending

· Suspend and resume are instance methods and are deprecated in 1.2

· A thread that receives a suspend call, goes to suspended state and stays there until it receives a resume call on it.

· A thread can suspend it itself, or another thread can suspend it.

· But, a thread can be resumed only by another thread.

· Calling resume on a thread that is not suspended has no effect.

· Compiler won’t warn you if suspend and resume are successive statements, although the thread may not be able to be restarted.

4. Blocking

· Methods that are performing I/O have to wait for some occurrence in the outside world to happen before they can proceed. This behavior is blocking.

· If a method needs to wait an indeterminable amount of time until some I/O takes place, then the thread should graciously step out of the CPU. All Java I/O methods behave this way.

· A thread can also become blocked, if it failed to acquire the lock of a monitor.

5. Waiting

· wait, notify and notifyAll methods are not called on Thread, they’re called on Object. Because the object is the one which controls the threads in this case. It asks the threads to wait and then notifies when its state changes. It’s called a monitor.

· Wait puts an executing thread into waiting state.(to the monitor’s waiting pool)

· Notify moves one thread in the monitor’s waiting pool to ready state. We cannot control which thread is being notified. notifyAll is recommended.

· NotifyAll moves all threads in the monitor’s waiting pool to ready.

· These methods can only be called from synchronized code, or an IllegalMonitorStateException will be thrown. In other words, only the threads that obtained the object’s lock can call these methods.
Locks, Monitors and Synchronization

· Every object has a lock (for every synchronized code block). At any moment, this lock is controlled by at most one thread.

· A thread that wants to execute an object’s synchronized code must acquire the lock of the object. If it cannot acquire the lock, the thread goes into blocked state and comes to ready only when the object’s lock is available.

· When a thread, which owns a lock, finishes executing the synchronized code, it gives up the lock.

· Monitor (a.k.a Semaphore) is an object that can block and revive threads, an object that controls client threads. Asks the client threads to wait and notifies them when the time is right to continue, based on its state. In strict Java terminology, any object that has some synchronized code is a monitor.

· 2 ways to synchronize:

1. Synchronize the entire method

· Declare the method to be synchronized – very common practice.

· Thread should obtain the object’s lock.

2. Synchronize part of the method

· Have to pass an arbitrary object which lock is to be obtained to execute the synchronized code block (part of a method).

· We can specify “this” in place object, to obtain very brief locking – not very common.

· wait – points to remember

§ calling thread gives up CPU

§ calling thread gives up the lock

§ calling thread goes to monitor’s waiting pool

§ wait also has a version with timeout in milliseconds. Use this if you’re not sure when the current thread will get notified, this avoids the thread being stuck in wait state forever.

· notify – points to remember

§ one thread gets moved out of monitor’s waiting pool to ready state

§ notifyAll moves all the threads to ready state

§ Thread gets to execute must re-acquire the lock of the monitor before it can proceed.
· Points for complex models:

1. Always check monitor’s state in a while loop, rather than in an if statement.

2. Always call notifyAll, instead of notify.

· Class locks control the static methods.

· wait and sleep must be enclosed in a try/catch for InterruptedException.

· A single thread can obtain multiple locks on multiple objects (or on the same object)

· A thread owning the lock of an object can call other synchronous methods on the same object. (this is another lock) Other threads can’t do that. They should wait to get the lock.

· Non-synchronous methods can be called at any time by any thread.

· Synchronous methods are re-entrant. So they can be called recursively.

· Synchronized methods can be overrided to be non-synchronous. Synchronized behavior affects only the original class.

· Locks on inner/outer objects are independent. Getting a lock on outer object doesn’t mean getting the lock on an inner object as well, that lock should be obtained separately.

· wait and notify should be called from synchronized code. This ensures that while calling these methods the thread always has the lock on the object. If you have wait/notify in non-synchronized code compiler won’t catch this. At runtime, if the thread doesn’t have the lock while calling these methods, an IllegalMonitorStateException is thrown.

· Deadlocks can occur easily. e.g, Thread A locked Object A and waiting to get a lock on Object B, but Thread B locked Object B and waiting to get a lock on Object A. They’ll be in this state forever.

· It’s the programmer’s responsibility to avoid the deadlock. Always get the locks in the same order.

· While ’suspended’, the thread keeps the locks it obtained – so suspend is deprecated in 1.2

· Use of stop is also deprecated; instead use a flag in run method. Compiler won’t warn you, if you have statements after a call to stop, even though they are not reachable.

*more here

a) public static void main();
b) public static void main( String args );
c) public static void main( String args[] );
d) public static void main( Graphics g );
e) public static boolean main( String args[] );
2. If MyProg.java were compiled as an application and then run from the command line as:
java MyProg I like tests
what would be the value of args[ 1 ] inside the main( ) method?

a) MyProg
b) “I”
c) “like”
d) 3
e) 4
f) null until a value is assigned
3. Which of the following are Java keywords?

a) array
b) boolean
c) Integer
d) protect
e) super
4. After the declaration:
char[] c = new char[100];
what is the value of c[50]?

a) 50
b) 49
c) ‘\u0000′
d) ‘\u0020′
e) ” ”
f) cannot be determined
g) always null until a value is assigned

5. After the declaration:
int x;
the range of x is:

a) -231 to 231-1
b) -216 to 216 – 1
c) -232 to 232
d) -216 to 216
e) cannot be determined; it depends on the machine

6. Which identifiers are valid?

a) _xpoints
b) r2d2
c) bBb$
d) set-flow
e) thisisCrazy

7. Represent the number 6 as a hexadecimal literal.

8. Which of the following statements assigns “Hello Java” to the String variable s?

a) String s = “Hello Java”;
b) String s[] = “Hello Java”;
c) new String s = “Hello Java”;
d) String s = new String(“Hello Java”);

9. An integer, x has a binary value (using 1 byte) of 10011100. What is the binary value of z after these statements:
int y = 1 << 7;
int z = x & y;

a) 1000 0001
b) 1000 0000
c) 0000 0001
d) 1001 1101
e) 1001 1100

10. Which statements are accurate:

a) >> performs signed shift while >>> performs an unsigned shift.
b) >>> performs a signed shift while >> performs an unsigned shift.
c) << performs a signed shift while <<< performs an insigned shift.
d) <<< performs a signed shift while << performs an unsigned shift.

11. The statement ...
String s = "Hello" + "Java";
yields the same value for s as ...
String s = "Hello";
String s2= "Java";
s.concat( s2 );
True
False

12. If you compile and execute an application with the following code in its main() method:
String s = new String( "Computer" );

if( s == "Computer" )
System.out.println( "Equal A" );
if( s.equals( "Computer" ) )
System.out.println( "Equal B" );
a) It will not compile because the String class does not support the = = operator.
b) It will compile and run, but nothing is printed.
c) "Equal A" is the only thing that is printed.
d) "Equal B" is the only thing that is printed.
e) Both "Equal A" and "Equal B" are printed.

13. Consider the two statements:
1. boolean passingScore = false && grade == 70;
2. boolean passingScore = false & grade == 70;
The expression
grade == 70
is evaluated:

a) in both 1 and 2
b) in neither 1 nor 2
c) in 1 but not 2
d) in 2 but not 1
e) invalid because false should be FALSE

14. Given the variable declarations below:
byte myByte;
int myInt;
long myLong;
char myChar;
float myFloat;
double myDouble;
Which one of the following assignments would need an explicit cast?

a) myInt = myByte;
b) myInt = myLong;
c) myByte = 3;
d) myInt = myChar;
e) myFloat = myDouble;
f) myFloat = 3;
g) myDouble = 3.0;

15. Consider this class example:
class MyPoint
{ void myMethod()
{ int x, y;
x = 5; y = 3;
System.out.print( " ( " + x + ", " + y + " ) " );
switchCoords( x, y );
System.out.print( " ( " + x + ", " + y + " ) " );
}
void switchCoords( int x, int y )
{ int temp;
temp = x;
x = y;
y = temp;
System.out.print( " ( " + x + ", " + y + " ) " );
}
}
What is printed to standard output if myMethod() is executed?

a) (5, 3) (5, 3) (5, 3)
b) (5, 3) (3, 5) (3, 5)
c) (5, 3) (3, 5) (5, 3)

16. To declare an array of 31 floating point numbers representing snowfall for each day of March in Gnome, Alaska, which declarations would be valid?

a) double snow[] = new double[31];
b) double snow[31] = new array[31];
c) double snow[31] = new array;
d) double[] snow = new double[31];

17. If arr[] contains only positive integer values, what does this function do?
public int guessWhat( int arr[] )
{ int x= 0;
for( int i = 0; i < arr.length; i++ )
x = x < arr[i] ? arr[i] : x;
return x;
}
a) Returns the index of the highest element in the array
b) Returns true/false if there are any elements that repeat in the array
c) Returns how many even numbers are in the array
d) Returns the highest element in the array
e) Returns the number of question marks in the array

18. Consider the code below:
arr[0] = new int[4];
arr[1] = new int[3];
arr[2] = new int[2];
arr[3] = new int[1];
for( int n = 0; n < 4; n++ )
System.out.println( /* what goes here? */ );
Which statement below, when inserted as the body of the for loop, would print the number of values in each row?

a) arr[n].length();
b) arr.size;
c) arr.size -1;
d) arr[n][size];
e) arr[n].length;

19. If size = 4, triArray looks like:

int[][] makeArray( int size)
{ int[][] triArray = new int[size] [];
int val=1;
for( int i = 0; i < triArray.length; i++ )
{ triArray[i] = new int[i+1];
for( int j=0; j < triArray[i].length; j++ )
{ triArray[i][j] = val++;
}
}
return triArray;
}

a)
1 2 3 4
5 6 7
8 9
10
b)
1 4 9 16
c)
1 2 3 4
d)
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
e)
1
2 3
4 5 6
7 8 9 10
20. Which of the following are legal declarations of a two-dimensional array of integers?

a) int[5][5]a = new int[][];
b) int a = new int[5,5];
c) int[]a[] = new int[5][5];
d) int[][]a = new[5]int[5];

21. Which of the following are correct methods for initializing the array "dayhigh" with 7 values?

a) int dayhigh = { 24, 23, 24, 25, 25, 23, 21 };
b) int dayhigh[] = { 24, 23, 24, 25, 25, 23, 21 };
c) int[] dayhigh = { 24, 23, 24, 25, 25, 23, 21 };
d) int dayhigh [] = new int[24, 23, 24, 25, 25, 23, 21];
e) int dayhigh = new[24, 23, 24, 25, 25, 23, 21];

22. If you want subclasses to access, but not to override a superclass member method, what keyword should precede the name of the superclass method?

23. If you want a member variable to not be accessible outside the current class at all, what keyword should precede the name of the variable when declaring it?

24. Consider the code below:

public static void main( String args[] )
{ int a = 5;
System.out.println( cube( a ) );
}
int cube( int theNum )
{
return theNum * theNum * theNum;
}

What will happen when you attempt to compile and run this code?

a) It will not compile because cube is already defined in the java.lang.Math class.
b) It will not compile because cube is not static.
c) It will compile, but throw an arithmetic exception.
d) It will run perfectly and print "125" to standard output.

25. Given the variables defined below:
int one = 1;
int two = 2;
char initial = '2';
boolean flag = true;
Which of the following are valid?

a) if( one ){}
b) if( one = two ){}
c) if( one == two ){}
d) if( flag ){}
e) switch( one ){}
f) switch( flag ){}
g) switch( initial ){}

26. If val = 1 in the code below:

switch( val )
{ case 1: System.out.print( "P" );
case 2:
case 3: System.out.print( "Q" );
break;
case 4: System.out.print( "R" );
default: System.out.print( "S" );
}

Which values would be printed?

a) P
b) Q
c) R
d) S

27. Assume that val has been defined as an int for the code below:

if( val > 4 )
{ System.out.println( “Test A” );
}
else if( val > 9 )
{ System.out.println( “Test B” );
}
else System.out.println( “Test C” );

Which values of val will result in “Test C” being printed:
a) val < 0
b) val between 0 and 4
c) val between 4 and 9
d) val > 9
e) val = 0
f) no values for val will be satisfactory
28. What exception might a wait() method throw?

29. For the code:

m = 0;
while( m++ < 2 )
System.out.println( m );

Which of the following are printed to standard output?

a) 0
b) 1
c) 2
d) 3
e) Nothing and an exception is thrown

30. Consider the code fragment below:

outer: for( int i = 1; i <3; i++ )
{ inner: for( j = 1; j < 3; j++ )
{ if( j==2 )
continue outer;
System.out.println( "i = " +i ", j = " + j );
}
}

Which of the following would be printed to standard output?

a) i = 1, j = 1
b) i = 1, j = 2
c) i = 1, j = 3
d) i = 2, j = 1
e) i = 2, j = 2
f) i = 2, j = 3
g) i = 3, j = 1
h) i = 3, j = 2

31. Consider the code below:
void myMethod()
{ try
{
fragile();
}
catch( NullPointerException npex )
{
System.out.println( "NullPointerException thrown " );
}
catch( Exception ex )
{
System.out.println( "Exception thrown " );
}
finally
{
System.out.println( "Done with exceptions " );
}
System.out.println( "myMethod is done" );
}
What is printed to standard output if fragile() throws an IllegalArgumentException?

a) "NullPointerException thrown"
b) "Exception thrown"
c) "Done with exceptions"
d) "myMethod is done"
e) Nothing is printed

32. Consider the following code sample:
class Tree{}
class Pine extends Tree{}
class Oak extends Tree{}
public class Forest
{ public static void main( String[] args )
{ Tree tree = new Pine();

if( tree instanceof Pine )
System.out.println( "Pine" );

if( tree instanceof Tree )
System.out.println( "Tree" );

if( tree instanceof Oak )
System.out.println( "Oak" );

else System.out.println( "Oops" );
}
}
Select all choices that will be printed:

a) Pine
b) Tree
c) Forest
d) Oops
e) (nothing printed).

33. Consider the classes defined below:
import java.io.*;
class Super
{
int methodOne( int a, long b ) throws IOException
{ // code that performs some calculations
}
float methodTwo( char a, int b )
{ // code that performs other calculations
}
}
public class Sub extends Super
{

}
Which of the following are legal method declarations to add to the class Sub? Assume that each method is the only one being added.
a) public static void main( String args[] ){}
b) float methodTwo(){}
c) long methodOne( int c, long d ){}
d) int methodOne( int c, long d ) throws ArithmeticException{}
e) int methodOne( int c, long d ) throws FileNotFoundException{}
34. Assume that Sub1 and Sub2 are both subclasses of class Super.
Given the declarations:

Super super = new Super();
Sub1 sub1 = new Sub1();
Sub2 sub2 = new Sub2();

Which statement best describes the result of attempting to compile and execute the following statement:

super = sub1;

a) Compiles and definitely legal at runtime
b) Does not compile
c) Compiles and may be illegal at runtime
35. For the following code:
class Super
{ int index = 5;
public void printVal()
{ System.out.println( "Super" );
}
}
class Sub extends Super
{ int index = 2;
public void printVal()
{ System.out.println( "Sub" );
}
}
public class Runner
{ public static void main( String argv[] )
{ Super sup = new Sub();
System.out.print( sup.index + "," );
sup.printVal();
}
}
What will be printed to standard output?

a) The code will not compile.
b) The code compiles and "5, Super" is printed to standard output.
c) The code compiles and "5, Sub" is printed to standard output.
d) The code compiles and "2, Super" is printed to standard output.
e) The code compiles and "2, Sub" is printed to standard output.
f) The code compiles, but throws an exception.

36. How many objects are eligible for garbage collection once execution has reached the line labeled Line A?

String name;
String newName = "Nick";
newName = "Jason";
name = "Frieda";

String newestName = name;

name = null;
//Line A

a) 0
b) 1
c) 2
d) 3
e) 4

37. Which of the following statements about Java's garbage collection are true?

a) The garbage collector can be invoked explicitly using a Runtime object.
b) The finalize method is always called before an object is garbage collected.
c) Any class that includes a finalize method should invoke its superclass' finalize method.
d) Garbage collection behavior is very predictable.

38. What line of code would begin execution of a thread named myThread?

39. Which methods are required to implement the interface Runnable.

a) wait()
b) run()
c) stop()
d) update()
e) resume()

40. What class defines the wait() method?

41. For what reasons might a thread stop execution?

a) A thread with higher priority began execution.
b) The thread's wait() method was invoked.
c) The thread invoked its yield() method.
d) The thread's pause() method was invoked.
e) The thread's sleep() method was invoked.

42. Which method below can change a String object, s ?

a) equals( s )
b) substring( s )
c) concat( s )
d) toUpperCase( s )
e) none of the above will change s

43. If s1 is declared as:

String s1 = "phenobarbital";

What will be the value of s2 after the following line of code:
String s2 = s1.substring( 3, 5 );
1.
a) null
b) "eno"
c) "enoba"
d) "no"

44. What method(s) from the java.lang.Math class might method() be if the statement

method( -4.4 ) == -4;

is true.

a) round()
b) min()
c) trunc()
d) abs()
e) floor()
f) ceil()

45. Which methods does java.lang.Math include for trigonometric computations?

a) sin()
b) cos()
c) tan()
d) aSin()
e) aCos()
f) aTan()
g) toDegree()

46. This piece of code:

TextArea ta = new TextArea( 10, 3 );

Produces (select all correct statements):

a) a TextArea with 10 rows and up to 3 columns
b) a TextArea with a variable number of columns not less than 10 and 3 rows
c) a TextArea that may not contain more than 30 characters
d) a TextArea that can be edited

47. In the list below, which subclass(es) of Component cannot be directly instantiated:

a) Panel
b) Dialog
c) Container
d) Frame

48. Of the five Component methods listed below, only one is also a method of the class MenuItem. Which one?

a) setVisible( boolean b )
b) setEnabled( boolean b )
c) getSize()
d) setForeground( Color c )
e) setBackground( Color c )

49. If a font with variable width is used to construct the string text for a column, the initial size of the column is:

a) determined by the number of characters in the string, multiplied by the width of a character in this font
b) determined by the number of characters in the string, multiplied by the average width of a character in this font
c) exclusively determined by the number of characters in the string
d) undetermined

50. Which of the following methods from the java.awt.Graphics class would be used to draw the outline of a rectangle with a single method call?

a) fillRect()
b) drawRect()
c) fillPolygon()
d) drawPolygon()
e) drawLine()

51. The Container methods add( Component comp ) and add( String name, Component comp ) will throw an IllegalArgumentException if comp is a:

a) button
b) list
c) window
d) textarea
e) container that contains this container

52. Of the following AWT classes, which one(s) are responsible for implementing the components layout?

a) LayoutManager
b) GridBagLayout
c) ActionListener
d) WindowAdapter
e) FlowLayout

53. A component that should resize vertically but not horizontally should be placed in a:

a) BorderLayout in the North or South location
b) FlowLayout as the first component
c) BorderLayout in the East or West location
d) BorderLayout in the Center location
e) GridLayout

54. What type of object is the parameter for all methods of the MouseListener interface?

55. Which of the following statements about event handling in JDK 1.1 and later are true?

a) A class can implement multiple listener interfaces
b) If a class implements a listener interface, it only has to overload the methods it uses
c) All of the MouseMotionAdapter class methods have a void return type.

56. Which of the following describe the sequence of method calls that result in a component being redrawn?

a) invoke paint() directly
b) invoke update which calls paint()
c) invoke repaint() which invokes update(), which in turn invokes paint()
d) invoke repaint() which invokes paint directly

57. Which of these is a correct fragment within the web-app element of deployment descriptor. Select the two correct answer.
A. 404 /error.jsp
B. mypackage.MyException 404 /error.jsp
C. mypackage.MyException 404
D. mypackage.MyException /error.jsp
58. A bean with a property color is loaded using the following statement

Which of the following statements may be used to set the of color property of the bean. Select the one correct answer.
1.
2.
3.
4.
5.
6.
59. What gets printed when the following JSP code is invoked in a browser. Select the one correct answer.
<%= if(Math.random() < 0.5){ %>
hello
<%= } else { %>
hi
<%= } %>
a.The browser will print either hello or hi based upon the return value of random.
b.The string hello will always get printed.
c.The string hi will always get printed.
d.The JSP file will not compile.
60. Given the following web application deployment descriptor:


myServlet
MyServlet
…


myServlet
*.jsp

which statements are true?

1) servlet-mapping element should be inside servlet element
2) url-pattern can’t be defined that way.
3) if you make the http call: http://host/Hello.jsp the servlet container will execute MyServlet.
4) It would work with any extension excepting jsp,html,htm
61.Name the class that includes the getSession method that is used to get the HttpSession object.
A.HttpServletRequest
B.HttpServletResponse
C.SessionContext
D.SessionConfig
62. What will be the result of running the following jsp file taking into account that the Web server has just been started and this is the first page loaded by the server?

<%= request.getSession(false).getId() %>

1)It won’t compile
2)It will print the session id.
3)It will produce a NullPointerException as the getSession(false) method’s call returns null, cause no session had been created.
4)It will produce an empty page.

63. The page directive is used to convey information about the page to JSP container. Which of these are legal syntax of page directive. Select the two correct statement
A.<% page info="test page" %>
B.<%@ page info="test page" session="false"%>
C.<%@ page session="true" %>
D.<%@ page isErrorPage="errorPage.jsp" %>
E.<%@ page isThreadSafe=true %>
64. Which of the following are methods of the Cookie Class?
1) setComment
2) getVersion
3) setMaxAge
4) getSecure.

*more here