Java Programming

We know that compiler will decide which function to be invoked among the overloaded functions. When the compiler could not choose a function between two or more overloaded functions, the situation is called as an ambiguity in function overloading.

When the program contains ambiguity, the compiler will not compile the program.

The main cause of ambiguity in the program

· Type conversion

· Functions with default arguments

· Functions with pass by reference

Type conversion

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(float f)

{ cout << f;}

int main()

{

fun(10);

fun(10.2);

return 0;

}

In this example type conversion creates ambiguity. fun(10) will refer the first function.

We think the value 10.2 is floating point value. So fun(10.2) will refer the second function. But fun(10.2) will refer which function? It could not refer any function. Because 10.2 will be treated as double data type by the compiler. (In c++ all the floating point values are converted by the compiler as double data type.) This is type conversion of float to double. So now compiler could not search the function fun with double data type.

So the compiler will give error message call of overloaded 'fun(double)' is ambiguous.

This example clearly rises the ambiguity in the program because of the type conversion.

Functions with default arguments

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(int i, int j=8)

{ cout << i << j;}

int main()

{

fun(10);

fun(10.2f);

return 0;

}

This program will give error message that overloaded 'fun(int)' is ambiguous. Because the fun(int i, int j =8) is a function with default arguments. It can be called in two ways. They are

(i) function with one argument.

fun(2) now the value of i is 2 and j is 8 (8 is the default value).

(ii) function with two arguments fun(5,6). So i is 5 and j is 6.

fun(int i) is a function with one argument. It should be invoked with one argument. So

when we call a function with 1 argument the compiler could not select among the two functions fun(int i) and fun(int i, int j=8).

This example clearly illustrates the ambiguity in the program because of function with default arguments.

Function with reference parameter

#include

using namespace std;

#include

void fun(int i)

{ cout << i;}

void fun(int &i)

{cout <

int main()

{

fun(10);

return 0;

}

This program will show the error message call of overloaded 'fun(int)' is ambiguous.

First fun(int) takes one integer argument and second function fun(int &) takes a reference parameter. In this case, compilers do not know which function is intended by the user when it is called. Because there is no syntactical difference in calling the function between the function with single argument and function with single reference parameter.

So compiler could not decide which function should be invoked when it is called. So this leads ambiguity in the program.

Throw is used to actually throw the exception, whereas throws is declarative for the method. They are not interchangeable.

public void myMethod(int param) throws MyException

{

if (param < 10)

{

throw new MyException("Too low!);

}

//Blah, Blah, Blah...

} The Throw clause can be used in any part of code where you feel a specific exception needs to be thrown to the calling method.

If a method is throwing an exception, it should either be surrounded by a try catch block to catch it or that method should have the throws clause in its signature. Without the throws clause in the signature the Java compiler does not know what to do with the exception. The throws clause tells the compiler that this particular exception would be handled by the calling method.

A Java package is a mechanism for organizing Java classes into namespaces similar to the modules of Modula. Java packages can be stored in compressed files called JAR files, allowing classes to download faster as a group rather than one at a time. Programmers also typically use packages to organize classes belonging to the same category or providing similar functionality.

· A package provides a unique namespace for the types it contains.

· Classes in the same package can access each other's members.

package is a container in which similar classes are grouped together.

package avoid the redundance of classes. it also provide security to hide the code only by importing the packege which contains the required class.

Differences:

1. Abstract class can also contain method definitions but an interface can contain only declarations
2. All variables in an interface are by default public static and final whereas in Abstract class it is not

An interface can be considered as a pure abstract class that contains no method implementations and contains only declarations.

There are many differences between Java and other programs, as there are also similarities: - managed code: java does not produce native code, but some byte code that will make it runnable in something called "virtual machine". The best thing about that: compile on windows and deploy that application on UNIX. - full object oriented -- even more than C++ where global variables are possible. Here, in java, everything must take place in an object - works on many operating systems. - a lot of technologies grouped in J2EE, that covers many the aspects of enterprise programming - servlets, jsp, ejb, jdbc to access the database, etc. The list is huge, I don't want to get in too much detail about that.

I guess it features some of the most mature technologies on the market.

• The Java compiler catches more compile-time errors; other languages (like C++) will compile programs that produce unpredictable results.
• Java does not allocate direct pointers to memory. This makes it impossible to accidentally reference memory that belongs to other programs or the kernel.
• ... (can't think of anything else off the top of my head)

1)Java is a purely Platform independent means the application that will work in any kind of Operating System.But .Net is platform independt software.

2).Net support to develop application in different languages and to develop application Rapidly. This feature is not exist in Java

On the other hand, General Purpose applications are still developed using C++ because it doesn't need any intermediate software to run.

and i think that java it's been improved everyday by the newest releases of the implementation of the virtual machine.

Complexity of an algorithm is the study of how long a program will take to run, depending on the size of its input & long of loops made inside the code

Specifically, the complexity of an algorithm is a measure of how long it takes to complete (give an answer) relative to increasing sizes of input data. Thus, complexity is not concerned with how long it took the algorithm to run using X amount of data. Rather, it is concerned with the relationship in runtime when using X amount of data, 2X amounts of data, 10X amounts of data, etc. While complexity usually refers to execution time, it can also be applied to other resource usage (for example, memory allocation). In all cases, complexity is concerned with the relationship between the rate of increase in resource consumption and the rate of increase of the size of the data set being worked on.

Complexity is closely related to the concepts of scalingand efficiency, but is NOT an exact equivalence to either.