Java Programming

The below method is written in the assumption that, the n numbers are sent as an ArrayList of Integer values.

public void computeSumAndAvg(ArrayList lst){ Iterator itr = lst.iterator();

int sum = 0;

float average = 0;

int count = 0;

while(itr.hasNext(){ Integer val = (Integer) itr.next();

sum = sum + val.intValue();

count++; }

average = sum/count;

System.out.println("Sum is: " + sum) ;

System.out.println("Average is: " + average) ; }

import java.util.Vector;

public class VectorTest {

/**

* @param args

*/

public static void main(String[] args) {

//instantiating a vector

Vector vct = new Vector();

//Add objects to a vector

vct.add("One");

//getting values from the vector

String val = (String) vct.get(0);

//vector size

System.out.println("Vector size is: " + vct.size());

//removing elements from a vector

vct.remove(0);

}

}

Enhanced Hibernate Query Language

Enhanced Hibernate Criteria Query API

Enhanced support for queries expressed in the native SQL dialect of the database

i Would say it because when i used to use it it would run slow and i got a warning from java

In an if statement, the condition must be enclosed in parentheses.

Explicit means done by the programmer.

Implicit means done by the JVM or the tool , not the Programmer.

For Example:

Java will provide us default constructor implicitly.Even if the programmer didn't write code for constructor, he can call default constructor.

Explicit is opposite to this , ie. programmer has to write .

class Count

{

public static void main(String args[])

{

int i,c=0;

int n=args.length;

System.out.println("length is"+n);

for(i=0;i<args.length;i++)

{

System.out.println(args[i]);

c++;

}

System.out.println("number of words="+c);

}

}

what are the objective of operating system

Bear says bow string length is 86.125in & buss cable length 31in

One practical example would be an application that would need to compute interest earned on a savings account or multiple savings accounts at the end of the year. Another would be an application that tracks a person's name and age and then sorts them into similar or randomized groups.

the length of the array

#include<stdio.h>

#include<string.h>

int main()

{

char a[80];

int rotated_element_number[80];

int rotation;

int i;

int length;

printf("enter the word: \n");

gets(a);

length = strlen(a);

printf("the reversed string is:\n");

for( rotation=0; rotation<length; rotation++)

{

for( i=0; i<length; i++)

{

rotated_element_number[i] = i + rotation;

while(rotated_element_number[i] > (length-1)) rotated_element_number[i] -= length;

printf("%c", a[rotated_element_number[i]]);

}

printf("\t");

}

getchar();

return 0;

}

at the starting of the JVM it handels approx 7000 threads .........

father

Character(-string).

Implementation hiding.

No. You must create a subclass of the abstract class in order to be able to instantiate it.

Class access is the ability for any given class to access the functions of another class. Private access limits access to data and code just to the class that contains the private access modifier. The so-called "default" access grants private access, as well as access to any class in the same package. Protected access grants the same as "default" access, and also allows subclasses to access the code and data. Public access allows any class in any package to access the code and data.

It is one of the constant key word and it is used only in run time

Cutting Class was created in 1989.

Theres two types of data, Continuous and discontinuous data.

a Memoir

The multiple inheritance is supported by using more implements key word

example

class a implements b, implements c, implements d

{

....

}

so here the class a supports multiple inheritance by implementing class b,c,d.

Java does not support true multiple inheritance - true M.I. requires that a class be able to inherit directly from multiple classes. That is, in M.I., Class A can be a direct child of Class B and C.

To get much of the functionality and advantages of the M.I. model, Java uses Interfaces. Thus, a Java Class A will be the child of Class B, but can implement several interfaces X, Y, and Z. This attempts to mimic the behavior that in a M.I. language would be given by Class A being a direct child of B, X, Y, and Z.

The major difference between a M.I. language and a single-inheritance language with interfaces (like Java), is that interfaces can only define the method signatures and constants; they CANNOT provide implementations of those methods in the interface specification. Thus, any class which implements a given interface must provide an actual implementation of the methods that the interface describes. The big downside to this is that it can lead to a large amount of "code copying" - that is, if both Class A and Class B implement an interface X, there is a good chance that most of the methods from X will have the same code implementation in both Class A and B. Sometimes this is unavoidable; however, it is also considered good programming style to use abstract Classes to implement commonly used interfaces, then put that abstract class fairly high in the object hierarchy, allowing large numbers of classes to inherit from that abstract Class (which, in turn, means they have access to the implementation of those interfaces without having to copy the code). The advantage of interfaces is that they can keep things conceptually clean, and also make it simple for classes to decide how they want to implement the method contract the interface describes.

Practically speaking, if you would like Class A to inherit from Class B and also to inherit from Class C, then, in Java, you would simulate this via interfaces this way:

public class B {

// the superclass

methods_go_here_with_their_implementations;

}

public interface C {

// the Java equivalent of Class C in a M.I. Language

the_method_signatures_of_C_go_here;

}

public class A extends B implements C {

implementations_of_methods_in_C_go_here;

}