Search This Blog

Saturday 18 March 2017

Prototype Design Pattern in Java

Prototype Design Pattern in Java

Intent
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.

Motivation
When we talk about object creation there is a better way to have new objects. If the cost of creating a new object is large and creation is resource intensive, we clone the object. Prototyping allows an object to create customized objects without knowing their class or any details of how to create them. This pattern involves implementing a prototype interface which tells to create a clone of the current object. 
The best example to understand Prototype Patter is, the mitotic division of a cell — resulting in two identical cells —that plays an active role in copying itself and thus, demonstrates the Prototype pattern. When a cell splits, two cells of identical genotype result. In other words, the cell clones itself.

Applicability
Use the Prototype pattern when a system should be independent of how its products are created, composed, and represented; and
·         When the classes to instantiate are specified at run-time.
·         To avoid building a class hierarchy of factories that parallels the class hierarchy of products.
·         When instances of a class can have one of only a few different combinations of state.

Consequences
The Prototype pattern has several benefits:
·         Adding and removing products at run-time.
·         Specifying new objects by varying values.
·         Specifying new objects by varying structure.
·         Reduced subclassing.
·         Configuring an application with classes dynamically.



Implementation
import java.util.ArrayList;
import java.util.List;

public class Employees implements Cloneable{

      private List<String> empList;
     
      public Employees(){
            empList = new ArrayList<String>();
      }
     
      public Employees(List<String> list){
            this.empList=list;
      }
      public void loadData(){
//This part can be used to read data from the Database and add to List
            empList.add("Ravi");
            empList.add("Ajay");
            empList.add("Sumit");
            empList.add("Pooja");
      }
     
      public List<String> getEmpList() {
            return empList;
      }

      @Override
      public Object clone() throws CloneNotSupportedException{
                  List<String> temp = new ArrayList<String>();
                  for(String s : this.getEmpList()){
                        temp.add(s);
                  }
                  return new Employees(temp);
      }
     
}

import java.util.List;

public class TestPrototypePattern {

      public static void main(String[] args) throws CloneNotSupportedException {
            Employees emps = new Employees();
            emps.loadData();
           
            //Use the clone method to get the Employee object
            Employees empsNew = (Employees) emps.clone();
            Employees empsNew1 = (Employees) emps.clone();
            List<String> list = empsNew.getEmpList();
            list.add("Simran");
            List<String> list1 = empsNew1.getEmpList();
            list1.remove("Sumit");
           
      System.out.println("Existing Employee List: "+emps.getEmpList());
System.out.println("Employee List after adding an Employee : "+list);
System.out.println("Employee List after removing an Employee : "+list1);
      }
}

Output :
Existing Employee List: [Ravi, Ajay, Sumit, Pooja]
Employee List after adding an Employee : [Ravi, Ajay, Sumit, Pooja, Simran]
Employee List after removing an Employee : [Ravi, Ajay, Pooja]

Thursday 16 March 2017

What is GIT

What is GIT


Git is the most widely used modern version control system in the world today. Git is a  actively maintained open source project. A lot of software projects rely on Git for version control, including commercial projects as well as open source. Git works well on a wide range of operating systems and IDEs (Integrated Development Environments). Git is an example of a DVCS (Distributed Version Control System).
Git has been designed with performance, security and flexibility in mind.

Performance
Committing new changes, branching, merging and comparing past versions are all optimized for performance.

Security
Git has been designed with the integrity of managed source code as a top priority. The content of the files as well as the true relationships between files and directories, versions, tags and commits, all of these objects in the Git repository are secured with a cryptographically secure hashing algorithm called SHA1.

Flexibility
Git is flexible in several respects, in support for various kinds of nonlinear development workflows, in its efficiency in both small and large projects and in its compatibility with many existing systems and protocols.Git has been designed to support branching and tagging and operations that affect branches and tags are also stored as part of the change history

Version control with Git
The main reasons why version control with Git is preferred over other Version Control

Git is good
Git has the functionality, performance, security and flexibility that most teams and individual developers need.

Git is in fact a standard
Git is the most broadly adopted version control tool. Vast numbers of developers have Git experience.
The predominance of Git also means that many third party software tools and services are already integrated with Git including IDEs, and project tracking software, JIRA, and code hosting service, Bitbucket.

Git is a quality open source project

Git is a very well supported open source project with over a decade. Git enjoys great community support and a vast user base. Documentation is excellent and plentiful, including books, tutorials and dedicated web sites. 

Tuesday 14 March 2017

What is Version Control

What is Version Control?

Version control systems are software tools that help a software development team manage changes to source code over time. Version control software keeps track of every modification to the code. If a mistake is made, developers can turn back and compare earlier versions of the code to help fix the mistake while minimizing disruption to other team members.

Software developers working in teams are continually writing new source code and changing existing source code. The code is typically organized in a folder structure. One developer on the team may be working on a new feature while another developer fixes an unrelated bug by changing code, each developer may make their changes in several parts.

Version control helps teams track every individual change by each contributor and help prevent concurrent work from conflicting. Changes made in one part of the code can be incompatible with those made by another developer working at the same time. Good version control systems facilitate a smooth and continuous flow of changes to the code.

Teams that do not use any form of version control often run into problems like not knowing which changes that have been made are available to users or the creation of incompatible changes between two unrelated pieces of work that must then be untangled and reworked. Version control software is an essential part of the every-day of the software team's professional practices.

Benefits of version control
Developing software without using version control is risky. Version control can also enable developers to move faster and it allows teams to preserve efficiency and agility.

The primary benefits of a Version Control System are as follows. 

Ø  A complete long-term change history of every file : Every change made by many individuals to file or files is available. Changes include the creation and deletion of files as well as edits to their contents. Having the complete history enables going back to previous versions to help in root cause analysis for bugs and it is crucial when needing to fix problems in older versions of software.

Ø  Branching and merging : Creating a "branch" in VCS tools keeps multiple streams of work independent from each other while also providing the facility to merge that work back together, enabling developers to verify that the changes on each branch do not conflict. 

Ø  Traceability : Being able to trace each change made to the software and connect it to project management and bug tracking software such as JIRA, and being able to annotate each change with a message describing the purpose and intent of the change can help not only with root cause analysis and other forensics.


While it is possible to develop software without using any version control, doing so subjects the project to a huge risk that no professional team would be advised to accept. So the question is not whether to use version control but which version control system to use.

Thursday 9 March 2017

The Map Interface

The Map Interface


A Map is an object that maps keys to values. A map cannot contain duplicate keys. Each key can map to at most one value.
 The Map interface includes methods for basic operations 
·         put 
·         get 
·         remove 
·         containsKey 
·         containsValue 
·         size 
·         empty

For Bulk operations 
·         putAll  
·         clear

For collection views 
·         keyset 
·         entrySet 
·         values

The Java platform provided three general purpose Map implementations 
·         HashMap 
·         TreeMap 
·         LinkedHashMap
Their behavior and performance are similar to HashSet, TreeSet, and LinkedHashSet.

Map Interface Basic Operations
import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> m = new HashMap<String, Integer>();
       
        // Initialize frequency table from command line
        for (String a : args) {
            Integer freq = m.get(a);
            m.put(a, (freq == null) ? 1 : freq + 1);
        }

        System.out.println(m.size() + " distinct words:");
        System.out.println(m);
    }
}
Execute the above program using command line passing command line arguments
java MapDemo i came i saw i conquered

We will get  the following output.
4 distinct words:
{came=1, saw=1, conquered=1, i=3}

Replace the HashMap implementation with TreeMap implementation in the above code
Map<String, Integer> m = new HashMap<String, Integer>();
Like
Map<String, Integer> m = new TreeMap<String, Integer>();
The output changes to
4 distinct words:
{came=1, conquered=1, i=3, saw=1}
In the output the words are now arranged in alphabetical order.
Map Interface Bulk Operations
·         The clear operation removes all the mappings from the Map.
·         The putAll operation is the Map similar of the Collection interface's addAll operation.
Collection Views
The Collection view methods allow a Map to be viewed as a Collection in three ways:
·         keySet  - the Set of keys contained in the Map.
·         values  -  The Collection of values contained in the Map.
·         entrySet — the Set of key-value pairs contained in the Map. The Map interface provides a small nested interface called Map.Entry, the type of the elements in this Set.
The Collection views provide the only means to iterate over a Map.

import java.util.*;
class HashMapDemo {
      public static void main(String args[]) {
//          Create a hash map
            HashMap hm = new HashMap();
            List l;
            //          Put elements to the map
            hm.put("John Doe", 3434.34);
            hm.put("Tom Smith", new Double(123.22));
            hm.put("Jane Baker", new Double(1378.00));
            hm.put("Todd Hall", new Double(99.22));
            hm.put("Ralph Smith", new Double(-19.08));
            hm.put("Ralph Smith", new Double(-9.08));
//          Get a set of the entries
            Set set = hm.entrySet();
     
            System.out.println(hm);
//          Get an iterator
            Iterator i = set.iterator();
//          Display elements
            while(i.hasNext()) {
                  //System.out.println(i.next());
                  Map.Entry me = (Map.Entry)i.next();
                  System.out.print(me.getKey() + ": ");
                  System.out.println(me.getValue());
                 
            }
            System.out.println();
//          Deposit 1000 into John Doe's account
            double balance = ((Double)hm.get("John Doe")).doubleValue();
            hm.put("John Doe", new Double(balance + 1000));
            System.out.println("John Doe's new balance: " +
                        hm.get("John Doe"));
      }
}