Andriod For Beginner

Basic Java Programming

Java is a high level programming language developed by Sun Microsystems. A small team of engineers worked together called Green Team, initiated the language in 1991. Today Java is a mostly used language for developing and delivering content in all many domains.

Now let’s see the programming concepts involved !

What is Java?

  • Object Oriented – Java is fully based on object so it is extensible.
  • Platform independent – Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code.
  • Simple – Easy to learn , if you understand OOPS Concept , then java is easy to learn.
  • Secure – Java’s secure feature, it enables to develop virus-free, tamper-free systems. Authentication techniques are based on public-key encryption.
  • Portable – Being architectural-neutral and having no implementation dependent aspects of the specification makes Java portable.
  • Robust – Java takes some steps to eliminate error by using some techniques like error checking and runtime checking.


OOPS Concept

Java is an Object-Oriented Language. As a language that has the Object Oriented feature, Java supports the following fundamental concepts:

  • Classes
  • Objects
  • Polymorphism
  • Inheritance
  • Encapsulation
  • Abstraction



Collection of objects is called class. It is a logical entity.


Objects have states and behaviour. An object is an instance of a class.

For example :

class Rect


Private int l,b;

public void setDimension(int x,int y)





public int area()


return l*b;


public void display()





public static void main(String ac[])


Rect r=new Rect();







A process is performed in more than one ways


Binding (or wrapping) code and data together into a single unit is known as encapsulation


When one object acquires all the properties and behaviours of parent object i.e. known as inheritance.

For example :

class Human extends men {

// new fields and methods defining a human would go here



Hiding internal details and showing functionality is known as abstraction.


Java provides a lot of concepts that can be performed on a string such as compare, concat, equals, split, length, replace, compareTo, intern, substring, etc.

string is a sequence of characters. But in java, string is an object that represents a sequence of characters. String class is used to create string object.

Creating String

The most direct way to create a string is to write:

1. String Literal

For example :

String s2=”Welcome”;     //will not create new instance  

Each time you create a string literal, the JVM checks the string constant pool first. If the string already exists in the pool, a reference to the pooled instance is returned. If string doesn’t exist in the pool, a new string instance is created and placed in the pool.

2. By New Keyword

For example :

String s= String(“Welcome”);   //creates two objects and one reference variable  

char[] hello = { ‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘.’};

String helloString = new String(hello);


The last line of this code snippet displays hello.

Access Specifier

One of the techniques in object-oriented programming is encapsulation. It concerns the hiding of data in a class and making this class available only through methods. Java allows you to control access to classes, methods, and fields via so-called access specifiers

Java offers four access specifiers, listed below in decreasing accessibility:

  • Public
  • protected
  • Default ( no specifiers )
  • private



public classes, methods, and fields can be accessed from everywhere. The only constraint is that a file with Java source code can only contain one public class whose name must also match with the filename.

For example :

public class Square      // public class


public x, y, size;        // public instance variables



protected methods and fields can only be accessed within the same class to which the methods and fields belong, within its subclasses, and within classes of the same package, but not from anywhere else.

Default (no specifiers)

If you do not set access to specific level, then such a class, method, or field will be accessible from inside the same package to which the class, method, or field belongs, but not from outside this package. This access-level is convenient if you are creating packages


private methods and fields can only be accessed within the same class to which the methods and fields belong. private methods and fields are not visible within subclasses and are not inherited by subclasses. So, the private access specifier is opposite to the public access specifier.

For example :

public class Square {     // public class

private double x, y        // private (encapsulated) instance variables

public setCorner(int x, int y) {   // setting values of private fields

this.x = x;

this.y = y;


public getCorner() {        // setting values of private fields

return Point(x, y);




Package = directory. Java classes can be grouped together in packages. A package name is the same as the directory (folder) name which contains the .java files. You declare packages when you define your Java program, and you name the packages you want to use from other libraries in an import statement.

Package Declaration

The first statement, other than comments, in a Java source file, must be the package declaration.

Following the optional package declaration, you can have import statements, which allow you to specify classes from other packages that can be referenced without qualifying them with their package.

Default package – Although all Java classes are in a directory, it’s possible to omit the package declaration. For small programs it’s common to omit it, in which case Java creates what it calls a default package. Sun recommends that you do not use default packages.

Package declaration Syntax

The statement order is as follows. Comments can go anywhere.

  1. Package statment (optional).
  2. Imports (optional).
  3. Class or interface definitions.



There are mainly three reasons to use interface. They are given below.

  • It is used to achieve fully abstraction.
  • By interface, we can support the functionality of multiple inheritance.
  • It can be used to achieve loose coupling.


For example :

interface Print {  

void p1();  


interface Show {  

void s1();  


class VK implements Print,Show {  

public void print(){System.out.println(“Hello”);


public void show(){System.out.println(“Welcome”);


public static void main(String args[])


VK obj = new VK();  



MVP Design Pattern (Prev Lesson)
(Next Lesson) Android Programming
Back to Andriod For Beginner
Inquire Now
close slider