Concept of complexity explained

.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+ <classpathentry kind="src" path="/DesignPatternsJava9/src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -1,9 +1,10 @@
 # Compiled class file
+.idea/*
 *.class
 
 # Log file
 *.log
-
+*.iws
 # BlueJ files
 *.ctxt
 

.project

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>DesignPatternsJava9</name>
+ <comment/>
+ <projects/>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments/>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>

DesignPatternsJava9.eml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component inheritJdk="true">
+ <output-test url="file:https://$MODULE_DIR$/bin/test/DesignPatternsJava9"/>
+ <exclude-output/>
+ <contentEntry url="file:https://$MODULE_DIR$"/>
+</component>

DesignPatternsJava9.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+ <component name="NewModuleRootManager">
+ <output url="file:https://$MODULE_DIR$/bin/production/DesignPatternsJava9" />
+ <output-test url="file:https://$MODULE_DIR$/bin/test/DesignPatternsJava9" />
+ <exclude-output />
+ <content url="file:https://$MODULE_DIR$">
+ <sourceFolder url="file:https://$MODULE_DIR$/src" isTestSource="false" />
+ </content>
+ <orderEntry type="inheritedJdk" />
+ <orderEntry type="sourceFolder" forTests="false" />
+ </component>
+</module>

README.md

@@ -1,2 +1,27 @@
-# DesignPatternsJava9
-This repo consists Gang of Four Design patterns code on Java 9. Each branch in the repository has code of 1 design pattern. Switch repository to try out different design patterns.
+# What is Cyclomatic Complexity?
+Cyclomatic complexity is a source code complexity measurement that is being correlated to a number of coding errors. It is calculated by developing a Control Flow Graph of the code that measures the number of linearly-independent paths through a program module.
+
+Lower the Program's cyclomatic complexity, lower the risk to modify and easier to understand. 
+Cyclomatic complexity = E - N + 2*P 
+where,
+* E = number of edges in the flow graph.
+* N = number of nodes in the flow graph.
+* P = number of nodes that have exit points
+
+
+If the decision points are more, then complexity of the program is more. If program has high complexity number, then probability of error is high with increased time for maintenance and trouble shoot.
+#### Try to write linear code, which means wrap logic in reusable methods and use them.
+
+### Learn Design Patterns with Java by Aseem Jain
+This repository contains working project code used in video Course by Packt Publication with title "Learn Design Patterns with Java " authored by "Aseem Jain".
+
+### Course link: 
+https://www.packtpub.com/application-development/learn-design-patterns-java-9-video
+
+### ![ https://in.linkedin.com/in/premaseem](https://github.com/premaseem/DesignPatternsJava9/blob/master/linkedin.png "https://in.linkedin.com/in/premaseem") Profile: https://in.linkedin.com/in/premaseem
+
+### Authors blog on design patterns:
+https://premaseem.wordpress.com/category/computers/design-patterns/
+
+### Software Design pattern community face book page:
+https://www.facebook.com/DesignPatternGuru/

src/CyclomatricComplexity.java

@@ -0,0 +1,53 @@
+/*
+@author: Aseem Jain
+@title: Design Patterns with Java 9
+@link: https://premaseem.wordpress.com/category/computers/design-patterns/
+*/
+public class CyclomatricComplexity {
+
+ /*
+ Problem Statement: Need to print biggest number from given numbers
+ */
+
+ public static void main (String[] args) {
+
+ Integer a=7,b=4,c=10,d=18;
+
+ if (a > b) {
+ if(a > c){
+ if (a >d){
+ System.out.println(a+ " is biggest");
+ }
+ }
+ }
+
+ if (b > c) {
+ if(b > d){
+ if (b >a){
+ System.out.println(b+ " is biggest");
+ }
+ }
+ }
+
+ if (c > b) {
+ if(c > a){
+ if (c >d){
+ System.out.println(c+" is biggest");
+ }
+ }
+ }
+
+ if (d > b) {
+ if(d > c){
+ if (d >a){
+ System.out.println(d+" is biggest");
+ }
+ }
+ }
+ }
+}
+
+// Take Away:
+// If the decision points are more, then complexity of the program is more.
+// If program has high complexity number, then probability of error is high
+// with increased time for maintenance and trouble shoot.

src/CyclomatricSimplicity.java

@@ -0,0 +1,35 @@
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/*
+@author: Aseem Jain
+@title: Design Patterns with Java 9
+@link: https://premaseem.wordpress.com/category/computers/design-patterns/
+*/
+public class CyclomatricSimplicity {
+
+ /*
+ Problem Statement: Need to print biggest number from given numbers
+ */
+
+ public static void main (String[] args) {
+
+ Integer a=7,b=4,c=10,d=18;
+ // Event when we need to modify parameter, things can be done
+ // with minimal code changes
+
+ PrintBiggestNumber(a,b,c,d);
+ }
+
+ private static void PrintBiggestNumber (Integer... numbers) {
+ System.out.println();
+ List list = Arrays.asList(numbers);
+ Comparable max = Collections.max(list);
+ System.out.println(max + " is biggest (KISS)");
+ }
+}
+
+// Take Away:
+// KISS - Keep it simple stupid.
+// Design clean dry less code which can absorb changes.