Android3 What security best practices do you know?

What are the best security practices do you know?

Best Practices for Security & Privacy

These classes and articles provide information about how to keep your app's data secure.

Why do we need Broadcast Receivers

Broadcast receivers

A broadcast receiver is a component that responds to system-wide broadcast announcements. Many broadcasts originate from the system—for example, a broadcast announcing that the screen has turned off, the battery is low, or a picture was captured. Applications can also initiate broadcasts—for example, to let other applications know that some data has been downloaded to the device and is available for them to use. Although broadcast receivers don't display a user interface, they may create a status bar notification to alert the user when a broadcast event occurs. More commonly, though, a broadcast receiver is just a "gateway" to other components and is intended to do a very minimal amount of work. For instance, it might initiate a service to perform some work based on the event.

A broadcast receiver is implemented as a subclass of BroadcastReceiver and each broadcast is delivered as an Intent object. For more information, see the BroadcastReceiver class.

How do popup permission for app in Marshmallow ?

 https://developer.android.com/training/permissions/requesting.html

Why do we need Intent filter

Use Case 1 :

Keep the first intent filter with keys MAIN and LAUNCHER and add another as ANY_NAME and DEFAULT.

Your LAUNCHER will be activity A and DEFAULT will be your activity B.

<activity    android:name=".SplashActivity"    android:configChanges="orientation|keyboardHidden|screenSize"    android:label="@string/app_name"    android:screenOrientation="portrait"    android:theme="@android:style/Theme.Light.NoTitleBar.Fullscreen" >
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>



Use Case 2 :




As I recall, referencing your application as an intent filter from the manifest file will let other applications know that you are capable of handling that intent. Therefore, if you are capable of sending mail and you register yourself this way in your manifest, another application can use yours to send e-mails.

This is often seen with gallery applications. Applications seldom create their own unless they themselves are a gallery application. Therefore, they will ask the Android system what gallery/mail applications are available, and let you choose one from a list. When you register yourself as an application capable of handling this intent you will find your application in this list.

I do believe that is one main difference between the two, as the programmatic instantiation is not known by other applications.

<activity android:name="ShareActivity">
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
</activity>


Why do we need service class


(why don't we create them in activity or application class?)

You can, but it depends of task you want to accomplish. The main characteristic of a Service is that it runs in background, decoupled from Activity life cycle.

Imagine the following situation, you are working on a Media Player application and would like to let the users play music, even when they exit the application, in background.

Now, if you put the media player logic in Activity, then when users will leave the app, the music will stop, as this will terminate the media player. That is not good, we want the music to continue playing in background when they leave the app. Well, in order to achieve this, you should put the playing logic in a Service.

Also, take a look over IntentService class, which provides its own worker thread, so you shouldn't define your own.


I can't find any method in Service which will run in loop. Is there is such method?


No, there isn't. You either start the service again, or, create a loop inside the service.

Why do we need Intent Service?

IntentService (android.app.IntentService) is a simple type of service that can be used to handle asynchronous work off the main thread by way of Intent requests. Each intent is added to the IntentService’s queue and handled sequentially.


public class SimpleIntentService extends IntentService {

    public static final String PARAM_IN_MSG = "imsg";

    public static final String PARAM_OUT_MSG = "omsg";



    public SimpleIntentService() {

        super("SimpleIntentService");

    }



    @Override

    protected void onHandleIntent(Intent intent) {



        String msg = intent.getStringExtra(PARAM_IN_MSG);

        SystemClock.sleep(30000); // 30 seconds

        String resultTxt = msg + " "

            + DateFormat.format("MM/dd/yy h:mmaa", System.currentTimeMillis());

    }

}


https://code.tutsplus.com/tutorials/android-fundamentals-intentservice-basics--mobile-6183





Main difference between the Service and Intent service are


1.Service does not create a separate worker thread for a request
2.Service always runs on main GUI thread if you do a long running operations onOnStartCommond method or Oncreate app may leads to ANR
3. It is used to handle the multiple request at a time
4. Need to create a seprate thread to perform long running operation



5.We always call a method selfStop/stopService to stop service


If the service is startService than service is running indefinitely even if the activity started destroyed

If the service is bindService than service will be autodestroyed by killing the activity

Why do we need Manifest and R.java?




Manifest file:

It is a declaration file.
Here only Which activity should start first, that has been declared.
It declares which permissions the application must have.
It also declares the permissions that others are required to have in order to interact.
It declares the minimum level of the Android API.
It lists the libraries that the application must be linked.
All the component should declared here.
The components are activities, services, broadcast receivers, and content providers.



R.java file:


It is an auto-generated file by aapt (Android Asset Packaging Tool) that contains resource IDs for all the resources of res/ directory.
If you create any component in the activity_main.xml file, id for the corresponding component is automatically created in this file.
This id can be used in the activity source file to perform any action on the component.




2.2. Creating and updating database with SQLiteOpenHelper


To create and upgrade a database in your Android application you create a subclass of the SQLiteOpenHelper class. In the constructor of your subclass you call the super() method of SQLiteOpenHelper, specifying the database name and the current database version.



In this class you need to override the following methods to create and update your database.




onCreate() - is called by the framework, if the database is accessed but not yet created.


onUpgrade() - called, if the database version is increased in your application code. This method allows you to update an existing database schema or to drop the existing database and recreate it via the onCreate()method.





Both methods receive an SQLiteDatabase object as parameter which is the Java representation of the database.



The SQLiteOpenHelper class provides the getReadableDatabase() andgetWriteableDatabase() methods to get access to an SQLiteDatabaseobject; either in read or write mode.



The database tables should use the identifier _id for the primary key of the table. Several Android functions rely on this standard.



It is good practice to create a separate class per table. This class defines static onCreate() and onUpgrade() methods. These methods are called in the corresponding methods ofSQLiteOpenHelper. This way your implementation ofSQLiteOpenHelper stays readable, even if you have several tables.





2.3. SQLiteDatabase


SQLiteDatabase is the base class for working with a SQLite database in Android and provides methods to open, query, update and close the database.



More specifically SQLiteDatabase provides the insert(), update() anddelete() methods.



In addition it provides the execSQL() method, which allows to execute an SQL statement directly.



The object ContentValues allows to define key/values. The key represents the table column identifier and the value represents the content for the table record in this column. ContentValues can be used for inserts and updates of database entries.



Queries can be created via the rawQuery() and query() methods or via theSQLiteQueryBuilder class .



rawQuery() directly accepts an SQL select statement as input.



query() provides a structured interface for specifying the SQL query.



SQLiteQueryBuilder is a convenience class that helps to build SQL queries.




2.4. rawQuery() Example


The following gives an example of a rawQuery() call.



Cursor cursor = getReadableDatabase().
        rawQuery("select * from todo where _id = ?", new String[] { id });





2.5. query() Example


The following gives an example of a query() call.



return database.query(DATABASE_TABLE,
        new String[] { KEY_ROWID, KEY_CATEGORY, KEY_SUMMARY, KEY_DESCRIPTION },
        null, null, null, null, null);




The method query() has the following parameters.

Table 1. Parameters of the query() method

Parameter
Comment


String dbName

The table name to compile the query against.


String[] columnNames

A list of which table columns to return. Passing "null" will return all columns.


String whereClause

Where-clause, i.e. filter for the selection of data, null will select all data.


String[] selectionArgs

You may include ?s in the "whereClause"". These placeholders will get replaced by the values from the selectionArgs array.


String[] groupBy

A filter declaring how to group rows, null will cause the rows to not be grouped.


String[] having

Filter for the groups, null means no filter.


String[] orderBy

Table columns which will be used to order the data, null means no ordering.




If a condition is not required you can pass null, e.g. for the group by clause.



The "whereClause" is specified without the word "where", for example a "where" statement might look like: "_id=19 and summary=?".



If you specify placeholder values in the where clause via ?, you pass them as the selectionArgs parameter to the query.




2.6. Cursor


A query returns a Cursor object. A Cursor represents the result of a query and basically points to one row of the query result. This way Android can buffer the query results efficiently; as it does not have to load all data into memory.



To get the number of elements of the resulting query use the getCount()method.



To move between individual data rows, you can use the moveToFirst() andmoveToNext() methods. The



isAfterLast() method allows to check if the end of the query result has been reached.



Cursor provides typed get*() methods, e.g. getLong(columnIndex),getString(columnIndex) to access the column data for the current position of the result. The "columnIndex" is the number of the column you are accessing.



Cursor also provides the getColumnIndexOrThrow(String) method which allows to get the column index for a column name of the table.



A Cursor needs to be closed with the close() method call.









public class DatabaseHandler extends SQLiteOpenHelper {



    // All Static variables

    // Database Version

    private static final int DATABASE_VERSION = 1;



    // Database Name

    private static final String DATABASE_NAME = "contactsManager";



    // Contacts table name

    private static final String TABLE_CONTACTS = "contacts";



    // Contacts Table Columns names

    private static final String KEY_ID = "id";

    private static final String KEY_NAME = "name";

    private static final String KEY_PH_NO = "phone_number";



    public DatabaseHandler(Context context) {

        super(context, DATABASE_NAME, null, DATABASE_VERSION);

    }



    // Creating Tables

    @Override

    public void onCreate(SQLiteDatabase db) {

        String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_CONTACTS + "("

                + KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT,"

                + KEY_PH_NO + " TEXT" + ")";

        db.execSQL(CREATE_CONTACTS_TABLE);

    }



    // Upgrading database

    @Override

    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

        // Drop older table if existed

        db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACTS);



        // Create tables again

        onCreate(db);

    }






Why do we need Content providers? 


A content provider component supplies data from one application to others on request. Such requests are handled by the methods of the ContentResolver class. A content provider can use different ways to store its data and the data can be stored in a database, in files, or even over a network.



CONTENTPROVIDER

What is the Content Resolver?

The Content Resolver is the single, global instance in your application that provides access to your (and other applications’) content providers. The Content Resolver behaves exactly as its name implies: it accepts requests from clients, and resolves these requests by directing them to the content provider with a distinct authority. To do this, the Content Resolver stores a mapping from authorities to Content Providers. This design is important, as it allows a simple and secure means of accessing other applications’ Content Providers.

The Content Resolver includes the CRUD (create, read, update, delete) methods corresponding to the abstract methods (insert, query, update, delete) in the Content Provider class. The Content Resolver does not know the implementation of the Content Providers it is interacting with (nor does it need to know); each method is passed an URI that specifies the Content Provider to interact with.


Design Pattern - Factory Pattern




Factory pattern is one of the most used design patterns in Java. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.

In Factory pattern, we create object without exposing the creation logic to the client and refer to newly created object using a common interface.

Implementation

We're going to create a Shape interface and concrete classes implementing the Shape interface. A factory class ShapeFactory is defined as a next step.

FactoryPatternDemo, our demo class will use ShapeFactory to get a Shape object. It will pass information (CIRCLE / RECTANGLE / SQUARE) to ShapeFactory to get the type of object it needs.



Step 1

Create an interface.

Shape.java
public interface Shape {
   void draw();
}

Step 2

Create concrete classes implementing the same interface.

Rectangle.java
public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

Square.java
public class Square implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

Circle.java
public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

Step 3

Create a Factory to generate object of concrete class based on given information.

ShapeFactory.java
public class ShapeFactory {
 
   //use getShape method to get object of type shape 
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }  
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
         
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
         
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      
      return null;
   }
}

Step 4

Use the Factory to get object of concrete class by passing an information such as type.

FactoryPatternDemo.java
public class FactoryPatternDemo {

   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();

      //get an object of Circle and call its draw method.
      Shape shape1 = shapeFactory.getShape("CIRCLE");

      //call draw method of Circle
      shape1.draw();

      //get an object of Rectangle and call its draw method.
      Shape shape2 = shapeFactory.getShape("RECTANGLE");

      //call draw method of Rectangle
      shape2.draw();

      //get an object of Square and call its draw method.
      Shape shape3 = shapeFactory.getShape("SQUARE");

      //call draw method of circle
      shape3.draw();
   }
}

Step 5

Verify the output.
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.



Design Patterns - MVC Pattern




MVC Pattern stands for Model-View-Controller Pattern. This pattern is used to separate application's concerns.


Model - Model represents an object or JAVA POJO carrying data. It can also have logic to update controller if its data changes.


View - View represents the visualization of the data that model contains.


Controller - Controller acts on both model and view. It controls the data flow into model object and updates the view whenever data changes. It keeps view and model separate.




10) Mention the advantages and disadvantages of MVC model?

Advantages
Disadvantages

It represents clear separation between business logic and presentation logic
Each MVC object has different responsibilities
The development progresses in parallel
Easy to manage and maintain
All classes and object are independent of each other


The model pattern is little complex
Inefficiency of data access in view
With modern user interface, it is difficult to use MVC
You need multiple programmers for parallel development
Multiple technologies knowledge is required







Implementation


We are going to create a Student object acting as a model.StudentView will be a view class which can print student details on console and StudentController is the controller class responsible to store data in Student object and update view StudentView accordingly.

MVCPatternDemo, our demo class, will use StudentController to demonstrate use of MVC pattern.


Step 1


Create Model.

Student.java
public class Student {
   private String rollNo;
   private String name;
   
   public String getRollNo() {
      return rollNo;
   }
   
   public void setRollNo(String rollNo) {
      this.rollNo = rollNo;
   }
   
   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }
}


Step 2


Create View.

StudentView.java
public class StudentView {
   public void printStudentDetails(String studentName, String studentRollNo){
      System.out.println("Student: ");
      System.out.println("Name: " + studentName);
      System.out.println("Roll No: " + studentRollNo);
   }
}


Step 3


Create Controller.

StudentController.java
public class StudentController {
   private Student model;
   private StudentView view;

   public StudentController(Student model, StudentView view){
      this.model = model;
      this.view = view;
   }

   public void setStudentName(String name){
      model.setName(name);  
   }

   public String getStudentName(){
      return model.getName();  
   }

   public void setStudentRollNo(String rollNo){
      model.setRollNo(rollNo);  
   }

   public String getStudentRollNo(){
      return model.getRollNo();  
   }

   public void updateView(){    
      view.printStudentDetails(model.getName(), model.getRollNo());
   } 
}


Step 4


Use the StudentController methods to demonstrate MVC design pattern usage.

MVCPatternDemo.java
public class MVCPatternDemo {
   public static void main(String[] args) {

      //fetch student record based on his roll no from the database
      Student model  = retriveStudentFromDatabase();

      //Create a view : to write student details on console
      StudentView view = new StudentView();

      StudentController controller = new StudentController(model, view);

      controller.updateView();

      //update model data
      controller.setStudentName("John");

      controller.updateView();
   }

   private static Student retriveStudentFromDatabase(){
      Student student = new Student();
      student.setName("Robert");
      student.setRollNo("10");
      return student;
   }
}


Step 5


Verify the output.
Student: 
Name: Robert
Roll No: 10
Student: 
Name: John
Roll No: 10



Design Patterns - Observer Pattern



Advertisements



 Previous Page

Next Page 




Observer pattern is used when there is one-to-many relationship between objects such as if one object is modified, its depenedent objects are to be notified automatically. Observer pattern falls under behavioral pattern category.

Implementation

Observer pattern uses three actor classes. Subject, Observer and Client. Subject is an object having methods to attach and detach observers to a client object. We have created an abstract class Observer and a concrete class Subject that is extending class Observer.

ObserverPatternDemo, our demo class, will use Subject and concrete class object to show observer pattern in action.



Step 1

Create Subject class.

Subject.java
import java.util.ArrayList;
import java.util.List;

public class Subject {
 
   private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
      observers.add(observer);  
   }

   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}

Step 2

Create Observer class.

Observer.java
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

Step 3

Create concrete observer classes

BinaryObserver.java
public class BinaryObserver extends Observer{

   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
   }
}

OctalObserver.java
public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
     System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); 
   }
}

HexaObserver.java
public class HexaObserver extends Observer{

   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

Step 4

Use Subject and concrete observer objects.

ObserverPatternDemo.java
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();

      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("First state change: 15"); 
      subject.setState(15);
      System.out.println("Second state change: 10"); 
      subject.setState(10);
   }
}

Step 5

Verify the output.
First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010





What is Activity ?






An activity is an application component that provides a screen with which users can interact in order to do something,





What is Fragment  ?
A fragment is usually used as part of an activity's user interface and contributes its own layout to the activity. To provide a layout for a fragment, you must implement the onCreateView() callback method, which the Android system calls when it's time for the fragment to draw its layout.







What is an Intent ?
Any android application compromises of one or more Android activities,
In order to launch one activity from another activity we have to use app component called as android Intent. An intent is basically an intention to do some action.
It's way to communicate between android components(Not just activities).
It's like a message that Android listens for and react accordingly.

Types of Intent :
Implicit intent used to invoke system components .
(Implicit intents do not directly specify the android component which should be called, its only specifies the action to be performed)




Intent intent = new Intent(Intent.ACTION_VIEW, 
Uri.parse("https://sureshmaidaragi.blogspot.in/"));

startActivity(intent);


Explicit intent used to invoke activity class
this intents are used in the application itself, wherein one activity can switch to another activity
for example

Intent intent = new Intent(this, MainActivity.class);
startActivity(intent);














What is an Parcelable  ?











http://stackoverflow.com/questions/7181526/how-can-i-make-my-custom-objects-parcelable


Due to Android's memory management scheme, you will often find yourself needing to communicate with different components of your application, system components, or other applications installed on the phone.Parcelable will help you pass data between these components.

Android uses Binder to facilitate such communication in a highly optimized way. The Binder communicates with Parcels, which is a message container. The Binder marshals the Parcel to be sent, sends and receives it, and then unmarshals it on the other side to reconstruct a copy of the original Parcel.

Creating a Parcelable, The Easiest Way (using Third Party Library)

The simplest way to create a Parcelable is to use a third-party library called Parceler. See this guide on Parceler to see how to use it. By annotating your Java classes that you intend to use, the library is able to create much of the boilerplate code needed as discussed in the manual steps below.

Creating a Parcelable, The Manual Way

To allow for your class instances to be sent as a Parcel you must implement the Parcelable interface along with a static field called CREATOR, which itself requires a special constructor in your class.

Defining a Parcelable Object

Here is a typical implementation:
public class MyParcelable implements Parcelable {
    // You can include parcel data types
    private int mData;
    private String mName;
    
    // We can also include child Parcelable objects. Assume MySubParcel is such a Parcelable:
    private MySubParcelable mInfo;

    // This is where you write the values you want to save to the `Parcel`.  
    // The `Parcel` class has methods defined to help you save all of your values.  
    // Note that there are only methods defined for simple values, lists, and other Parcelable objects.  
    // You may need to make several classes Parcelable to send the data you want.
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
        out.writeString(mName);
        out.writeParcelable(mInfo, flags);
    }

    // Using the `in` variable, we can retrieve the values that 
    // we originally wrote into the `Parcel`.  This constructor is usually 
    // private so that only the `CREATOR` field can access.
    private MyParcelable(Parcel in) {
        mData = in.readInt();
        mName = in.readString();
        mInfo = in.readParcelable(MySubParcelable.class.getClassLoader());
    }

    public MyParcelable() {
        // Normal actions performed by class, since this is still a normal object!
    }

    // In the vast majority of cases you can simply return 0 for this.  
    // There are cases where you need to use the constant `CONTENTS_FILE_DESCRIPTOR`
    // But this is out of scope of this tutorial
    @Override
    public int describeContents() {
        return 0;
    }

    // After implementing the `Parcelable` interface, we need to create the 
    // `Parcelable.Creator<MyParcelable> CREATOR` constant for our class; 
    // Notice how it has our class specified as its type.  
    public static final Parcelable.Creator<MyParcelable> CREATOR
            = new Parcelable.Creator<MyParcelable>() {

        // This simply calls our new constructor (typically private) and 
        // passes along the unmarshalled `Parcel`, and then returns the new object!
        @Override
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

        // We just need to copy this and change the type to match our class.
        @Override
        public MyParcelable[] newArray(int size) {
            return new MyParcelable[size];
        }
    };
}

Note that the Parcelable interface has two methods defined: int describeContents() and void writeToParcel(Parcel dest, int flags). After implementing the Parcelable interface, we need to create the Parcelable.Creator<MyParcelable> CREATOR constant for our class which requires us to define createFromParcel, newArray.

Passing Data Between Intents

We can now pass the parcelable data between activities within an intent:
// somewhere inside an Activity
MyParcelable dataToSend = new MyParcelable();
Intent i = new Intent(this, NewActivity.class);
i.putExtra("myData", dataToSend); // using the (String name, Parcelable value) overload!
startActivity(i); // dataToSend is now passed to the new Activity

and then access the data in the NewActivity using:
public class NewActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        MyParcelable object = (MyParcelable) getIntent().getParcelableExtra("myData");
    }
}

Now we can access the parcelable data from within the launched activity.

What It Is Not

You may notice some similarities between Parcelable and Serializable. DO NOT, I repeat, DO NOT attempt to persist Parcel data. It is meant for high-performance transport and you could lose data by trying to persist it.

Using Parcelable compared to Serializable can achieve up to 10x performance increase in many cases for transport which is why it's the Android preferred method.

SOAP vs REST Web Services

There are many differences between SOAP and REST web services. The important 10 differences between SOAP and REST are given below:

No.
SOAP
REST
1)
SOAP is a protocol.
REST is an architectural style.
2)
SOAP stands for Simple Object Access Protocol.
REST stands for REpresentational State Transfer.
3)
SOAP can't use REST because it is a protocol.
REST can use SOAP web services because it is a concept and can use any protocol like HTTP, SOAP.
4)
SOAP uses services interfaces to expose the business logic.
REST uses URI to expose business logic.
5)
JAX-WS is the java API for SOAP web services.
JAX-RS is the java API for RESTful web services.
6)
SOAP defines standards to be strictly followed.
REST does not define too much standards like SOAP.
7)
SOAP requires more bandwidth and resource than REST.
REST requires less bandwidth and resource than SOAP.
8)
SOAP defines its own security.
RESTful web services inherits security measures from the underlying transport.
9)
SOAP permits XML data format only.
REST permits different data format such as Plain text, HTML, XML, JSON etc.
10)
SOAP is less preferred than REST.
REST more preferred than SOAP.



SON and XML are human readable formats and are language independent. They both have support for creation, reading and decoding in real world situations. We can compare JSON with XML, based on the following factors −

Verbose

XML is more verbose than JSON, so it is faster to write JSON for programmers.

Arrays Usage

XML is used to describe the structured data, which doesn't include arrays whereas JSON include arrays.

Parsing

JavaScript's eval method parses JSON. When applied to JSON, eval returns the described object.

Example

Individual examples of XML and JSON −

JSON
{
   "company": Volkswagen,
   "name": "Vento",
   "price": 800000
}

XML
<car>
   <company>Volkswagen</company>
   <name>Vento</name>
   <price>800000</price>
</car>

Definition - What does Android SDK mean?




The Android SDK (software development kit) is a set of development tools used to develop applications for Android platform. The Android SDK includes the following:

Required libraries
Debugger
An emulator
Relevant documentation for the Android application program interfaces (APIs)
Sample source code
Tutorials for the Android OS





Java program to reverse a string



















This java program reverses a string entered by the user. We use charAt method to extract characters from the string and append them in reverse order to reverse the entered string.

Java programming code

import java.util.*;
 
class ReverseString
{
   public static void main(String args[])
   {
      String original, reverse = "";
      Scanner in = new Scanner(System.in);
 
      System.out.println("Enter a string to reverse");
      original = in.nextLine();
 
      int length = original.length();
 
      for ( int i = length - 1 ; i >= 0 ; i-- )
         reverse = reverse + original.charAt(i);
 
      System.out.println("Reverse of entered string is: "+reverse);
   }
}












Reverse string using StringBuffer class

class InvertString
{
   public static void main(String args[])
   {
      StringBuffer a = new StringBuffer("Java programming is fun");
      System.out.println(a.reverse());
   }
}


StringBuffer class contains a method reverse which can be used to reverse or invert an object of this class.

Java Program to Sort the Array in an Ascending Order


This is a Java Program to Sort the Array in an Ascending Order.




Enter size of array and then enter all the elements of that array. Now with the help of for loop and temp variable we sort the array in ascending order.

Here is the source code of the Java Program to Sort the Array in an Ascending Order. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.









import java.util.Scanner;

public class Ascending _Order 

{

    public static void main(String[] args) 

    {

        int n, temp;

        Scanner s = new Scanner(System.in);

        System.out.print("Enter no. of elements you want in array:");

        n = s.nextInt();

        int a[] = new int[n];

        System.out.println("Enter all the elements:");

        for (int i = 0; i < n; i++) 

        {

            a[i] = s.nextInt();

        }

        for (int i = 0; i < n; i++) 

        {

            for (int j = i + 1; j < n; j++) 

            {

                if (a[i] > a[j]) 

                {

                    temp = a[i];

                    a[i] = a[j];

                    a[j] = temp;

                }

            }

        }

        System.out.print("Ascending Order:");

        for (int i = 0; i < n - 1; i++) 

        {

            System.out.print(a[i] + ",");

        }

        System.out.print(a[n - 1]);

    }

}










Output:







$ javac Ascending _Order.java
$ java Ascending _Order 
 
Enter no. of elements you want in array:5
Enter all the elements:
4
3
2
6
1
Ascending Order:1,2,3,4,6