Introduction to Java

With the invention of microprocessors, the world is scientifically developed with sophisticated equipment,
systems, and devices. Microprocessors are used in computers, televisions, and fax machines. Even the
hand-held devices such as pagers, PDAs (Personal Digital Assistant), and cell phones make use
of microprocessors. All these electronic devices are helpful because of their communication
capabilities. With the increasing capabilities and decreasing cost of information processing and
networking technologies, the network is growing rapidly for transmitting information through electronic
systems.

Internet is the network of networks between different types of computers located at different
places to transmit information. Information can reach to any place in the world quickly at a cheaper
rate through the Internet. Thus, the Internet has made the world a global village for information exchange.
The emerging infrastructure of electronic devices and interconnected computer networks create an
environment that presents new challenges to software industries. for this emerging computing
environment, Java process to be a well – suited programming language. it is found suitable for
networked environments involving a great variety of computer and devices.

Java has many characteristics that have contributed to its popularity:

➢ Platform independence - Many languages are compatible with only one platform. Java was
specifically designed so that it would run on any computer, regardless if it was running
Windows, Linux, Mac, Unix or any of the other operating systems.
➢ Simple and easy to use - Java's creators tried to design it so code could be written efficiently
and easily.
➢ Multi-functional - Java can produce many applications from command-line programs to applets
to Swing windows (basically, sophisticated graphical user interfaces).

Java does have some drawbacks. Since it has automated garbage collection, it can tend to use more
memory than other similar languages. There are often implementation differences on different
platforms, which have led to Java being described as a "write once, test everywhere" system. Lastly,
since it uses an abstract "virtual machine", a generic Java program doesn't have access to the Native
API's on a system directly. None of these issues are fatal, but it can mean that Java isn't an
appropriate choice for a particular piece of software.

7
 The Java Platform
One thing that distinguished Java from some other languages is its ability to run the same compiled
code across multiple operating systems. In other languages, the source code (code that is written
by the programmer), is compiled by a compiler into an executable file. This file is in machine language,
and is intended for a single operating system/processor combination, so the programmer would have to re-
compile the program separately for each new operating system/processor combination. Java is different
in that it does not compile the code directly into machine language code. Compilation creates bytecode
out of the source code. Bytecode generally looks something like this:

a7 f4 73 5a 1b 92 7d

When the code is run by the user, it is processed by something called the Java Virtual Machine (JVM).
The JVM is essentially an interpreter for the bytecode. It goes through the bytecode and runs it. There
are different versions of the JVM that are compatible with each OS and can run the same code. There
is virtually no difference for the end-user, but this makes it a lot easier for programmers doing software
development.

Java and Open Source:-

➢ In 2006 Sun started to make Java available under the GNU General Public License
(GPL). Oracle continues this project called OpenJDK.

Java Virtual machine :-

➢ The Java virtual machine (JVM) is a software implementation of a computer that
executes programs like a real machine.
➢ The Java virtual machine is written specifically for a specific operating system, e.g. for
Linux a special implementation is required as well as for Windows.
➢ Java programs are compiled by the Java compiler into bytecode. The Java virtual machine
interprets this bytecode and executes the Java program.

Java Runtime Environment vs. Java Development Kit

➢ A Java distribution comes typically in two flavors, the Java Runtime Environment (JRE) and
the Java Development Kit (JDK).
➢ The Java runtime environment (JRE) consists of the JVM and the Java class libraries and contains
the necessary functionality to start Java programs.
➢ The JDK contains in addition the development tools necessary to create Java programs. The
JDK consists therefore of a Java compiler, the Java virtual machine, and the Java class
libraries.

8
 Installation of Java
❖ Check installation
➢ Java might already be installed on your machine. You can test this by opening a console (if
you are using Windows: Win+R, enter cmd and press Enter) and by typing in the following
command:
➢ java -version
➢ If Java is correctly installed, you should see some information about your Java installation.
If the command line returns the information that the program could not be found, you have
to install Java.

Installing the Java Development Kit

➢ Before installing the Java Development Kit (JDK), you should probably know what it is. It
is distributed by Oracle. It contains the core libraries and compiler required to develop Java.
The JDK should not be confused with the JRE (Java Runtime Environment). The JRE is a
JVM for running, as opposed to compiling, Java programs.

Downloading and Installing

➢ To download the JDK, go to
http://www.oracle.com/technetwork/java/javase/downloads/index.html. Click on "JDK with
NetBeans Bundle". Follow the instructions for downloading the JDK installation file.
Windows: If you are running Windows, simply run the executable file and follow the installation
instructions.
Unix, Solaris, or Linux: For Linux and Unix, download the "jdk1 6.0" for Linux systems.
Save the downloaded file in any drive. Once you have saved the file, extract it to a place
that you can remember, by using Terminal or by double clicking on the file. When you
have finished extracting the file, copy the JDK 1.6.0 folder and paste it in the usr/local(To paste to
the usr/local directory, you have to be in root) so that every user can use the java files. You
can delete the downloaded zip file so that it doesn't take up space on your drive.
Macintosh: The latest available JDK is automatically installed by the operating system.
Because Java for Macintosh is developed and maintained by Apple, in coordination with
Sun, the current version on the Macintosh may not be the current version that is available

Note on Editions
➢ The JDK comes in three editions.
➢ Java Standard Edition (JSE) – This version is the basic platform for Java. The course will focus
on this edition.
➢ Java Enterprise Edition (JEE) – This edition is mainly for developing and running distributed
multitier architecture Java applications, based largely on modular software components running
on an application server. We will not be covering this version in the course.
➢ Java Micro Edition (JME) – This edition is primarily for developing programs to run on consumer
9
 applicances, such as PDAs and cell phones.
Configuring Variables
➢ Before writing code, it is recommended that you set the Path variable on your system
so you can compile your code more easily.

❖ For Windows Users

➢ From the Control Panel, double click "System" (System and Maintenance in Vista)
➢ For Windows 7 or Vista, click on "System," "Advanced System Settings" on the left, and then
on "Environment Variables."
➢ For XP and 2000, click on the "Advanced" tab and click on "Environment Variables" For NT,
click on the "Environment" tab.
➢ Select the Path variable and click "Edit"
➢ Add the path to the bin directory of where Java is installed on your hard drive. It should probably
be: C:\Program Files\Java\jdk1.6.0_20\bin unless you changed it during installation.
➢ Click OK

❖ For Linux and UNIX

➢ One way to set your path in Linux/Unix is to add a path export to your bash profile.
➢ In order to do this, first open your bash profile in a text editor. For example,
➢ pico ~/.bash_profile
➢ Then add this line:
➢ export PATH=$PATH:/usr/local/jdk/bin
➢ Note that the path to the java directory "/usr/local/jdk/bin" may be different on your
machine.
➢ Restart your shell.

❖ For Macintosh
➢ Apple sets everything up for you. Sit back and relax.
➢ The only drawback is that because Apple handles development and maintenance of Java on
the Mac, there is usually a delay from the time that a new version is released by Sun and the
time that the new version is released on the Mac. Also, getting the latest version sometimes requires
an operating system upgrade.
➢ Oh well, you can't have everything.

Validate installation
➢ Switch again to the command line and run the following command.
➢ java -version
➢ The output should be similar to the following output.
➢ java version "1.7.0_25"
➢ OpenJDK Runtime Environment (IcedTea 2.3.10) (7u25-2.3.10-1ubuntu0.13.04.2)
➢ OpenJDK 64-Bit Server VM (build 23.7-b01, mixed mode)
10
 Development Process with Java
➢ Java source files are written as plain text documents. The programmer typically writes Java
source code in an Integrated Development Environment (IDE) for programming. An IDE
supports the programmer in the task of writing code, e.g. it provides auto-formating of the
source code, highlighting of the important keywords, etc.
➢ At some point the programmer (or the IDE) calls the Java compiler (javac). The Java compiler
creates the bytecode instructions. These instructions are stored in .class files and can be
executed by the Java Virtual Machine.

Garbage collector
➢ The JVM automatically re-collects the memory which is not referred to by other objects. The
java garbage collector checks all object references and find the objects which can be
automatically released.
➢ While the garbage collector releases the programmer from the need to explicitly manage memory
the programmer still need to ensure that he does not keep unneeded object references otherwise
the garbage collector cannot release the associated memory. Keeping unneeded object
references are typically called memory leaks.

Classpath
➢ The classpath defines where the Java compiler and Java runtime look for .class files to load.
This instructions can be used in the Java program.
➢ For example if you want to use an external Java library you have to add this library to your
classpath to use it in your program.

Write, compile and run a Java program

❖ Write source code
➢ The following Java program is developed under Linux using a text editor and the command
line. The process on other operating system should be similar and but is not covered in this
description.
➢ Select or create a new directory which will be used for your Java development. In this description
the path \home\vogella\javastarter is used. On Microsoft Windows your might want to use
c:\temp\javastarter. This path is called javadir in the following description. Open a text
editor which supports plain text, e.g. gedit under Linux or Notepad under Windows and
write the following source code.
Save the source code in your javadir directory with the HelloWorld.java filename. The
name of a Java source file must always equals the class name (within the source code) and
end with the .java extension. In this example the filename must be HelloWorld.java
Because the class is called HelloWorld.

11
 ❖ Compile and run your Java program
➢ Open a shell for command line access. Switch to the javadir directory with the command
cd javadir, for example in the above example via the cd
\home\vogella\javastarter command. Use the ls command (dir under Microsoft
Windows) to verify that the source file is in the directory. Compile your Java source file into
a class file with the following command.

javac HelloWorld.java
Afterwards list again the content of the directory with the ls or dir command. The directory
contains now a file "HelloWorld.class". If you see this file you have successfully compiled
your first Java source code into bytecode.

You can now start your compiled Java program. Ensure that you are still in the jardir
directory and enter the following command to start your Java program.

java HelloWorld
The system should write "Hello World" on the command line.

12
Using the classpath
➢ You can use the classpath to run the program from another place in your directory.
➢ Switch to the command line, e.g. under Windows Start-> Run -> cmd. Switch to any directory
you want. Type:

java HelloWorld
➢ If you are not in the directory in which the compiled class is stored then the system should
result an error message Exception in thread "main" java.lang.NoClassDefFoundError:
test/TestClass
➢ To use the class type the following command. Replace "mydirectory" with the directory which
contains the test directory. You should again see the "HelloWorld" output.
java -classpath "mydirectory" HelloWorld

Java basic terms

❖ Basics: Package, Class and Object
It is important to understand the base terminology of Java in terms of packages, classes and
objects. This section gives an overview of these terms.

❖ Package
Java groups classes into functional packages.

Packages are typically used to group classes into logical units. For example all graphical
views of an application might be placed in the same package called
com.vogella.webapplication.views .

It is common practice to use the reverse domain name of the company as top level package. For
example the company might own the domain, vogella.com and in this example the Java packages of
this company starts with com.vogella.
13
Other main reason for the usage of packages is to avoid name collisions of classes. A name
collision occurs if two programmers give the same fully qualified name to a class. The fully
qualified name of a class in Java consists out of the package name followed by a dot (.) and the
class name.

Without packages, a programmer may create a Java class called Test. Another programmer
may create a class with the same name. With the usage of packages you can tell the system
which class to call. For example if the first programmer puts the Test class into package
report and the second programmer puts his class into package xmlreader you can
distinguish between these classes by using the fully qualified name, e.g. xmlreader.Test or
report.Test

❖ Class
Def.: Template that describes the data and behavior associated with an instance of that
class.

In Java source code a class is defined by the class keyword and must start with a capital
letter. The body of a class is surrounded by {}.
package test;

class MyClass {

The data associated with a class is stored in variables ; the behavior associated to a class
or object is implemented with methods.

A class is contained in a Java source file with the same name as the class plus the .java
extension.

❖ Object
Def.: An object is an instance of a class.

The object is the real element which has data and can perform actions. Each object is
created based on the class definition.
❖ Inheritance
A class can be derived from another class. In this case this class is called a subclass. Another
common phrase is that a class extends another class.

The class from which the subclass is derived is called a superclass.

Inheritance allows a class to inherit the behavior and data definitions of another class.

The following codes demonstrates how a class can extend another class. In Java a class can
14
extend a maximum of one class.

package com.vogella.javaintro.base;

class MyBaseClass {
void hello(){
System.out.println("Hello from MyBaseClass");
}
}
package com.vogella.javaintro.base;

class MyExtensionClass extends MyBaseClass {

}

❖ Override methods and the @override annotation

If a class extends another class it inherits the methods from its superclass. If it wants to
change these methods it can override these methods. To override a method you use the same
method signature in the source code of the subclass.

To indicate to the reader of the source code and the Java compiler that you have the intention
to override a method you can use the @override annotation.

The following code demonstrates how you can override a method from a superclass.

package com.vogella.javaintro.base;

class MyBaseClass {
void hello(){
System.out.println("Hello from MyBaseClass");
}
}
package com.vogella.javaintro.base;

class MyExtensionClass2 extends MyBaseClass {

}

Object has superclass

Every object in Java implicitly extends the Object class. The class defines the following
methods for every Java object:

➢ equals(o1) allows to check if the current object is equal to o1

➢ getClass() returns the class of the object

➢ hashCode() returns an identifier of the current object
➢ toString() Give a string representation of the current object

Variables and methods

15
❖ Variable
Variables allow the Java program to store values during the runtime of the program.

A variable can either be a primitive variable or a reference variable. A primitive variable

contains value while the reference variable contains a reference (pointer) to the object.
Hence if you compare two reference variables, you compare if both point to the same object.
To compare objects use the object1.equals(object2) method call.

❖ Instance variable
Instance variable is associated with an instance of the class (also called object). Access
works over these objects.

Instance variables can have any access control and can be marked final or transient. Instance
variables marked as final can not be changed after assigned to a value.

❖ Local variable

Local (stack) variable declarations cannot have access modifiers.

final is the only modifier available to local variables. This modifier defines that the variable
can not be changed after first assignment.

Local variables do not get default values, so they must be initialized before use.

❖ Methods
A method is a block of code with parameters and a return value. It can be called on the
object.

package com.vogella.javaintro.base;

public class MyMethodExample {

void tester(String s) {
System.out.println("Hello World");
}
}
Method can be declared with var-args. In this case the method declares a parameter which
accepts from zero to many arguments (syntax: type .. name;) A method can only have one
var-args parameter and this must be the last parameter in the method.
16
 Overwrite of a superclass method: A method must be of the exact same return parameter and
the same arguments. Also the return parameter must be the same. Overload methods: An
overloaded method is a method with the same name, but different arguments. The return
type can not be used to overload a method.

❖ Main method
A public static method with the following signature can be used to start a Java
application. Such a method is typically called main method.

public static void main(String[] args){

❖ Constructor
A class contains constructors that are invoked to create objects based on the class definition.
Constructor declarations look like method declarations except that they use the name of the
class and have no return type. A class can have several constructors with different parameters.
Each class must define at least one constructor.

In the following example the constructor of the class expects a parameter.

package com.vogella.javaintro.base;

public class MyConstructorExample2 {

String s;

public MyConstructorExample2(String s) {
this.s = s;
}
}
If no explicit constructor is defined the compiler adds implicitly a constructor. If the class
is sub-classed then the constructor of the super class is always implicitly called in this
case.

In the following example the definition of the constructor without parameters (also
known as the empty constructor) is unnecessary. If not specified the compiler would
create one.

package com.vogella.javaintro.base;

public class MyConstructorExample {

// Unnecessary, would be created by the compiler if left out

public MyConstructorExample() {
}
}

17
 The naming conversion for creating a constructor is the following: classname
(Parameter p1, ..) {} .

Every object is created based on a constructor. This constructor method is the first
statement called before anything else can be done with the object.

Modifiers
❖ Access modifiers
There are three access modifiers keywords available in Java. Public, protected and private. There
are four access levels: public, protected, default and private. They define how the corresponding
element is visible to other components. If something is declared public, e.g. classes or methods
can be freely created or called by other Java objects. If something is declared private, e.g. a
method, it can only be accessed within the class in which it is declared. Protected and default
are similar. A protected class can be accessed from the package and sub-classes outside the
package while a default class can get only accessed via the same package. The following table
describes the visibility:

Table 1. Access Level

Modifier Class Package Subclass World

Public Y Y Y Y
protected Y Y Y N

Modifier Class Package Subclass World

no
Y Y N N
modifier
Private Y N N N

18
 Other modifiers
➢ final methods: cannot be overwritten in a subclass
➢ abstract method: no method body
➢ synchronized method: threat safe, can be final and have any access control
➢ native methods: platform dependent code, apply only to methods
➢ strictfp: class or method

Import statements
❖ Usage of import statements
In Java you have to access a class always via its full-qualified name, e.g. the package
name and the class name. You can add import statements for classes or packages into
your class file, which allow you to use the related classes in your code without the
package qualifier.

❖ Static imports
Static import is a feature that allows members (fields and methods) which are defined in a
class with the public static access modifier to be used in Java code without specifying
the class in which the member is defined. The feature provides a typesafe mechanism to
include constants into code without having to reference the class that originally defined the
field.
More Java language constructs interface
Interfaces are contracts for what a class can do but they say nothing about the way in which
the class must do it. An interface is a type similar to a class. Like a class an interface defines
methods. An interface can have only abstract methods, no concrete methods are allowed.
Methods defined in interfaces are by default public and abstract – explicit declaration of these
modifiers is optional. Interfaces can have constants which are always implicitly public, static and
final. A class can implement an interface. In this case it must provide concrete implementations
of the interface methods. If you override a method defined by an interface you can also
use the @override annotation. The following code shows an example implementation of an
interface and its usage within a class.

package com.vogella.javaintro.base;

public interface MyDefinition {

// constant definition
String URL="http://www.vogella.com";
19
 // define several method stubs
void test();
void write(String s);
}
package com.vogella.javaintro.base;

public class MyClassImplementation implements MyDefinition {

@Override
public void test() {
// TODO Auto-generated method stub

}
@Override
public void write(String s) {
}
}
Class methods and class variables
Class methods and class variables are associated with the class and not an instance of the class,
i.e. objects. To refer to these element you can use the classname and a dot (".") followed by the
class method or class variable name. Class methods and class variables are declared with
the static keyword. Class methods are also called static methods and class variables are also
called static variables or static fields.

An example for the usage of a static field is println of the following statement:
System.out.println("Hello World"). out is a static field, an object of type
PrintStream, and you call the println() method on this object. If you define a static variable
the Java runtime environment associates one class variable for a class no matter how many
instances (objects) exists. The static variable can therefore be seen as a global variable. The
following code demonstrates the usage of static fields.

package com.vogella.javaintro.base;

public class MyStaticExample {

static String PLACEHOLDER = "TEST";

static void test() {

System.out.println("Hello");
}
}
package com.vogella.javaintro.base;

public class Tester {

public static void main(String[] args) {

System.out.println(MyStaticExample.PLACEHOLDER);
MyStaticExample.test();
}

20
 If a variable should be defined as constant, you declare it with the static and the final
keyword. The static method runs without any instance of the class, it cannot directly access
non-static variables or methods.
❖ Abstract class and methods
A class and method can be declared as abstract. An abstract class can not be directly
instantiated. If a class has at least one method which only contain the declaration of the method
but not the implementation then this class is abstract and can not be instantiated. Sub-
classes need then to define the methods except if they are also declared as abstract. If a
class contains an abstract method it also needs to get defined with the keyword abstract. The
following example shows an abstract class.

package com.vogella.javaintro.base;
public abstract class MyAbstractClass {
abstract double returnDouble();
}

Working With Classes

Table 2

What to do How to do it
package test;

Create a new class called MyNewClass. public class MyNewClass {

}
package test;
Create a new attribute (instance variable)
called var1 of type String in the MyNewClass public class MyNewClass {
class private String var1;
}
package test;

public class MyNewClass {

private String var1;
Create a Constructor for your MyNewClass
class which has a String parameter and assigns public MyNewClass(String
the value of it to the var1 instance variable. para1) {
var1 = para1;
// or this.var1= para1;
}
}

21
 package test;

public class MyNewClass {

private String var1;

public MyNewClass(String
para1) {
Create a new method called doSomeThing in var1 = para1;
your class which does not return a value and has // or this.var1= para1;
no parameters }

public void doSomeThing()

{

}
package test;

public class MyNewClass {

private String var1;
Create a new method called doSomeThing2 in
public MyNewClass(String
your class which does not return a value and para1) {
has two parameters, a int and a Person var1 = para1;
// or this.var1= para1;
}

public void doSomeThing()

22
What to do How to do it
{

public void
doSomeThing2(int a, Person
person) {

}
package test;

public class MyNewClass {

private String var1;

public MyNewClass(String
para1) {
var1 = para1;
// or this.var1= para1;
}

public void doSomeThing()

{
Create a new method called doSomeThing2 in
}
your class which returns an int value and has
three parameters, two Strings and a Person public void
doSomeThing2(int a, Person
person) {

public int
doSomeThing3(String a,
String b, Person person) {
return 5; // Any value
will do for this example
}

}
package test;

public class MyOtherClass {

String myvalue;
Create a class called MyOtherClass with two Dog dog;
instance variables. One will store a String, the public String
other will store a Dog. Create getter and setter getMyvalue() {
for these variables. return myvalue;
}

public void
setMyvalue(String myvalue)

23
What to do How to do it
{
this.myvalue = myvalue;
}

public Dog getDog() {

return dog;
}

public void setDog(Dog

dog) {
this.dog = dog;
}
}

Working With Local Variable

Table 3:

What to do How to do it
Declare a (local) variable of type string. String variable1;
Declare a (local) variable of type string and assign
String variable2 = "Test";
"Test" to it.
Declare a (local) variable of type Person Person person;
Declare a (local) variable of type Person, create a
Person person = new Person();
new Object and assign the variable to this object.
Declare a array of type String String array[];
Declare a array of type Person and create an array
Person array[]= new Person[5];
for this variable which can hold 5 Persons.
Assign 5 to the int variable var1 (which was
var1 = 5;
already declared);
Assign the existing variable pers2 to the exiting
pers1 = pers2;
variable pers1;
Declare a ArrayList variable which can hold
ArrayList<Person> persons;
objects of type Person
Create a new ArrayList with objects of type
persons = new
Person and assign it to the existing variable
ArrayList<Person>();
persons
Declare a ArrayList variable which can hold ArrayList<Person> persons =
objects of type Person and create a new Object for new ArrayList<Person>();

24
 What to do How to do it
it.

Integrated Development Environment

The previous chapter explained how to create and compile a Java program on the command
line. A Java Integrated Development Environment (IDE) provides lots of ease of use
functionality for creating java programs. There are other very powerful IDE's available, for
example the Eclipse IDE. . For an introduction on how to use the Eclipse IDE please see
Eclipse IDE Tutorial. The remaining description uses the phrase: Create a Java project called...
". This refers to creating a Java project in Eclipse. If you are using a different IDE please follow
the required steps in this IDE. Exercises - Creating Java objects and methods Create a Person
class and instantiate it Create a new Java project called com.vogella.javastarter.exercises1 and
a package with the same name. Create a class called Person. Add three instance variables to
it, one for storing the first name of the person, on for storing the last name and one for storing the
age of the Person. Use the constructor of the Person object to set the values to some default
value. Write a public method called writeName() which uses the System.out.println( method
to print the first name of the person to the console. Create a new class called Main with a
public static void main(String[] args). In this method create an instance of the Person class.

❖ Use constructor
Add a constructor to your Person class which takes the first name, last name and the age as
parameter. Assign the values to your instance variables. Create in your main method two
objects of type Person and call the writeName method on it.

❖ Define getter and setter methods

Define methods which allow you to read the values of the instance variables and to set them. These
methods are called setter and getter. Getters should start with get followed by the variable name
whereby the first letter of the variable is capitized. Setter should start with set followed by the variable
name whereby the first letter of the variable is capitized. ` For example the variable called
firstName would have the getFirstName() getter method and the setFirstName(String s) setter
method. Change your main method so that you create one person object and use the setter
method to change the last name.

❖ Create an Address object

Create a new object called Address. The Address should allow you to store the address of a person.
Add a new instance variable of this type in the Person object. Also create a getter and setter
for the Address object in the Person object.

Solution - Creating Java objects and methods

25
Create a Person class and instantiate it
The following is a potential solution for Section 11.1, “Create a Person class and instantiate
it”.

package exercises.exercise04;

class Person {

String firstname = "Jim";

String lastname = "Knopf";

int age = 12;

voi d writeName() {

// Writes the firstname

System.out.println(firstname);

// Alternatively you can combine strings with +

System.out.println(firstname + " " + lastname + "" + age);

}
}

package exercises.exercise04;
public class Main {

public static void main(String[] args) {

Person person = new Person();

person.writeName();

26
Use constructor
package com.vogella.javastarter.exercises1;
class Person {

String firstName;

String lastName;

int age;

public Person(String a, String b, int value) {

firstName = a;

lastName = b;

age=value;

}
void writeName() {

// Writes the firstname

System.out.println(firstName);
// Alternatively you can combine strings with + System.out.println(firstName + " " +
lastName + "" + age);
}

}
package com.vogella.javastarter.exercises1;

public class Main {

void main(String[] args) {

Person person = new Person("Jim", "Knopf" , 12);

person.writeName();

// Reuse the same variable and assign new object to it

person = new Person("Henry", "Ford", 104);

27
 person.writeName();

}
}

Define getter and setter methods

package com.vogella.javastarter.exercises1;

class Person {

String firstName;

String lastName;

int age;

public Person(String a, String b, int value) {

firstName = a;

lastName = b;

age = value;

}
public String getFirstName() {

return firstName;

public void setFirstName(String firstName) {

this.firstName = firstName;

}
public String getLastName() {

return lastName;

public void setLastName(String lastName) {

28
 this.lastName = lastName;

public int getAge() {

return age;

}
public void setAge(int age) {

this.age = age;

}
void writeName() {

// Writes the firstname

System.out.println(firstName);

// Alternatively you can combine strings with +

System.out.println(firstName + " " + lastName + "" + age);

package com.vogella.javastarter.exercises1;

public class Main {

public static void main(String[] args) {

Person person = new Person("Jim", "Knopf", 21);

Person person2 = new Person("Jill", "Sanders", 20);

// Jill get married to Jim

person2.setLastName("K nopf");

person2.writeName();

}
29
 }

Create an Address object

package com.vogella.javastarter.exercises1;

public class Address {

private String street;

private String number;

private String postalCode;

private String city;

private string country;

public String getStreet() {

return street;

}
public void setStreet(String street) {

this.street = street;

}
public String getNumber() {

return number;

}
public void setNumber(String number) {

this.number = number;

public String getPostalCode() {

return postalCode;

30
}

PostalCode(String postalCode) {

this.postalCode = postalCode;

public String getCity() {

return city;

public void setCity(String city) {

this.city = city;

public String getCountry() {

return country;

public void setCountry(String country) {

this.country = country;

public String toString() {

return street + " " + number + " " + postalCode + " " + city + " "

+ country;

}
package com.vogella.javastarter.exercises1;

class Person {

String firstName;

31
String lastName;

int age;

private Address address;

public Person(String a, String b, int value) {

firstName = a;

lastName = b;

age=value;

public String getFirstName() {

return firstName;

public void setFirstName(String firstName) {

this.firstName = firstName;

public String getLastName() {

return lastName;

public void setLastName(String lastName) {

this.lastName = lastName;

public int getAge() {

return age;

}
public void setAge(int age) {
32
 this.age = age;

}
Public Address getAddress() {

return address;

public void setAddress(Address address) {

this.address = address;

}
void writeName() {

// Writes the firstname

System.out.println(firstName);

// Alternatively you can combine strings with +

System.out.println(firstName + " " + lastName + "" + age);

}
}

package com.vogella.javastarter.exercises1;

public class Main {

public static void main(String[] args) {

// I create a person

Person pers = new Person("Jim", "Knopf", 31);

// I set the age of the person to 32

// Just for testing I write this to the console

System.out.println(pers.toString());

33
/*

* Actually System.out.println calls always toString, if you do not

* specify it so you could also have written System.out.println(pers);

*/

// I create an address

Address address = new Address();

// I set the values for the address

address.setCity("Heidelberg");

address.setCountry("Germany");

address.setNumber("104");

address.setPostalCode("69214");

address.setStreet("Musterstr.");

address = null;

// person is moving to the next house in the same street

pers.getAddress().setNumber("105");

34
 HISTORYOF JAVA

It is quite interesting to know the development of Java technology, which is widely accepted in the
area of networked/distributed computing. Java evolved from a project developing a language for
programming consumer electronic devices at Sun Microsystems, USA.

Sun’s Stealth Project in 1990 was aimed to do research in the area of application of computers
in the consumer electronics market. Bill Joy, James Gosling, Mike Sheridan, Patrick Naughton (formerly
the project leader of Sun’s Open Windows user environment), and several other individuals discussed
the ideas for the Stealth Project in January 1991.The vision of this project was to develop smart
consumer electronic devices that could all be centrally controlled and programmed from a handheld-
remote-control-like device. The Stealth group began to work to achieve this goal. It was realized that
a platform-independent development-environment was needed.

Green Project was initiated by Patrick Naughton, Mike Sheridan, and James Gosling of Sun
Microsystems in 1991 (Members of the Stealth Project, which later became known as the Green
Project) The tasks of the project were divided amongst the members of Green Project. Mike Sheridan
concentrated on business development, Patrick Naughton worked on the graphics system, and James
Gosling was to identify the appropriate programming language for the Green Project. Even though
creating a new language was not the aim of Green Project, a new language was created as a
programming tool in this project since C++ was found unsuitable for the project.

An intelligent remote control called *7 (Star Seven) was delivered as the first product of Green
Project in 1992. It is a PDA- like device comprising of a new language oak, an operating system called
GreenOS, user interface, and hardware. This device was quite impressive to Sun Executives. But no
customer was interested in this project. The market was not conducive to this type of device in the
consumer electronics industry.

The new language Oak was created by James Gosling, a Green Team member, specifically
for *7. Gosling named the new language Oak because that name was struck while looking at an oak
three outside of his office window. The name Oak was later renamed to Java in order to avoid
legal issues since Oak was the name of an existing language.
In November 1992, the Green Project was incorporated under the name FirstPerson. In 1993.
Time-Warner was demanding for proposals for set-top box operating systems and video- on-demand
35
technology with an objective of sending the data to consumer all over the country for display on the
television sets. At the same time (1993(, NCSA released the first graphical web browser Mosaic 1.0,
an easy-to-use front end to the World Wide Web.

When FirstPerson was bidding on the Time-Warner TV trial based on video-on-demand

technology, Time-Warner chose Silicon Graphics, Inc. (SGI) over Sun. Hence, half of the members
of FirstPerson left for SGI and the remaining members continued to work at Sun.

Mosaic web browser revolutionized people’s perceptions. The remaining member of

FirstPerson returned to work on Java (Oak was renamed Java) to develop Java-based web browser.
FirstPerson was dissolved gradually. Naughton and Jonathan Payne developed WebRunner (named
after the movie Blade Runner). Later WevRunner was officially announced as the HotJavaTM browser
in 1994. This was the turning point for Java. At that time the World Wide Web changed the face of
Internet and it was winning the race on Internet.

Arthur Ban Hoff implemented the Java compiler in Java itself whereas Gosling implemented
it in C. The Java compiler, written in Java made the people to accept Java as a full- featured language.
Sun Microsystems official y announced Java environment at Sun World’95 on May 23, 1995.
Java entered into the mainstream of the Internet after a struggle for about four years. Netscape
Communications incorporated Java into its web browser Netscape Navigator. Within a decade, Java was
destined to be the most overreaching technology in the Internet. Java was not restricted to the Internet
alone. The initial goal of Sun was also achieved by using Java technology in interactive set-top
boxes, hand-held devices and other consumer electronics products.
Sun released the first version 1.0 of Java in 1996. Java is an object-oriented programming
language which evolved from C++. It is also a high-level programming language. The different forms
of Java versions are discussed in the next section.

History of Java
Year Java - Versions and Features
1990 Sun Microsystems started Stealth project supporting application of
computers in the
consumer electronics market.
1991 The Green project started with the members of Stealth project such as
James Gosling,
Patrick Naughton, and Mike Sheridan. A new programming language,
called Oak was created by Gosling.

1992 An intelligent remote control called StarSeven was delivered. The Green
Project was
incorporated was incorporated under the name FirstPerson.
1993 Mosaic Web browser was introduced in the world of Internet.
1994 HotJava Web browser was announced by Sun Microsystems.

36
1995 Oak was renamed as Java. Sun officially announced Java technology.
1996 Sun released the first version 1.0 of Java. Core Language features
supporting: I/O
facility, Utilities, Network Programming, User Interface – AWT, Applets,
and
Multithreading.
1997 Sun released JDK1.1 by including new features such as addition of inner
classes to
the languageand capabilities such as JavaBeans, JDBC(Java Data
Base Connectivity), and RMI (Remote Method Invocation).

1998 Java 2 Platform, Standard Edition (J2SE)1.2, code named as

Playground, was
released. It replaced JDK and distinguished the base platform from j2ee (Java
2 Platform, Enterprise Edition) and J2ME (Java 2Platform, Micro Edition). The
key features include Swing graphical API, Java IDL (Interface Definition
Language) to support CORBA interoperability. They also added Collections
framework to support various data structures. For the first time, JVM
was equipped with a JIT (Just-in-
Time) compiler.

2000 J2SE 1.3, code named as Kestrel, was released with key features such as
JavaSound
API to support audio operations (e.g., audio playback and capture/recording,
mixing, sequencing, and synthesis), Java Naming and Directory Interface
(JNDI), and Java Platform Debugger Architecture (JPDA).

2002 H2SE 1.4, code named as Merlin, was released with key features such as
(a) image
I/O API for manipulating images in formats like JPEG and PNG, (b)
integrated XML parser and XSLT processor (JAXP), integrated security
and cryptography extensions,
(c) Java Web Start supporting deployment of Java software applications
over the network.

37
2004 J2SE 5.0, code named as Tiger, was released with enhancement of Java
platform and
inclusion of a number of significant new language features such as Generics,
Enhanced for Loop, Autoboxing/Unboxing, Typesafe Enums, Varags, Static
Import, and Metadata supporting declarative style programming annotation of
source code.
2006 Java SE 6.0, code named as Mustang, was released with enhancement of
performance
in Swing, JDBC 4.0 support, Java Compiler API, Upgrade of JAXB to version
2.0, including integration of a StAX parser, support for pluggable annotations,
and many GUI improvements.

2008 Java SE 7.0, code named as Dolphin, with native support for XML
recognizing its
foundation for Web services.

38
 FEATURES OF JAVA

According to Sun, Java is defined as a simple, object-oriented, distributed, interpreted, robust, secure,
architecture –neutral, portable, high performance, multithreaded, and dynamic programming language
and platform.

Java is simple because the syntax of well-known languages such as C and C++ are used with
modifications meant for simplification and improvement. It is easy to read and write Java code if
the reader is familiar with C/C++.

Almost everything in Java is centered on creating objects, manipulating the objects and making objects
work together. Only the primitive operations and data types are at the sub-object level. Hence Java is
an object-oriented programming language.

An application can be distributed in many systems which are connected together. Since
networking capability is incorporated in Java, the data/file can be sent across many systems to
run the application.

Java is robust because it is more reliable. It ensures the reliability by providing early checking
for possible errors. It eliminates error-prone constructs such as pointer. It eliminates error-prone
constructs such as pointer. It also supports runtime error handling.

Java programs are compiled to a byte code format that can be read and run by interpreters on
many platforms including Windows, Linux, etc. Hence, it is architecture neutral. Because of this
feature it is portable to new hardware and operating systems.

Although the speed of execution of Java programs is slower compared to C/C++ programs, Java
is meant for distributed applications. Whenever the file/data is transmitted from one system to
another, the performance is not affected. Hence, it is having high performance.

Java supports multithreaded programming to perform several tasks simultaneously. Any code
can be loaded without recompilation at runtime. Hence it is dynamic.

39
MYSQL COMMANDS:

mysql> use mysql;

Create Database
Mysql> CREATE DATABASE Appin;

SELECT DATABASE() -- Show the default database

SHOW DATABASES -- Show all the databases in this server

Drop Database
Mysql> DROP DATABASE Appin;

Selecting MySQL Database

Mysql> USE Appin;

Create MySQL Tables

Syntax:

Here is generic SQL syntax to create a MySQL table:

CREATE TABLE table_name (column_name column_type);

Now, we will create following table in Appin database.

Mysql> CREATE TABLE Book(id INT NOT NULL AUTO_INCREMENT,title VARCHAR(100)

NOT NULL,author VARCHAR(40) NOT NULL,submission_date DATE,PRIMARY KEY ( id ));

SHOW TABLES -- Show all the tables in the default database

DESCRIBE|DESC tableName -- Describe the details for a table
ALTER TABLE tableName ... -- Modify a table, e.g., ADD COLUMN and DROP COLUMN
ALTER TABLE tableName ADD columnDefinition
ALTER TABLE tableName DROP columnName

Drop MySQL Tables

DROP TABLE Book ;

40
MySQL Insert Query
Syntax:
Mysql> INSERT INTO Book(title, author, submission_date)VALUES ("Hadoop", "Santosh
Solanki", NOW());

Mysql> INSERT INTO Book(title, author, submission_date)VALUES("JAVA", "Abhas Agrawl",

'2015-05-06');

MySQL Select Query

Syntax:
Mysql>SELECT * from Book;

Mysql>SELECT id,title,author,submission_date FROM Book;

MySQL WHERE Clause

Mysql>SELECT * from Book WHERE author='Abhas Agrawal';

MySQL UPDATE Query

Syntax:
Mysql>UPDATE book SET title='Learning JAVA' WHERE id=2;

MySQL DELETE Query

Syntax:
Mysql> DELETE FROM Book WHERE id=2;

Mysql> TRUNCATE TABLE table_name;

MySQL LIKE Clause

Syntax:
mysql> SELECT * from Book WHERE author LIKE '%nki';

MySQL Sorting Results

Syntax:
mysql> SELECT * from Book ORDER BY author ASC

41
Using MySQl Joins

mysql> create table Bcount_tbl(author varchar(40) NOT NULL B_count INT);

mysql> INSERT INTO Bcount_tbl(author, B_count) values ('mahran', 20);

mysql> INSERT INTO Bcount_tbl(author, B_count) values ('mahnaz', NULL);
mysql> INSERT INTO Bcount_tbl(author, B_count) values ('Jen', NULL);
mysql> INSERT INTO Bcount_tbl(author, B_count) values ('Gill', 20);

mysql> SELECT * FROM Bcount_tbl;

mysql> SELECT * from Book;

mysql> SELECT a.id, a.author, b.B_count FROM Books a, Bcount_tbl b WHERE a. author
= b.author;

Handling MySQL NULL Values

mysql> SELECT * FROM Bcount_tbl WHERE B_count = NULL;

mysql> SELECT * FROM Bcount_tbl WHERE B_count!= NULL;

MySQL Temporary Tables

mysql> CREATE TEMPORARY TABLE SalesSummary (product_name VARCHAR(50) NOT
NULL, total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00 avg_unit_price DECIMAL(7,2)
NOT NULL DEFAULT 0.00, total_units_sold INT UNSIGNED NOT NULL DEFAULT 0);

mysql> INSERT INTO SalesSummary(product_name, total_sales, avg_unit_price,

total_units_sold)VALUES('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SalesSummary;

mysql> DROP TABLE SalesSummary;

MySQL Database Export - Backup Methods

mysql> SELECT * FROM tutorials_tbl INTO OUTFILE '/tmp/tutorials.txt';

MySQL Database Import - Recovery Methods

mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;

Load data local infile '/tmp/emp.sql' into table emp;

1. Getting backup of a MySQL database using mysqldump.

Use following command line for taking backup of your MySQL database using mysqldump utility.
42
mysqldump –-user [user name] –-password=[password] [database name] > [dump file]
or
mysqldump –u[user name] –p[password] [database name] > [dump file]

2. Backup multiple databases in MySQL.

mysqldump –u[user name] –p[password] [database name 1] [database name 2] .. > [dump file]
mysqldump –-user root –-password=myrootpassword db_test db_second db_third > db_test.sql

3. Backup all databases in MySQL.

shell> mysqldump –u[user name] –p[password] –all-databases > [dump file]

4. Backup a specific table in MySQL.

shell> mysqldump --user [username] --password=[password] [database name] [table name] \
> /tmp/sugarcrm_accounts_contacts.sql
shell> mysqldump --user root --password=myrootpassword db_test customers \
> db_test_customers.sql

5. Restoring MySQL database.

The mysqldump utility is used only to take the MySQL dump. To restore the database from the dump
file that you created in previous step, use mysql command.

shell> mysql --u [username] --password=[password] [database name] < [dump file]

43
 Daily Diary
S.NO TOPIC DAY

1. Java Introduction 1st day

2. C++ vs Java 2nd day

3. Downloading & Installing Java and NetBeans 3rd day

4. Environment Variable and Class Path 4th day

5. JDK, JRE and JVM 5th day

6. Java Variables 6th day

7. Java Data Types 7th day

8. Operators & Keywords 8th day

9. Functions and Return types 9th day

10. Control Statements (if, if-else, for, while, switch, etc) 10th day

11. Java OOPs Concept 11th day

12. Objects and Classes 12th day

13. Constructors 13th day

14. Java Inheritance 14th day

15. Method Overloading 15th day

16. Method Overriding 16th day

17. Abstract Classes 17th day

18. Interface vs Abstract Class 18th day

19. Java Array 19th day

20. Exception Handling 20th day

21. Java Multithreading 21st day

22. Java I/O 22nd day

44
23. Java Collection 23rd day

24. Java JDBC 24th day

25. Introduction to MySQL Database 25th day

26. DDL (Create, Alter, Drop, Truncate) 26th day

27. DML (Insert, Update, Delete) 27th day

28. DCL (Grant, Revoke) 28th day

29 TCL (Commit, Rollback, Savepoint) 29th day

30 DQL ( Select) 30th day

45