Java Programming

key is nothing but a attribute and attribute is the aspect of a member in an entity

entity is represented by set of attributes.

primary key is the one which is selected by the database designer to identify a entity in a entity set

super key is one or more attributes which is used to identify the entity in an entity set uniquely

candidate key minimal number of super keys... in some context super key and secondary key are equal.

foreign key is the relational constraint between tables or entities

A secondary key is made on a field that you would like to be indexed for faster searches!

For any Further detail,you visit this website:http://www.iyogibusiness.com

hi friend....

Instance variable means with which you need to create an obeject in order to invoke any methods or variables defined in a class.

For ex:

class A

{

int a=10;

public void inc()

{return a++; }

}

To invoke a member

A b=new A();

b.inc();

System.out.println(b.a);

If incase of a static method you can directly call using class name itself.

like :

b=Math.sqrt(a);

This is done via a call sequence. The syntax is different between languages but the process is about the same. The calling program issues a call to the called program and passes data items known as arguments. These arguments are used to instruct the called program on what actually to do. After the called program has completed its function it passes these arguments back to the calling program along with a return code to inform the calling program everything was ok, or not ok.

Yes You can. The features of such a class would be similar to what an Exception would have but not exactly as a predefined Java Exception.

When you create a user defined exception you extend the java.lang.Exception class which in turn extends the java.lang.Throwable so indirectly you are extending the Throwable class while creating a user defined exception...

Typical way for writing code that uses RMI is similar

to the process for writing RPC

❍ declare the interface in IDL, compile the IDL file to generate

client and server stubs, link them with client and server side

code to generate the client and the server executables

❍ referred to as static invocation

❍ requires the object interface to be known when the client is

being developed

❒ Dynamic invocation

❍ the method invocation is composed at run-time

invoke(object, method, input_parameters, output_parameters)

❍ useful for applications where object interfaces are

discovered at run-time, e.g. object browser, batch processing

systems for object invocations, "agents"

class Table

{

int n;

void func(int n)

{

int k=2;

for(int i=1;i<n;i++)

{

System.out.println("table of "+k);

for(int j=1;j<=10;j++)

{

int a=j*k;

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

System.out.print(" ");

}

k=k+1;

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

}

}

public static void main(String k[])

{

Table t =new Table();

int num=Integer.parseInt(k[0]);//pass the number upto you want the tables eg:4

t.func(num);

}

}

#include

void main()

{

int i=2,m,n;

printf("enter number");

scanf("%d",&n);

do

{

m=i*n;

printf("%d*%d=%d\n",n,i,m);

i=i+1;

}

while (i<=10);

}

Keywords are reserved words in a programming language whose meaning are available in the respective compiler. C programming language has the following keywords; default, return, struct, void, volatile, unsigned, signed, double, while, union, static, switch, typedef, register, short, size of, for, long, if, int, goto, enum, float, else, extern, do, const, break, char, case, break and auto.

If the method is static you can do this way:

Classname.method()

If the method is not static then you would have to instantiate the class that contains this method and then call it using that object.

Classname obj = new Classname();

obj.method()

They end with an extension .java

Test.java would be a java source file.

The contents of Test.java could be

package xyz;

import java.util.*;

public class Test {

...

...

..

.

.

}

A new operater is used to allocating a memory space for a particular object.

buzzwords are nothing but the feature of java programming and they are as follows...

1 complied and interpreted

2 platform independent and portable

3 high performance

4 Robust

5 simple

6 Secure...........

#include "stdio.h" int main() { unsigned int number, count; printf("Enter the Number \t"); scanf("%d", &number); printf("The even numbers are: \n"); for(count = 0x01; (count < number && number!= 0x00)) { if(count%2) { }else { printf("%d\n", count); } count++; } return 0; }

You should use arrays when you have several pieces of related data, of the same type. As an example, let's suppose you have a series of measurements, for example, temperature measured every few minutes. It doesn't make sense (from a programming point of view) to use a different variable for every measurement, so you store the measurements as a group - as an array.

You should use arrays when you have several pieces of related data, of the same type. As an example, let's suppose you have a series of measurements, for example, temperature measured every few minutes. It doesn't make sense (from a programming point of view) to use a different variable for every measurement, so you store the measurements as a group - as an array.

You should use arrays when you have several pieces of related data, of the same type. As an example, let's suppose you have a series of measurements, for example, temperature measured every few minutes. It doesn't make sense (from a programming point of view) to use a different variable for every measurement, so you store the measurements as a group - as an array.

You should use arrays when you have several pieces of related data, of the same type. As an example, let's suppose you have a series of measurements, for example, temperature measured every few minutes. It doesn't make sense (from a programming point of view) to use a different variable for every measurement, so you store the measurements as a group - as an array.

If you're referring to "args" in the line: "public static void main(String args[])", then it is the name of the array that holds the command line arguments. So, if you called your java program (called myJavaProgram) from the command line using the following line:

java myJavaProgram Hello World "These are args"

Then args would have the following values stored in it:

args[0] = "Hello"

args[1] = "World"

args[2] = "These are args"

If you called your program from the command line like this:

java myJavaProgram Different Args

then args would contain

args[0] = "Different"

args[1] = "Args"

There are a number of ways to create a file in java. The following example demonstrates a few:

import java.io.*;

import java.nio.charset.*;

public class Main {

public static void main(String[] args) {

try {

// Simplest way

PrintWriter out1 = new PrintWriter("file1.txt");

out1.println("hello file1!");

out1.close();

// Append to existing file if it already exists

PrintWriter out2 = new PrintWriter(new FileWriter("file2.txt", true));

out2.println("hello file2!");

out2.close();

// If non-default charset is needed

Charset charset = Charset.forName("UTF-16");

PrintWriter out3 = new PrintWriter(new OutputStreamWriter(new FileOutputStream("file3.txt"), charset));

out3.println("hello file3!");

out3.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

That depends on how you look at it. The point of the JVM is to allow Java bytecode to be executed on any platform, regardless of what machine it was compiled on.

The actual implementation of the JVM, however, must be platform-specific.

public class CircleDiameter { publicCircleDiameter() { super(); } publicfloatgetDiameterFrmRadius(float radius){ return radius * 2; } /** * @param args */ public static void main(String[] args) { float radius = 5; CircleDiameter circle = newCircleDiameter(); float dia = circle.getDiameterFrmRadius(radius); System.out.println("Diameter of this circle is: " + dia); } }

An applet is a Java program embedded in an HTTP document. When the HTTP document is loaded into a web browser, the Java program executes on the web. A widget = window gadget, a GUI (graphical user interface) control. A GUI control, such as a command button, is accessed by the user via a mouse click or by the keyboard. GUI programs can run on one's PC.

A compound statement is a group of statements enclosed in braces, i.e curly brackets. A compound statement is a group of statements enclosed in braces, i.e curly brackets.

A set which containing $and pi are the end blocks are the finite and without these are infinite

in .exe file it contains

machine understandable code. but in .class file it contain only byte code which is not understadable by the microprocessor it will understud by the jvm only . we con't execute .class file without jvm . but we can execute .exe file without c-compiler .