• Call us: +91 9501707741
  • tutorialzdiary@gmail.com

ANDROID

ANDROID Tutorials

Chapter 1: Introduction
Chapter 2: What is Android?
Chapter 3: MVP Design Pattern
Chapter 4: Basic Java Programming
Chapter 5 : Android Programming
Chapter 6 : Web Services
Chapter 7 : App Store Process
Chapter 8 : Git Hub & other Resources
Chapter 9: Conclusion

ANDROID Interview Questions and Answers

Part 1: Java
Part 2: Android
Part 3: Android Core
Part 4:Database

ANDROID Installation

Part 1: Android Studio Setup

Chapter 4: 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

 

Class

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

Object

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)

{

l=x;

b=y;

}

public int area()

{

return l*b;

}

public void display()

{

System.out.println(“Length=”+l);

System.out.println(“Breadth=”+b);

}

public static void main(String ac[])

{

Rect r=new Rect();

r.setDimension(5,10);

r.display();

System.out.println(“Area=”+r.area());

}

}

Polymorphism

A process is performed in more than one ways

Encapsulation

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

Inheritance

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

}

Abstraction

Hiding internal details and showing functionality is known as abstraction.

String

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);

System.out.println(helloString);

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

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

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

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

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.

 

Interface

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();  

obj.print();  

obj.show();  

}  

image_pdfimage_print

Newsletter
Training Enquiry