First Program
First program in java
 |
| First program in java |
you should have IDE mean NetBeans or eclipse with compiler.
copy the code in to the java empty file in IDE and click Run the program
/* This is a simple Java program. Call this file "Example.java". */ class Example { // Your program begins with a call to main(). public static void main(String args[]) { System.out.println("This is a simple Java program."); } } |
A Closer Look at the First Sample Program
Although Example.java is quite short, it includes several key features that are common to all Java programs. Let’s closely examine each part of the program. The program begins with the following lines:/* This is a simple Java program.
Call this file "Example.java". */
This is a comment. Like most other programming languages, Java lets you enter a remark into
a program’s source file. The contents of a comment are ignored by the compiler. Instead, a
comment describes or explains the operation of the program to anyone who is reading its
source code. In this case, the comment describes the program and reminds you that the source
file should be called Example.java Of course, in real applications, comments generally explain
how some part of the program works or what a specific feature does.
Java supports three styles of comments. The one shown at the top of the program is called
a multiline comment. This type of comment must begin with /* and end with */. Anything
between these two comment symbols is ignored by the compiler. As the name suggests, a
multiline comment may be several lines long.
The next line of code in the program is shown here:
class Example {
This line uses the keyword class to declare that a new class is being defined. Example is an
identifier that is the name of the class. The entire class definition, including all of its members,
will be between the opening curly brace ({) and the closing curly brace (}). For the moment,
don’t worry too much about the details of a class except to note that in Java, all program
activity occurs within one. This is one reason why all Java programs are (at least a little bit)
object-oriented.
The next line in the program is the single-line comment, shown here:
// Your program begins with a call to main().
This is the second type of comment supported by Java. A single-line comment begins with
a // and ends at the end of the line. As a general rule, programmers use multiline comments
for longer remarks and single-line comments for brief, line-by-line descriptions. The third
type of comment, a documentation comment, will be discussed in the “Comments” section later
in this chapter.
The next line of code is shown here:
public static void main(String args[]) {
This line begins the main( ) method. As the comment preceding it suggests, this is the line
at which the program will begin executing. All Java applications begin execution by calling
main( ). The full meaning of each part of this line cannot be given now, since it involves
a detailed understanding of Java’s approach to encapsulation. However, since most of the
examples in the first part of this article will use this line of code, let’s take a brief look at each
part now.
The public keyword is an access specifier, which allows the programmer to control the
visibility of class members. When a class member is preceded by public, then that member
may be accessed by code outside the class in which it is declared. (The opposite of public
is private, which prevents a member from being used by code defined outside of its class.)
In this case, main( ) must be declared as public, since it must be called by code outside of
its class when the program is started. The keyword static allows main( ) to be called without
having to instantiate a particular instance of the class. This is necessary since main( ) is
called by the Java Virtual Machine before any objects are made. The keyword void simply
tells the compiler that main( ) does not return a value. As you will see, methods may also
return values. If all this seems a bit confusing, don’t worry. All of these concepts will be
discussed in detail in subsequent chapters.
As stated, main( ) is the method called when a Java application begins. Keep in mind that
Java is case-sensitive. Thus, Main is different from main. It is important to understand that
the Java compiler will compile classes that do not contain a main( ) method. But java has no
way to run these classes. So, if you had typed Main instead of main, the compiler wouldstill compile your program. However, java would report an error because it would be unable
to find the main( ) method.
Any information that you need to pass to a method is received by variables specified
within the set of parentheses that follow the name of the method. These variables are called
parameters. If there are no parameters required for a given method, you still need to include
the empty parentheses. In main( ), there is only one parameter, albeit a complicated one. String
args[ ] declares a parameter named args, which is an array of instances of the class String.
(Arrays are collections of similar objects.) Objects of type String store character strings. In this
case, args receives any command-line arguments present when the program is executed.
This program does not make use of this information,
The last character on the line is the {. This signals the start of main( )’s body. All of the
code that comprises a method will occur between the method’s opening curly brace and its
closing curly brace.
One other point: main( ) is simply a starting place for your program.
A complex program
will have dozens of classes, only one of which will need to have a main( ) method to get
things started. When you begin creating applets—Java programs that are embedded in web
browsers—you won’t use main( ) at all, since the web browser uses a different means of
starting the execution of applets
The next line of code is shown here. Notice that it occurs inside main( ).
System.out.println("This is a simple Java program.");
This line outputs the string “This is a simple Java program.” followed by a new line on the
screen. Output is actually accomplished by the built-in println( ) method. In this case, println( )
displays the string which is passed to it. As you will see, println( ) can be used to display
other types of information, too. The line begins with System.out. While too complicated to
explain in detail at this time, briefly, System is a predefined class that provides access to the
system, and out is the output stream that is connected to the console.
As you have probably guessed, console output (and input) is not used frequently in
most real-world Java programs and applets. Since most modern computing environments
are windowed and graphical in nature, console I/O is used mostly for simple utility
programs and for demonstration programs. Later in this site article, you will learn other ways to
generate output using Java. But for now, we will continue to use the console I/O methods.
Notice that the println( ) statement ends with a semicolon. All statements in Java end
with a semicolon. The reason that the other lines in the program do not end in a semicolon
is that they are not, technically, statements.
The first } in the program ends main( ), and the last } ends the Example class definition.
Related Topics:
No comments:
Post a Comment
We are happy for leaving comments,we will don't let you bite stay with us