Java Concepts

Comments are almost like C++
The javadoc program generates HTML API
documentation from the “javadoc” style comments in
your code.
/* This kind comment can span multiple lines */
// This kind is of to the end of the line
/* This kind of comment is a special
* ‘javadoc’ style comment
*/

JAVA Classes
The class is the fundamental concept in JAVA (and other
OOPLs)
A class describes some data object(s), and the operations
(or methods) that can be applied to those objects
Every object and method in Java belongs to a class
Classes have data (fields) and code (methods) and classes
(member classes or inner classes)
Static methods and fields belong to the class itself
Others belong to instances

An example of a class
class Person { Variable
String name;
int age; Method
void birthday ( )
{
age++;
System.out.println (name +
' is now ' + age);
}
}

Scoping
As in C/C++, scope is determined by the placement of curly braces {}.
A variable defined within a scope is available only to the end of that scope.
{ int x = 12;
/* only x available */
{ int q = 96;
/* both x and q available */
}
/* only x available */
/* q “out of scope” */
}
{ int x = 12;
{ int x = 96; /* illegal */
}
}
This is ok in C/C++ but not in Java.

Scope of Objects
Java objects don’t have the same lifetimes as
primitives.
When you create a Java object using new, it hangs
around past the end of the scope.
Here, the scope of name s is delimited by the {}s
but the String object hangs around until GC’d
{
String s = new String("a string");
} /* end of scope */

Java methods and variables can be declared static
These exist independent of any object
This means that a Class’s
 static methods can be called even if no objects of that
class have been created and
 static data is “shared” by all instances (i.e., one rvalue
per class instead of one per instance
class StaticTest {static int i = 47;}
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
// st1.i == st2.I == 47
StaticTest.i++; // or st1.I++ or
st2.I++
// st1.i == st2.I == 48

public class Circle {public class Circle {
// A class field// A class field
public static final double PI= 3.14159; // A usefulpublic static final double PI= 3.14159; // A useful
constantconstant
// A class method: just compute a value based on the// A class method: just compute a value based on the
argumentsarguments
public static double radiansToDegrees(double rads) {public static double radiansToDegrees(double rads) {
return rads * 180 / PI;return rads * 180 / PI;
}}
// An instance field// An instance field
public double r; // The radius of thepublic double r; // The radius of the
circlecircle
// Two methods which operate on the instance fields of// Two methods which operate on the instance fields of
an objectan object
public double area() { // Compute the area ofpublic double area() { // Compute the area of
the circlethe circle
return PI * r * r;return PI * r * r;
}}
public double circumference() { // Compute thepublic double circumference() { // Compute the
circumference of the circlecircumference of the circle
return 2 * PI * r;return 2 * PI * r;
}}
}}

Array Operations
Subscripts always start at 0 as in C
Subscript checking is done automatically
Certain operations are defined on arrays of objects,
as for other classes
 e.g. myArray.length == 5

An array is an object
Person mary = new Person ( );
int myArray[ ] = new int[5];
int myArray[ ] = {1, 4, 9, 16, 25};
String languages [ ] = {"Prolog", "Java"};
Since arrays are objects they are allocated dynamically
Arrays, like all objects, are subject to garbage collection
when no more references remain
 so fewer memory leaks
 Java doesn’t have pointers!

NSIT ,Jetalpur
 C:UMBC331java>type echo.java
 // This is the Echo example from the Sun tutorial
 class echo {
 public static void main(String args[]) {
 for (int i=0; i < args.length; i++) {
 System.out.println( args[i] );
 }
 }
 }
 C:UMBC331java>javac echo.java
 C:UMBC331java>java echo this is pretty silly
 this
 is
 pretty
 silly
 C:UMBC331java>

NSIT ,Jetalpur
/* This program computes the factorial of a number
*/
public class Factorial { // Define a class
public static void main(String[] args) { // The program starts
here
int input = Integer.parseInt(args[0]); // Get the user's
input
double result = factorial(input); // Compute the
factorial
System.out.println(result); // Print out the
result
} // The main() method
ends here
public static double factorial(int x) { // This method
computes x!
if (x < 0) // Check for bad input
return 0.0; // if bad, return 0
double fact = 1.0; // Begin with an
initial value
while(x > 1) { // Loop until x equals
fact = fact * x; // multiply by x
each time
x = x - 1; // and then
decrement x

NSIT ,Jetalpur
Classes should define one or more methods to create or
construct instances of the class
Their name is the same as the class name
 note deviation from convention that methods begin with lower
case
Constructors are differentiated by the number and
types of their arguments
 An example of overloading
If you don’t define a constructor, a default one will be
created.
Constructors automatically invoke the zero argument
constructor of their superclass when they begin (note
that this yields a recursive process!)

values
Java methods are like C/C++ functions.
General case:
returnType methodName ( arg1, arg2, … argN)
{
methodBody
}
The return keyword exits a method optionally with a value
int storage(String s) {return s.length() * 2;}
boolean flag() { return true; }
float naturalLogBase() { return 2.718f; }
void nothing() { return; }
void nothing2() {}

Java Concepts

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java Concepts (20)

More from AbdulImrankhan7 (20)

Recently uploaded (20)

Java Concepts