jExpertize

java 2 micro edition used HTTP vs UDP vs Socket

2012-06-15T23:30:00.000-07:00

In the case of MIDP, the specification only requires support for HTTP, although many devices support datagrams and sockets as well, because these protocols are needed to implement HTTP. However, before making commitments to datagrams or sockets it is a good idea to make sure they are supported on the platforms you are targeting.

Because HTTP is guaranteed to be supported by MIDP this is usually the best protocol choice due to portability. HTTP moves through firewalls easily since it generally operates over port 80. However, of the three protocols discussed, HTTP incurs the most overhead, which may drive up the user's cost of using the application on the network.

Datagrams, on the other hand, tend to have far less overhead and can be easier on the end-user's budget. The caveat, as discussed previously, is that the application must take on the task of ensuring that all data arrived at the other end and that the order of that data received is correct.

Finally, sockets fall somewhere in the middle of HTTP and datagrams in that data sent over a socket is managed by the protocol, but requires fewer network resources than HTTP. This means that the application does not have to concern itself with making sure data is received on the other end. Sockets are generally a lighter-weight option over HTTP since the application controls when the end points communicate. HTTP, on the other hand, must make several trips between the end points to exchange header information as well as the data.

The GCF provides a lot of functionality and standardizes how connections are established throughout the J2ME architecture. The GCF is extensible as well, allowing manufacturers to support their own interfaces and connection types. In some cases a manufacturer may use the GCF to support streaming multimedia content with a special connection or for establishing connections to a GPS receiver. Having this kind of flexibility prevents J2ME from being constrained to a common set of protocols while maintaining consistency throughout the architecture.

java 2 micro edition tutorial of Using HttpConnection in J2ME (Retrieve web content from a website to a phone)

2012-06-15T23:28:00.000-07:00

This J2ME example will cover reading data using the MIDP HttpConnection. Note that this connection interface is not part of the CLDC or CDC, but is defined rather in the MIDP and Personal Profiles themselves. The behavior of HttpConnection is one that combines an InputStream and an OutputStream into a single connection. A single HttpConnection may open and use exactly one OutputStream and exactly one InputStream. The order in which the streams are used is important as well. The OutputStream, if used, must be used before the InputStream. Once the streams have been used the connection should be closed and a new HttpConnection should be opened to continue communications if necessary. This follows the HTTP request-response paradigm.

The HttpConnection is a bit more tricky to use than the socket or datagram connections because there is a lot that happens behind the scenes. There are three states to an HttpConnection:

Setup

Connected

Closed

The setup state is the first state encountered after a connection is opened. While in this state, connection parameters can be set such as the request method (GET, POST or HEAD) using the setRequestMethod() method or any header properties using the setRequestProperty() method.

The transition from setup to connected is triggered by any methods that cause data to be sent to the server. The following is a list of methods that cause this transition.

openInputStream

openDataInputStream

getLength

getType

getEncoding

getHeaderField

getResponseCode

getResponseMessage

getHeaderFieldInt

getHeaderFieldDate

getExpiration

getDate

getLastModified

getHeaderField

getHeaderFieldKey

Once the connection transitions to the connected state, any calls to setRequestMethod() and setRequestProperty() will throw an IOException. The state transition from setup to connected reflects the underlying handshake of the HttpConnection as headers are sent to the server and the connection prepares to send data. The following example demonstrates reading Web content from an HttpConnection.

HttpConnection c = null;
InputStream is = null;
StringBuffer sb = new StringBuffer();
try {
c = (HttpConnection)Connector.open(
"http://www.java-samples.com”,
Connector.READ_WRITE, true);
c.setRequestMethod(HttpConnection.GET); //default
is = c.openInputStream(); // transition to connected!
int ch = 0;
for(int ccnt=0; ccnt < 150; ccnt++) { // get the title.
ch = is.read();
if (ch == -1){
break;
}
sb.append((char)ch);
}
}
catch (IOException x){
x.printStackTrace();
}
finally{
try {
is.close();
c.close();
} catch (IOException x){
x.printStackTrace();
}
}
System.out.println(sb.toString());

In this example, the server at www.java-samples.com is contacted. Because this is an HttpConnection and no port is specified, port 80 is used by default. The request method is set to GET (note GET is the default and is explicitly set here only for the example).

java 2 micro edition tutorial of Datagrams in J2ME (UDP Programming)

2012-06-15T23:25:00.000-07:00

It is quite possible for someone to have worked with Java for some time without ever needing to understand or use datagrams. For mobile devices, however, datagrams offer some advantages in that they are rather lightweight when compared to TCP-based connections such as sockets. User Datagram Protocol, UDP, is one of the more common datagram protocols. However, because most datagram protocols follow the same basic principals as to their usage, the GCF is able to support datagrams generically.

Datagrams are based on a connection-less paradigm, which means that a conversation is not established between two systems. Instead, datagrams are blindly transmitted across a network connection. To transmit a datagram from one system to another, an application creates a datagram and sends it to the intended target. This is a rather simple process in J2ME. However, there is a caveat to using datagrams in that they offer no guarantee or acknowledgement as to whether the datagram actually reached the intended recipient. As a result, a datagram implementation must either not care if the recipient actually receives the data 100 percent of the time, or an acknowledgement/handshake must be implemented manually by the application.

Using Datagrams

The following example shows how to create a datagram and send it to a specific IP address.

try {
DatagramConnection dgc = (DatagramConnection)
Connector.open("datagram://localhost:9001");
try {

byte[] payload = "Test Message".getBytes();
Datagram datagram =
dgc.newDatagram(payload, payload.length);
dgc.send(datagram);
} finally {
dgc.close();
}
} catch (IOException x) {
x.printStackTrace();
}

In this example, a MIDlet creates a Datagram containing the text "Hello from a Datagram" and sends it to an application listening for datagrams on the local machine on port 9001. This example will execute just fine even if there is no application running to receive the datagram, thus demonstrating the connection-less nature of datagrams. The sender has no indication that the datagram was consumed by the target system.

Next I show how an application might receive the datagram sent by the previous code snippet.

try {
DatagramConnection dgc = (DatagramConnection)
Connector.open("datagram://:9001");
try {
int size = 100;
Datagram datagram = dgc.newDatagram(size);
dgc.receive(datagram);
System.out.println(
new String(datagram.getData()).trim());
} finally {
dgc.close();
}
} catch (IOException x){
x.printStackTrace();
}

In the receive example, a datagram connection is established on port 9001. A datagram is created with a size of 100 bytes; if a received datagram contains more than 100 bytes, any data beyond the 100-byte mark is ignored. Once the datagram is created the receive() method is called, putting the thread in a wait state until a datagram is received. When a datagram is received, the payload is extracted from the datagram container and printed to the console.

In order to run the send and the receive examples, two instances of a MIDlet can be run from the Wireless Toolkit, one to perform the receive and one to perform the send.

java 2 micro edition tutorial of adding own Application icon

2012-06-15T23:20:00.000-07:00

It is normally used the default icon which is seen as soon as the installation of a jar file is complete. if you want to see your own icon for launching the application after installing the jar file then here is how you can do this.To achieve this manually just add following entry into your JAD/Manifest files:

MIDlet-1: <App Name>,<AppIcon>,<MidletClass> where AppIcon is the name of icon image file along with path in the JAR file where it resides in the Jar ex: /app/appicon.png or else You can add the MIDlet-Icon attribute that contains the absolute path of the icon file for the MIDlet suite, relative to the JAR file itself.

If you are using an IDE, then follow the steps below:

For the Netbeans IDE

Just go to the project properties,
then go to the application descriptor.
and now click the midlet tab then you will find the icon option,correct.
Then click on this icon drop down and provide the name of the icon.
Thats all.
For the eclipse + mtj

#Open the eclipse
#Find your project
#Find the Application descriptor
#Now give double click with mouse left bottom in this
#Find the label "optional" choose it, in the MIDlet icon box put the your icon path...e.g. C:\...
#save your changes.

java 2 micro edition tutorial of CheckBox ChoiceGroup

2012-06-15T00:11:00.000-07:00

How to create check boxes in to your form. In this example we are creating a Form("Technologies") that is having four different choices, ChoiceGroup("JAVA", "J2ME", "J2EE", "JSF"). if user select a check box and click on "Choose" button then the selected item will be display on the form. We are using StringItem to display the selected item on the form. We are creating a variable of array type ("message[ ]") and stored the size of selected item in it. Next we are creating a boolean type array ("get[ ]") to store the size of selected item then we have given a condition if get[] returns true then this will display the StringItem() with message and String value of selected item. The StringItem has only 2 methods that is:

getText()
setText(String text)

Constructor StringItem Syntax is:

StringItem(String label, String text)

Tutorial:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

public class CheckBoxExample extends MIDlet implements CommandListener {
  private Display display;
  private Form form;
  private Command exit, choose;
  private ChoiceGroup technology;
  private int index;

  public CheckBoxExample() {
  form = new Form("Technologies");
  technology = new ChoiceGroup("Select Technology Which You Know", Choice.MULTIPLE);
  exit = new Command("Exit", Command.EXIT, 1);
  choose = new Command("Choose", Command.SCREEN, 2);  
  }

  public void startApp() {
  display = Display.getDisplay(this);
  technology.append("JAVA", null);
  technology.append("J2ME", null);
  technology.append("J2EE", null);
  technology.append("JSF", null); 

  index = form.append(technology);
  form.addCommand(exit);
  form.addCommand(choose);
  form.setCommandListener(this);
  display.setCurrent(form);
  }

  public void pauseApp(){}

  public void destroyApp(boolean unconditional){
  notifyDestroyed();
  }

  public void commandAction(Command c, Displayable displayable){
  String label = c.getLabel();
  if (label.equals("Choose")) {
  StringItem message[] = new StringItem[technology.size()];
  boolean get[] = new boolean[technology.size()];
  technology.getSelectedFlags(get);
  for (int i = 0; i < get.length; i++) {
  if (get[i]) {
  message[i] = new StringItem("Your Choice is: ", technology.getString(i));
  form.append(message[i]);
  }
  }
  form.delete(index);
  form.removeCommand(choose);
  } else if (label.equals("Exit")){
  destroyApp(false);
  }
  }
}

java 2 micro edition tutorial of Date Field

2012-06-15T00:08:00.001-07:00

How to insert date field in your form. We are using here two fields DateField (datein and dateout) and initialize a final static variable DATE which is 0. We are taking both DateField variable in to the constructor (DateFieldExample). When application will run, first of all the startApp() method will be called and it will display the form with datein and dateout field. For the specific date we are using here java.util.Date class and java.util.TimeZone class is used to show the format of date.

Tutorial:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;
import java.util.Date;
import java.util.TimeZone;
public class DateFieldExample extends MIDlet{
  private Form form;
  private Display display;
  private DateField datein, dateout;  
  private static final int DATE = 0;

  public DateFieldExample(){
  datein = new DateField("Date In:", DateField.DATE, TimeZone.getTimeZone("GMT"));
  dateout = new DateField("Date Out:", DateField.DATE, TimeZone.getTimeZone("GMT"));
  }

  public void startApp(){
  display = Display.getDisplay(this);
  Form form = new Form("Date Field");
  form.append(datein);
  form.append(dateout);
  display.setCurrent(form);
  }

  public void pauseApp(){
  
  }

  public void destroyApp(boolean destroy){
  notifyDestroyed();
  }
}

java 2 micro edition tutorial of create Contact List

2012-06-15T00:04:00.001-07:00

Creating your phone book. In this example we are taking three SCREEN button ("Next", "New", "Exit") and taking two TextBox ("name", "number"). In the name field user enters name and in number field user enters phone number. When user enters name and click on Next button then number text box will open, now user enters phone number. In case user select "Exit" or "New" the name and number get prints on the console.

When program will run initially, startApp() method will be called. And both "Enter Name" text box and the "Next" button will be displayed. After that if user clicks on next button the commandAction() method will be called that will check, if label is equal to "Next" then number TextBox will appear on the screen that can be used to enter the phone number of user.

Tutorial:


import javax.microedition.lcdui.*;

import javax.microedition.midlet.*;



public class PhoneBookExample extends MIDlet implements CommandListener {

  private Command exit, next, New;

  private TextBox name, number;

  private Display display;

  private String nam, no;

  private Form form;

  

  public PhoneBookExample(){

  next = new Command("Next", Command.SCREEN, 2);

  exit = new Command("Exit", Command.SCREEN, 2);

  New = new Command("New", Command.SCREEN, 2);

  }



  public void startApp(){

  display = Display.getDisplay(this);

  name = new TextBox("Enter Name", "", 30, TextField.ANY);

  name.addCommand(next);

  name.setCommandListener(this);

  number = new TextBox("Enter Number", "", 13, TextField.PHONENUMBER);

  number.addCommand(New);

  number.addCommand(exit);

  number.setCommandListener(this);

  display.setCurrent(name);

  }



  public void pauseApp() {}



  public void destroyApp(boolean unconditional){

  notifyDestroyed();

  }



  public void commandAction(Command c, Displayable s){

  String label = c.getLabel();

  if (label.equals("Exit")){

  nam = name.getString();

  no = number.getString();

  System.out.println("Name = " + name.getString() + ",

  Number = "+ number.getString());

  destroyApp(false);

  } else if (label.equals("Next")){

  number.setString("");

  display.setCurrent(number);

  } else if (label.equals("New")){

  display.setCurrent(name);

  nam = name.getString();

  no = number.getString();

  System.out.println("Name = " + name.getString() + ",

  Number = "+ number.getString());

  name.setString("");

  }

  }

}

java 2 micro edition tutorial of MIDlet Application For Login

2012-06-15T00:01:00.000-07:00

Creating the MIDlet application for user login . All MIDlet applications for the MIDP ( Mobile Information Device Profile) derived from MIDlet class and it play a role as a mediator between the application and the environment in which the application runs. The MIDlet life cycle manage the flow of application. It is in the javax.microedition.midlet package, so import this package in your application.

The javax.microedition.icdui package is used for following classes:

Alert
AlertType
Canvas
ChoiceGroup
Command
DateField
Display
Displayable
Font
Form
Gauge
Graphics
Image
ImageItem
Item
List
Screen
StringItem
TextBox
TextField
Ticker

Give Your LoginID 'xyz' and Password 'xyz' then it call the commandAction where if condition will be executed and it calls a function (validateUser()) which checks whether name and password is equal to 'xyz' or not if it equal to 'xyz' then it executed the showMsg() function which show a congratulation message but if name and password is not equal to 'xyz' then it call tryAgain() function which show the error page like figure below and it return on login page with refresh value.

Tutorial:


import javax.microedition.midlet.MIDlet;

import javax.microedition.lcdui.*;



public class LoginExample extends MIDlet implements CommandListener{

  private Display display;

  private TextField userName,password;

  public Form form;

  private Command login,cancel;

  private Image img, imge, img2;

  

  public LoginExample() {

  form = new Form("Sign in");

  userName = new TextField("LoginID:", "", 30, TextField.ANY);

  password = new TextField("Password:", "", 30, TextField.PASSWORD);

  cancel = new Command("Cancel", Command.CANCEL, 2);

  login = new Command("Login", Command.OK, 2);

  try{

  img = Image.createImage("/logo.png");

  imge = Image.createImage("/front_left1_bad.png");

  img2 = Image.createImage("/Congratulations-1.png");

  }catch(Exception e){

  System.out.println(e.getMessage());

  }  

  }



 public void startApp() {

  display = Display.getDisplay(this);

  try{form.append(img);}catch(Exception e){}

  form.append(userName);

  form.append(password);

  form.addCommand(cancel);

  form.addCommand(login);

  form.setCommandListener(this);

  display.setCurrent(form);

  }



  public void pauseApp() {}



  public void destroyApp(boolean unconditional) {

  notifyDestroyed();

  }



  public void validateUser(String name, String password) {

  if (name.equals(" xyz ") && password.equals("
xyz ")) {

  showMsg();

  } else {

  tryAgain();

  }

  }  



  public void showMsg() {

  Alert success = new Alert("Login Successfully", 

  "Your Login Process is completed!",

   img2, AlertType.INFO);

  success.setImage(img2);

  userName.setString("");

  password.setString("");

  display.setCurrent(success, form);  

  }



  public void tryAgain() {

  Alert error = new Alert("Login Incorrect", "Please

  try again", imge, AlertType.ERROR);

  error.setTimeout(900);

  error.setImage(imge);

  userName.setString("");

  password.setString("");

  display.setCurrent(error, form);

  }

  

  public void commandAction(Command c, Displayable d) {

  String label = c.getLabel();

  if(label.equals("Cancel")) {

  destroyApp(true);

  } else if(label.equals("Login")) {

  validateUser(userName.getString(), password.getString());

  } 

  }

}

Framework in JAVA

2012-06-14T00:25:00.000-07:00

What is Frameworks?

Framework is set of reusable software program that forms the basis for an application. Frameworks helps the programmers to build the application quickly. Earlier it was very hard to develop complex web applications. Now its very easy to develop such application using different kinds of frameworks such as Struts, Struts 2, Hibernate, JSF, Tapestry, JUnit, Log4j, Spring etc.

In Java technology there are so many frameworks that helps the programmers to build complex applications easily. You can choose these frameworks for building your applications.

Software Framework

Framework software in computer system is a layered structure that indicates what kind of program should be built and how they would interrelate to one another. In computer system, a framework is a conceptual structure that sometime includes actual programs, which specify programming interface or offer programming tools for using the frameworks.

java 2 micro edition KXML Parser

2012-06-14T00:01:00.001-07:00

we use "catching parsing events" way to parse the xml. Through 'catching parsing events', the parser traverses the XML data and issues callbacks to a previously registered event listener whenever it encounters particular structures in the data. For example, when the parser encounters an opening tag such as <employee> then the event listener would receive an event notifying it of the encounter and pass it any necessary information. A parser implements such a strategy is called a push parser because the parser is "pushing" the event to a listener.

import java.io.*;
import org.kxml.*;
import org.kxml.parser.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class KXMLParserExample extends MIDlet {
  public String emp = "/employee.xml";
  XmlParser parser = null;

  protected void startApp(){
  try{
  parser = new XmlParser(new 
  InputStreamReader(this.getClass().getResourceAsStream(emp)), 300);   ParseEvent event = null;
  while((event = parser.read()).getType() != Xml.END_DOCUMENT){
  if(event.getType() == Xml.START_TAG){
  String name = event.getName();
  if(name != null && name.equals("details")){
  System.out.println("----------[ EMP-DETAILS ]----------");
  parseAddressTag( parser );
  System.out.println("-----------------------------------\n");
  }
  name = null;
  }
  event = null;
  }
  }catch (IOException ioe){
  System.out.println("XML Parsing Error: " + ioe);
  ioe.printStackTrace();
  }finally{
  parser = null;
  }  
  }

  protected void pauseApp(){}
  
  public void parseAddressTag( XmlParser parser ) throws IOException {
  ParseEvent event = null;
  while ((event = parser.peek()).getType() != Xml.END_DOCUMENT) {
  String name = event.getName();
  int type = event.getType();
  if (type == Xml.END_TAG && name.equals("details")) {
  event = null;
  name = null;
  return;
  }
  event = parser.read();
  if (type != Xml.START_TAG) {
  event = null;
  continue;
  }
  ParseEvent next = parser.read();
  if (next.getType() != Xml.TEXT) {
  event = null;
  next = null;
  continue;
  }
  String text = next.getText();
  System.out.println( name + ": " + text );
  event = null;
  text = null;
  next = null;
  }
  }

  protected void destroyApp(boolean arg){
  notifyDestroyed();
  }
}

employee.xml

<employee>    

        <details>

        <name>Sandeep Kumar Suman</name>

        <designation>J2ME Programmer</designation>

        <city>Gorakhpur</city>

        <state>UP</state>

        </details>

</employee>

java 2 micro edition tutorial of Thread Processing

2012-06-13T23:53:00.001-07:00

How thread works in J2ME application. An application can run multiple activities simultaneously using thread. Here we have defined different states of thread...

The states of Thread is:

running:- Executing code.
ready:- Ready to execute code.
suspended:- Waiting on an external event.
terminated:- Finished executing code.

In the output First of all process() thread will be executed then start() thread and then run() thread will be executed.

Tutorial:

import java.io.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

public class ThreadProcessing extends MIDlet implements CommandListener{
  private Display display;
  private Ticker ticker;
  private Form form; 
  private Command exit, start;

  public ThreadProcessing(){
  form = new Form("Thread Processing");
  ticker = new Ticker ("10/17/2008 3:59:59 PM ACC LTD 489.05 (-6.42%)
BHARTI ARTL 676.80 (-7.47%) BHEL 1,194.80 (-9.00%)
ACC LTD 489.05 (-6.42%)  BHARTI ARTL 676.80 (-7.47%)
 BHEL 1,194.80 (-9.00%) DLF LTD* 291.30 (-10.34%)
 GRASIM INDUSTRIES LTD. 1,293.40 (-5.71%) HDFC BANK LT 1,024.05 (-5.82%)");
  exit = new Command("Exit", Command.EXIT, 1);
  start = new Command("Start", Command.SCREEN, 2);  
  }

  public void startApp(){
  display = Display.getDisplay(this);
  form.addCommand(exit);
  form.addCommand(start );  
  form.setCommandListener(this);
  form.setTicker(ticker);
  display.setCurrent(form);
  }

  public void pauseApp(){ }

  public void destroyApp(boolean unconditional){
  notifyDestroyed();
  }

  public void commandAction(Command c, Displayable displayable){
  String label = c.getLabel();
  if (label.equals("Exit")){
  destroyApp(false);
  }else if (label.equals("Start")){
  Process process = new Process(this);
  process.start(); 
  } 
  }
}

class Process implements Runnable{
  private ThreadProcessing MIDlet;

  public Process(ThreadProcessing MIDlet){ 
  this.MIDlet = MIDlet;
  System.out.println("Thread Process...");
  }

  public void run(){
  try{
  transmit();
  System.out.println("Thread Run...");
  }catch(Exception error){ 
  System.err.println(error.toString());
  }  
  }

  public void start(){
  Thread thread = new Thread(this);
  try{
  thread.start();
  System.out.println("Thread Start...");
  }catch(Exception error){}
  }

  private void transmit() throws IOException{} 

}

java 2 micro edition tutorial of alert

2012-06-13T13:28:00.001-07:00

Sound Alerts using MIDlet in J2ME
This example illustrates how to create alert through sound. In this example we are using AlertType class for the different alert. The AlertType() class has only one method:

playSound(Display display):- This is the boolean type method, it is used to Alert user by playing the sound.

There are different Alert Types in J2ME:

ALARM
CONFIRMATION
ERROR
INFO
WARNING

Tutorial:


import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;



public class SoundAlertExample extends MIDlet implements

ItemStateListener, CommandListener{


  private Display display;  

  private Form form;  

  private Command exit; 

  private ChoiceGroup choice; 



  public void startApp(){



  display = Display.getDisplay(this);

  choice = new ChoiceGroup("List of Sound", Choice.EXCLUSIVE);

  choice.append("Message Tone", null);  

  choice.append("Confirmation Tone", null);  

  choice.append("Warning Tone", null);  

  choice.append("Alarm Tone", null);  

  choice.append("Error Tone", null);  

  exit = new Command("Exit", Command.EXIT, 1);

  form = new Form("");

  form.append(choice);

  form.addCommand(exit);

  form.setCommandListener(this); 

  form.setItemStateListener(this);

  display.setCurrent(form);

  }



  public void pauseApp(){ }



  public void destroyApp(boolean unconditional){

  notifyDestroyed();

  }



  public void commandAction(Command c, Displayable s){

  String label = c.getLabel();

  if(label.equals("Exit")){

  destroyApp(false);

  } 

  }



  public void itemStateChanged(Item item){

  switch (choice.getSelectedIndex()){

  case 0: 

  AlertType.INFO.playSound(display);

  break;



  case 1:

  AlertType.CONFIRMATION.playSound(display);

  break;



  case 2:

  AlertType.WARNING.playSound(display);

  break;

  

  case 3:

  AlertType.ALARM.playSound(display);

  break;



  case 4:

  AlertType.ERROR.playSound(display);

  break;

  }

  }

}

java 2 micro edition tutorial of MIDlet lifecycle

2012-06-13T13:22:00.000-07:00

A MIDlet lifecycle have following steps...

startApp()
pauseApp()
destroyApp()

By default MIDlet is in the paused states. when the application is executed by default startApp() method will call and when close the application the destroyApp() method will be called. But when your constructor is not null type then it will be executed firstly. The source code of life cycle execution is as follows:

Tutorial:


import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;



public class MidletLifecycle extends MIDlet{

  private Form form;



  

  private Display display;



  public MidletLifecycle(){

  System.out.println("MidletLifecycle constructure");

  }



  public void startApp(){

  form = new Form("Midlet Lifecycle");

  display = Display.getDisplay(this);

  String msg = "This is the Lifecycle of Midlet!";

  form.append(msg);

  display.setCurrent(form);

  }



  public void pauseApp(){

  System.out.println("You are in pauseApp()...");

  }



  public void destroyApp(boolean destroy){

  System.out.println("You are in destroyApp()...");

  notifyDestroyed();

  }

}

Figure: MIDlet lifecycle

java 2 micro edition tutorial of Client Server in J2ME (Socket Programming)

2012-06-12T23:51:00.002-07:00

Sockets are different than datagrams because they use a connection-based paradigm to transmit data. This means that both a sender and a receiver must be running and establish a communication channel for data to be exchanged. To use a real-world analogy, a socket connection is like calling a friend on the telephone. If the friend does not answer, a conversation cannot take place. Datagrams on the other hand are more like sending a letter to a friend, where a note is placed into an envelope, addressed, and mailed.

The following code demonstrates how to set up a listener to monitor a port for an inbound socket connection.


try
{
  ServerSocketConnection ssc = (ServerSocketConnection) 
  Connector.open("socket://:9002");
  StreamConnection sc = null;
  InputStream is = null;
  try{
    sc = ssc.acceptAndOpen();    is = sc.openInputStream();
    int ch = 0;
    StringBuffer sb = new StringBuffer();
    while ((ch = is.read()) != -1){
      sb.append((char)ch);
    }
    System.out.println(sb.toString());
  } finally{
      ssc.close();
      sc.close();
      is.close();
  }
} catch (IOException x) {
    x.printStackTrace();
}

In this example a ServerSocketConnection is opened on port 9002. This type of connection is used for sole purpose of listening for an inbound socket connection. The code goes into a wait state when the acceptAndOpen() method is called. When a socket connection is established, the acceptAndOpen() method returns with an instance of a SocketConnection. Opening an input stream on this connection allows data to be read from the transmission.

The next example demonstrates the code required by the client to initiate the socket connection.


try{
  SocketConnection sc = (SocketConnection) 
    Connector.open("socket://localhost:9002");
  OutputStream os = null;
  try{
    os = sc.openOutputStream();
    byte[] data = "Hello from a socket!".getBytes();
    os.write(data);
  } finally{
      sc.close();
      os.close();
  }
} catch (IOException x){
 x.printStackTrace();
}

In this example a SocketConnection is established on port 9002 of the local machine. When using sockets, this is the point on the server side that the acceptAndOpen() method returns. If the connection is successfully opened, the OutputStream is obtained and a message is written to the stream. Note that because sockets are connection based, if there is no server listening for an incoming SocketConnection an exception will be thrown.

java 2 micro edition tutorial of Play a multimedia file (Audio/Video) using MMAPI

2012-06-12T23:45:00.002-07:00

The simplest MMAPI MIDlet that can be built allows you to easily play a multimedia file from within your MIDlet without worrying about controls, feature sets, or security architecture. If all you’re doing is adding some sampled audio (or any other media) in a game, MMAPI allows you to do so in two lines of code. Listing below shows this code within a complete MIDlet.

//A Simple MMAPIMIDlet

import javax.microedition.midlet.MIDlet;
import javax.microedition.media.Manager;
import javax.microedition.media.Player;

public class SimplePlayer extends MIDlet {

public void startApp() {

try {

Player player = Manager.createPlayer(getClass().getResourceAsStream("/media/audio/chapter3/baby.wav"),"audio/x-wav");
player.start();

} catch(Exception e) {
e.printStackTrace();
}

}

public void pauseApp() {

}

public void destroyApp(boolean unconditional) {

}

To keep things simple at this stage, the media file is played by creating an InputStream on a wav file, which is embedded in the MIDlet’s JAR. This media file is kept in the folder and is called baby.wav (which is the sound of a baby crying).

You don’t need to play an audio file only. You can substitute the wav file with a video file, provided the emulator supports the format of the video file. The video will not show anywhere, because this listing doesn’t provide a mechanism to show the video. You can substitute the wav file for a midi, tone, or any other supported audio format. The point is that playing multimedia files using the MMAPI is as simple as creating a Player instance using the Manager class and calling method start() on it.

java 2 micro edition tutorial for send SMS

2012-06-12T23:39:00.000-07:00

A java application, where on making a Push to talk call, and the call does not get matured due the the callers phone being busy in another call, busy in packet data, switched off or not in coverage, the java application installed in the callers phone should send out a sms, automatically to the called number. The number to send the SMS is taken from the phone book for the called number.

Here at at first we created a form called send sms and added commands to exit and send. On clicking the send the control goes to public void sendit(String paramString1, String paramString2). where it first creates a connection with defined addree and and then creates an empty msg of type text. We then added the text that has to be sent and the pass that in the url of the address.

public void startApp()
 {
   this.display = Display.getDisplay(this);
   this.form = new Form("send sms");
   this.text = new TextField("number", "", 256, 0);
   this.send = new Command("send", 4, 1);
   this.exit = new Command("exit", 3, 2);
   this.form.append(this.text);
   this.form.addCommand(this.send);
   this.form.addCommand(this.exit);
   this.form.setCommandListener(this);
   this.display.setCurrent(this.form);
 }

 public void pauseApp()
 {
 }

 public void destroyApp(boolean paramBoolean)
 {
 }

 public void commandAction(Command paramCommand, Displayable
paramDisplayable) {
   if (paramCommand == this.exit) {
     notifyDestroyed();
   }
   if (paramCommand == this.send) {
     this.number = this.text.getString();
     System.out.println("in loop" + this.number);
     this.message1 = "please call me back";
     sendit(this.message1, this.number);
   }
 }

 public void sendit(String paramString1, String paramString2)
 {
   this.phoneNumber = paramString2;
   this.message = paramString1;
   StringBuffer localStringBuffer = new StringBuffer(20);

   String str = "sms://" + paramString2 ";

   this.form2 = new Form("");
   MessageConnection localMessageConnection = null;
   try
   {
     localMessageConnection = (MessageConnection)Connector.open(str);

     TextMessage localTextMessage =
(TextMessage)localMessageConnection.newMessage("text");
     localTextMessage.setAddress(str);
     localTextMessage.setPayloadText(paramString1);
     localMessageConnection.send(localTextMessage);

     this.form2.append("message sent");
     this.display.setCurrent(this.form2);
   }
   catch (Exception localException) {
     this.form2.append("phone number" + str + localException.getMessage());
     this.display.setCurrent(this.form2);
   }
 }

how to use Constructors in java?

2012-06-11T07:31:00.000-07:00

When you create an object, you use the new operator to instantiate an object from a class. A String is

an object, so you might write:

String s = new String();

This statement creates a new, empty string. The second occurrence of the word String is a call to a

special method known as a constructor. The constructor's name is always the same as the class

name. Java allows you to have multiple methods with the same name (as long as they have different

parameters), so one class can have many different constructors.

As with any method, you can also provide arguments for this special constructor. You could write:

String s = new String("jExpertize");

When you write your own classes, you'll provide a constructor for every case you want to handle. If

you don't provide any constructors, Java creates a default constructor (a constructor method with no

arguments) for you. If you provide any constructor, however, Java won't add a default for you; you'll

have to code it if you want a default constructor. Of course, some objects always require construction

arguments and therefore don't have default constructors.

java 2 micro edition tutorial of Internet Calling using SIP

2012-06-11T07:11:00.000-07:00

The Session Initiation Protocol (SIP) is a signaling protocol used for establishing and controlling multimedia communication sessions on networks that use the Internet Protocol (IP). A session may be as simple as a two-way phone call or as complex as a collaborative video conference. SIP was primarily designed to establish, modify, and terminate sessions, and therefore doesn't know about the details within a session. This simplicity makes SIP quite scalable and extensible, and it can be used easily in different architectures and deployment scenarios. SIP is already being used for all kinds of innovative applications and services, and its importance in mobile networks will continue to grow. In addition, now that MIDP 2.0 has included support for TCP/IP sockets and UDP/IP datagrams, SIP will become an important protocol in IP-based mobile phone environments.

This expectation that SIP will play a rapidly growing role in the mobilility space led to the development of the SIP API for J2ME (JSR 180) within the Java Community Process (JCP). The motive behind the initiative was to define a single standard SIP interface with strong security early, before competing standards, with less robust security models, could gain wide acceptance.

After an overview of SIP, this article:

Presents a tutorial that introduces SIP API for J2ME
Describes how to download, install, and run the JSR 180 reference implementation, available from Nokia
Discusses how to develop MIDlets that use SIP API for J2ME
Demonstrates how to compile SIP MIDlets using the J2ME Wireless Toolkit
Offers a taste of the effort involved in developing SIP MIDlets

Overview of Session Initiation Protocol

The Session Initiation Protocol (SIP) was defined by the Internet Engineering Task Force (IETF), in collaboration with the Third Generation Partnership Project (3GPP), as RFC 2543, later superseded by RFC 3261. It's a request-response protocol, just like HTTP, so using it makes telephony just another web application, which can be integrated into Internet applications and services easily.

3GPP has specified SIP to be the network protocol of choice for the all-IP packet-switched third-generation network. The IP Multimedia Subsystem (IMS) represents the architecture defined in 3GPP Releases 5 and 6 for SIP-based 3G networks. Within the IMS network, mobile terminals establish voice calls using the SIP protocol. SIP is used for managing sessions between two or more IP endpoints. It defines user agents that initiate and respond to SIP requests, and proxies that route SIP messages to their destinations. This scheme leads to a host of innovative services: voice-based e-commerce, web-page click-to-dial, location services, and many more. In addition, it can be used to provide instant messaging, presence, and gaming services.

JSR 180: SIP API for J2ME

JSR 180 defines an optional package that provides a general SIP API for J2ME clients, so that SIP applications can operate in devices with limited memory. This interface enables Java-enabled mobile devices to send and receive SIP messages. The API is compact, so it has a small footprint, and generic, so you can use it with any J2ME profile, not just MIDP. As a minimum, it requires version 1.0 of the Connected Limited Device Configuration (CLDC), but the APIs can be used with the Connected Device Configuration (CDC) as well. It provides SIP functionality at the transaction level; it's integrated into CLDC's Generic Connection Framework (GCF).

The APIs are defined in the package javax.microedition.sip. This package contains eight interfaces and four classes:

Interfaces	Description
`SipConnection`	The base interface for SIP connections; holds the common properties and methods for subinterfaces `SipClientConnection` and `SipServerConnection`.
`SipClientConnection`	Represents a SIP client transaction. An application can create a new `SipClientConnection` using `javax.microedition.io.Connector` or `SipDialog`.
`SipServerConnection`	Represents a SIP server transaction; created by the `SipConnectionNotifier` when a new request is received.
`SipConnectionNotifier`	Defines a SIP server connection notifier, which queues incoming messages. To receive incoming requests, applications use this interface's `acceptAndOpen()` method, which accepts and opens a new `SipServerConnection`. If there are no messages in the queue, the method blocks until a new request is received.
`SipServerConnectionListener`	A listener interface for incoming SIP requests.
`SipClientConnectionListener`	A listener interface for incoming SIP responses.
`SipDialog`	Represents one SIP dialog. The `SipDialog` can be retrieved from a `SipConnection` object when it's available, which happens after an `INVITE` or `SUBSCRIBE` request.
`SipRefreshListener`	A listener interface for the `RefreshHelper` class; declares a `refreshEvent()` method that takes a `refreshID` to identify the corresponding refresh task, and a `statusCOde` representing the result of the refresh: `0` for cancellation, `200` for success, and anything else for failure.

Classes	Description
`SipAddress`	Provides a generic SIP address parser. It can be used to parse a SIP address, or to construct one.
`SipHeader`	Provides a generic SIP header parser helper. It can be used to parse string header values read from SIP messages, or to construct SIP headers.
`SipRefreshHelper`	Implements the functionality that facilitates the handling of refreshing requests on behalf of the application.
`SipException`	An exception class for SIP-specific errors.

SIP API for J2ME is meant to be used by applications that need to implement SIP user-agent functionality. They can use SipClientConnection to implement a SIP user-agent client, and use SipConnectionNotifier and SipServerConnection to implement a SIP user-agent server. A mobile device may act as a SIP client sending requests to SIP servers, and also as a SIP server accepting requests from SIP clients, as Figure 1 illustrates:

Figure 1: Mobile Devices Acting as Both Clients and Servers

The SIP APIs are integrated into CLDC's Generic Connection Framework. For example, an application instantiates a new SIP connection by calling Connector.open(), which will return either a SipClientConnection or a SipServerConnection, depending on the SIP URI passed to open(). Your application should call the Connector.close() method when it has finished with the connection.

The SIP URI has the following syntax...

{scheme}:[{target}][{params}]

...where:

scheme is the SIP scheme supported by the system, sip or sips. In the sips protocol, the server connection accepts only requests over secure transport, as defined in the RFC 3261 standard.
target is the user address, which can be something like userName@target-host.com:portNumber or just a phone number.
params represents additional parameters; for example, transport=udp to specify UDP as the transport protocol.

If the target host is included, a new client connection is opened; if it's not, a new server connection is opened. Here are some examples:

...
// client connections
SipClientConnection scc = (SipClientConnection)
    Connector.open("sip:max@company.com");
SipClientConnection scc2 = (SipClientConnection)
    Connector.open("sip:jack@128.11.1.2:5100");
...

...
// server connection
SipConnectionNotifier scn = (SipConnectionNotifier)
    Connector.open("sip:5500");
...

...
// server connection where the port number is allocated by the system
SipConnectionNotifier scn2 = (SipConnectionNotifier)
    Connector.open("sip:");
...

The following method demonstrates how to open a SIP client connection to a server that's running on host 102.12.1.1 and listening on port 5050.

private void sendMessage(String message) {
    SipClientConnection sc = null;
    try {
        // open SIP connection to server 102.12.1.1 on port 5050
        sc = (SipClientConnection)
            Connector.open(sip:user@102.12.1.1:5050);
        // initialize SIp request MESSAGE
        sc.initRequest("MESSAGE", null);
        // set the message header
        sc.setHeader("Subject", subject.getString());
        sc.setHeader("Content-Type", "text/plain");
        sc.setHeader("Content-Length", ""+text.length());
        // send the message to the network
        OutputStream os = sc.openContentOutputStream();
        os.write(message.getBytes());
        os.close(); // close the connection
    } catch(Exception ex) {
        ex.printStackTrace();
    }
}

The next code segment implements the notifyRequest() method of the SipServerConnectionListener interface. When the server receives the initialization SIP request MESSAGE, it retrieves the headers of the message and its content, then sends a response back to the client.

public void notifyRequest(SipConnectionNotifier scn) {
   try {
      ssc = scn.acceptAndOpen();
      if(ssc.getMethod().equals("MESSAGE")) {
         String contentType = ssc.getHeader("Content-Type");
         String contentLength = ssc.getHeader("Content-Length");
         int length = Integer.parseInt(contentLength);
         if((contentType != null) && contentType.equals("text/plain")) {
            InputStream is = ssc.openContentInputStream();
            int i=0;
            byte testBuffer[] = new byte[length];
            i = is.read(testBuffer);
            String tmp = new String(testBuffer, 0, i); 
               // the message received
         }
         ssc.initResponse(200); // OK
         ssc.send();
      }    
   } catch(IOException ex) {
      // ex.getMessage();
   }
}

Programming SIP MIDlets

A good way to learn how to develop SIP MIDlets is by adapting existing MIDlets. SipMIDlet, which comes with the reference implementation, shows how to open a connection to a SIP server, send messages, and receive replies:

import java.util.*;
import java.io.*;
import javax.microedition.io.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

import javax.microedition.sip.*;

public class SipMIDlet extends MIDlet
    implements CommandListener, SipServerConnectionListener  {

    private Display display;
    private long startTime;
    private Form form;
    private TextField receivePort;
    private Command receiveCmd;
    private Command exitCmd;
    SipConnectionNotifier scn = null;
    SipServerConnection ssc = null;

    public SipMIDlet() {
        System.out.println("MIDlet: SipMIDlet starting...");
        display=Display.getDisplay(this);
        form = new Form("Receive Message");
        receivePort = new TextField
            ("Give receive port:", "sip:5060", 30,
            TextField.LAYOUT_LEFT);
        form.append(receivePort);
        receiveCmd = new Command("Start", Command.ITEM, 1);
        exitCmd = new Command("Exit", Command.EXIT, 1);
        form.addCommand(receiveCmd);
        form.addCommand(exitCmd);
        form.setCommandListener(this);
    }
    
    public void commandAction(Command c, Displayable d) {
        if(c == receiveCmd) {
            Thread t = new Thread() {
                public void run() {
                receiveMessage();
                }
            };
            t.start();
        }
        if(c == exitCmd) {
            if(scn != null) {
                try {
                    scn.close();
                }
                catch(IOException iox) {
                }
            }
            destroyApp(true);
        }
    } 
    
    public void startApp() {
        display.setCurrent(form);    
        System.out.println("MIDlet: SipMIDlet startApp()");
    }
    
    public void receiveMessage() {
        try {
            if(scn != null)
            scn.close();
            scn = (SipConnectionNotifier)
                Connector.open(receivePort.getString());
            scn.setListener(this);
            form.append("Listening... in port: "+scn.getLocalPort());
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }
    
    public void notifyRequest(SipConnectionNotifier scn) {
        try {
            ssc = scn.acceptAndOpen();
            if(ssc.getMethod().equals("MESSAGE")) {
            String contentType = ssc.getHeader("Content-Type");
            String contentLength = ssc.getHeader("Content-Length");
            int length = Integer.parseInt(contentLength);
            if((contentType != null) &&
                contentType.equals("text/plain")) {
                InputStream is = ssc.openContentInputStream();
                int i=0;
                byte testBuffer[] = new byte[length];
                i = is.read(testBuffer);

                String tmp = new String(testBuffer, 0, i);

                StringItem st = new StringItem
                    ("Subject:", ssc.getHeader("Subject"));
                form.append(st);
                st = new StringItem("Message:", tmp);
                form.append(st);
            }
            ssc.initResponse(200);
            ssc.send();
        }
        
        } catch(IOException ex) {
            form.append("Exception: "+ex.getMessage());
        }
    
    }
    
    public void pauseApp() {
        System.out.println("MIDlet: pauseApp()");
    }

    public void destroyApp(boolean b) {
        System.out.println("MIDlet: destroyApp()");
        notifyDestroyed();
    }   
}

Using the J2ME Wireless Toolkit to Develop SIP MIDlets

The easiest way to build SIP MIDlets is to use the J2ME Wireless Toolkit. Note that even the latest release of the toolkit, version 2.2, doesn't support SIP APIs for J2ME and therefore can't actually run MIDlets that use them. You can, however, configure the Wireless Toolkit so that it can build MIDlets that use the SIP APIs for J2ME, then test the MIDlets in the Nokia emulator that comes with the JSR 180 RI. This section shows you how.

Once you have J2ME Wireless Toolkit 2.2 installed, the key task is to copy the SIP APIs that come with the Nokia reference implementation into the toolkit's midp20api.jar file. Use your favorite archiving tool; for example, many Windows users would use WinZip, thus:

In WinZip, open /<pathToSIPROOT>/lib/sipa1_0.jar.
In a second WinZip window, open /<wtk22>/lib/midp20.jar.
Drag and drop the classes from sipa1_0.jar to midpapi20.jar.
Close both archives.

Now run the J2ME Wireless Toolkit. Create a project to build SipMIDlet, and call it whatever you like – MySIP in my example. Because you cannot run the SIP MIDlet in the toolkit's emulator, and the RI's emulator supports only CLDC 1.1 and MIDP 2.0, you should configure the project settings as in this dialog:

Other SIP-related JSRs

Within the JCP, a number of JSRs have resulted in standard SIP APIs: JAIN SIP API Specification (JSR 32) specifies a standard interface to share information between SIP clients and SIP servers. SIP Servlet API (JSR 116) defines a high-level extension interface to enable SIP servers to deploy and manage SIP applications based on the servlet model. Finally, JSR 180 defines a general SIP API for J2ME clients, to make it possible for SIP applications to run in devices with limited memory.

Conclusion

The SIP protocol was designed with the Internet in mind. With its request-response model, it resembles HTTP and other Internet protocols. As a result, telephony simply becomes another web application that can be integrated into other applications and services easily. Compared to legacy mobile-network protocols, SIP is easy to program to, so it will become an important tool for establishing communication sessions. It can be used to implement all kinds of peer-to-peer applications that feature voice, video, messaging, and gaming.

This article presented an overview of SIP, and a tutorial on SIP API for J2ME. The sample code showed how little effort is required to develop SIP applications; there's only a handful of classes and interfaces you need to learn about to get started. Following the instructions in this article, you should find it easy to configure your J2ME Wireless Toolkit to serve as your development environment for SIP MIDlets.

how to use Extending Objects in java

2012-06-10T03:52:00.003-07:00

Many times you need to create an object that is almost like an existing object but with slight differences. In this situation, you can extend the existing object. When you extend an object, you inherit all of its members marked as public (unless you choose to override them). You can also add new public members. In addition, your new class can access items in the original class marked as protected (but not private).

For example, suppose the simple class from the last example (T) is almost what you need, but you want another method to print the string in uppercase. You can write:

class Tupper extends T
{
public Tupper(String s)

{
super(s); // chain constructor
}
public void printMsgUpper()
{
System.out.println(msg.toUpperCase());
}
}
In this case, you say that class Tupper extends T. That makes T the base class for Tupper , and Tupper derives from T.

This new class is just like T but includes an extra method. The Tupper class has the same members as the T class (except for the constructor). Notice that each class must provide its own constructors (unless the base class has a default constructor).

You could just as easily replace printMsg with a new version instead of creating a new method. For example:

class Tupper extends T
{
public Tupper(String s)
{
super(s); // chain constructor
}
public void printMsg()
{
System.out.println(msg.toUpperCase());
}
}

The super keyword refers to the base class. As a special case, you can use this keyword as the first line in a constructor to call a particular constructor in the base class. You can also use this keyword anywhere in any method to access methods in the base class. For example:

public void printMsg()
{

super.printMsg();
System.out.println(msg.toUpperCase());
}
This is a good example of polymorphism. Consider this main method:
public static void main(String [] args)
{
T test = new Tupper("Black Book");
test.printMsg();
}

how to use throw Statement in java

2012-06-10T03:46:00.003-07:00

A throw statement forces an exception. This transfers control to the next try-catch statement that matches the object named in the throw statement. The following code shows you how to use it:

throw e; //e is a class derived from Throwable Executing a throw statement exits the enclosing block. Here's an example:
try
{

return cons.newInstance(new Object[] { string });
} catch (Throwable ex)
{
throw new ParseException("Error creating instance", 0);
}

how to use try-catch-finally Statement in java

2012-06-10T03:44:00.001-07:00

You can add a finally block to a try block. When the block under the try statement exits for any reason (including a normal exit), the finally block executes.

The following is an adaptation from a finally statement used in Java's Timer class:

public void run()
{
try
{

mainLoop();
} finally
{// Dead Thread, behave as if Timer cancelled
synchronized(queue)
{
newTasksMayBeScheduled = false;
queue.clear(); // Eliminate obsolete references
}
}
}

how to use return statement in java

2012-06-10T03:42:00.002-07:00

Use return to terminate the current method. The return statement terminates a method and (optionally) sends back a value to the calling statement. You'll see more about the returnType method when you start to write your own methods.

The following program computes the length of the hypotenuse of a right triangle, where the sides of the triangle are side_1 and side_2 . The return statement returns the length as a double data type:

static double computePythagorus(double side_1, double side_2)
{
double hypotenuse = 0D;
hypotenuse = Math.sqrt(side_1 * side_2 + side_2 * side_2);
return hypotenuse;
}

How to use break and continue statement in java?

2012-06-09T01:28:00.003-07:00

Using the break Statement:

The break statement is used to exit a block contained within a switch, while, do, or for statement. By
default, execution continues after the controlling statement. For example, this loop will exit if the loop
variable becomes negative:

for (;i==5;i--)
{
if (i<0) break;
// other statements here
}

Presumably, this break statement will prevent the problem in which i was less than 5 already. When i
becomes negative, the break statement will cause Java to stop executing the loop.

You can also break out of multiple loops by using a label (see the "Using Labeled Statements"
section).

Using the continue Statement:

The continue statement is used to skip the current iteration of a for , while, or do loop. When Java
encounters a continue statement, it short-circuits the current loop and moves to the next iteration.

For example, consider this loop:

for (int i=1;i<=3;i++)
{
if (i==2) continue;
System.out.println(i);
}

This loop will print only 1 and 3. When i is 2, the continue statement causes the loop to skip that
iteration.

Sometimes when multiple loops are nested, you'll want to continue an outer loop from within an inner
loop. You can do that with labels.

how to use the for loop or statement in java?

2012-06-09T01:24:00.003-07:00

You should use the for statement when you have a definite number of times you want to execute a
loop. This statement includes three sections: initialization, condition, and update. A for statement
should have the following form:

for (initialization; condition; update)
{
statements;
}

When Java first encounters a for statement, it executes the initialization clause. This can set an
initial value for a loop variable (i=0, for example), or you can declare a unique variable for the loop and
initialize it (int i=0). If you declare a variable here, its scope is just the body of the loop.

The next step is to evaluate the condition expression. If the condition is false, the loop does not
execute. Java repeats this test when the loop repeats.

If the body of the loop executes, the update clause evaluates at the end of the block, and then Java
tries the condition expression again. If the condition is true, the block repeats. If the expression is
false, the loop is over; Java skips the block and continues execution. This loop will print the numbers 1
to 10 on the console:

for (int i=1; i<=10; i++) System.o ut.println(i);

The following program demonstrates using a for loop to march through the characters of a string to
build a hash value for the string:

public class stringHashCode
{
public static void main(String[] args)
{
String stringToHash = args[0];
char stringChar[] = stringToHash.toCharArray();
int hashcode = 0, count = 0;
int len = stringToHash.length();
for (int index = 0; index < len; index++)
{
hashcode = 31*hashcode + stringChar[count++];
}
String output = "Hashcode for " + stringToHash +
" = " + stringToHash.hashCode() + "\n";
output += "Java native hashcode = " + hashcode + "\n";
output += " our hashcode = " + hashcode ;
System.out.println( output );
}
}

//returns:
//Hashcode for john = 3267851
//Java native hashcode = 3267851
// our hashcode = 3267851

You don't have to specify all three parts of the for loop if you don't want to. For example, if the loop is
already initialized, you can omit the initialization clause:

for (;i<10;i++) . . .

Of course, that assumes that i and any other variables you need are already set before you enter the
loop. You can even omit all three clauses if you want to loop forever (or until a break statement
occurs, which is the topic of the next section):

for (;;;) go(); // execute forever.

in java Replacing if with the Conditional Operator

2012-06-09T01:22:00.002-07:00

Conditional Operator?:

It is very common to use an if statement to set a variable to one of two values based on some logical
expression. For example:

if (firstValue < secondValue)
{
minimumValue = firstValue;
} else
{
minimumValue = secondValue;
}

This construction is used so often that Java has a shortcut notation for it. The shortcut is called the
conditional operator , having the fo rm:

answer = (expression) ? returnThisIfTrue : returnThisIfFalse;

The expression must return a boolean value. The returnThisIfTrue and returnThisIfFalse
expressions must yield a value of the same data type as the answer variable. We can replace the
previous if statement with a conditional operator:

minimumValue = (firstValue < secondValue) ? firstValue : secondValue;

The following example is adapted from Java's Short class. A string is converted to a short integer by
using one procedure for a positive number and another procedure for a negative number:

shortValue = negative ? new Short((short)-inputString.shortValue()) : new Short((short)inputString.shortValue());