diff --git a/Basics/ControlStatment/Continue.java b/Basics/ControlStatment/Continue.java new file mode 100644 index 0000000..8e2904d --- /dev/null +++ b/Basics/ControlStatment/Continue.java @@ -0,0 +1,17 @@ +//Java Program to illustrate the use of continue statement +//inside an inner loop +public class ContinueExample2 { + public static void main(String[] args) { + //outer loop + for(int i=1;i<=3;i++){ + //inner loop + for(int j=1;j<=3;j++){ + if(i==2&&j==2){ + //using continue statement inside inner loop + continue; + } + System.out.println(i+" "+j); + } + } + } + } \ No newline at end of file diff --git a/Basics/ControlStatment/DoWhile.java b/Basics/ControlStatment/DoWhile.java new file mode 100644 index 0000000..64bc8ed --- /dev/null +++ b/Basics/ControlStatment/DoWhile.java @@ -0,0 +1,7 @@ +public class DoWhileExample2 { + public static void main(String[] args) { + do{ + System.out.println("infinitive do while loop"); + }while(true); + } + } \ No newline at end of file diff --git a/Basics/ControlStatment/ForLoop.java b/Basics/ControlStatment/ForLoop.java new file mode 100644 index 0000000..ae59a72 --- /dev/null +++ b/Basics/ControlStatment/ForLoop.java @@ -0,0 +1,10 @@ +public class PyramidExample { + public static void main(String[] args) { + for(int i=1;i<=5;i++){ + for(int j=1;j<=i;j++){ + System.out.print("* "); + } + System.out.println();//new line + } + } + } \ No newline at end of file diff --git a/Basics/ControlStatment/If-else.java b/Basics/ControlStatment/If-else.java new file mode 100644 index 0000000..e9696e0 --- /dev/null +++ b/Basics/ControlStatment/If-else.java @@ -0,0 +1,14 @@ +//A Java Program to demonstrate the use of if-else statement. +//It is a program of odd and even number. +public class IfElseExample { + public static void main(String[] args) { + //defining a variable + int number=13; + //Check if the number is divisible by 2 or not + if(number%2==0){ + System.out.println("even number"); + }else{ + System.out.println("odd number"); + } + } + } \ No newline at end of file diff --git a/Basics/ControlStatment/WhileLoop.java b/Basics/ControlStatment/WhileLoop.java new file mode 100644 index 0000000..3e8c172 --- /dev/null +++ b/Basics/ControlStatment/WhileLoop.java @@ -0,0 +1,10 @@ +public class WhileExample2 { + public static void main(String[] args) { + // setting the infinite while loop by passing true to the condition + while(true){ + System.out.println("infinitive while loop"); + } + } + } + + \ No newline at end of file diff --git a/Basics/Data Structure/Queue-datastructure/QueueX.java b/Basics/Data Structure/Queue-datastructure/QueueX.java new file mode 100644 index 0000000..baab0b1 --- /dev/null +++ b/Basics/Data Structure/Queue-datastructure/QueueX.java @@ -0,0 +1,110 @@ +package Task1; + +public class QueueX { + private int[] arr; // array to store queue elements + private int front; // front points to the front element in the queue + private int rear; // rear points to the last element in the queue + private int capacity; // maximum capacity of the queue + private int count; // current size of the queue + + // Constructor to initialize a queue + QueueX(int size) + { + arr = new int[size]; + capacity = size; + front = 0; + rear = -1; + count = 0; + } + + // Utility function to dequeue the front element + public int dequeue() + { + // check for queue underflow + if (isEmpty()) + { + System.out.println("Underflow\nProgram Terminated"); + System.exit(-1); + } + + int x = arr[front]; + + System.out.println("Removing " + x); + + front = (front + 1) % capacity; + count--; + + return x; + } + + // Utility function to add an item to the queue + public void enqueue(int item) + { + // check for queue overflow + if (isFull()) + { + System.out.println("Overflow\nProgram Terminated"); + System.exit(-1); + } + + System.out.println("Inserting " + item); + + rear = (rear + 1) % capacity; + arr[rear] = item; + count++; + } + + // Utility function to return the front element of the queue + public int peek() + { + if (isEmpty()) + { + System.out.println("Underflow\nProgram Terminated"); + System.exit(-1); + } + return arr[front]; + } + + // Utility function to return the size of the queue + public int size() { + return count; + } + + // Utility function to check if the queue is empty or not + public boolean isEmpty() { + return (size() == 0); + } + + // Utility function to check if the queue is full or not + public boolean isFull() { + return (size() == capacity); + } + + public static void main(String[] args) { + // TODO Auto-generated method stub + // create a queue of capacity 5 + QueueX q = new QueueX(5); + + q.enqueue(1); + q.enqueue(2); + q.enqueue(3); + + System.out.println("The front element is " + q.peek()); + q.dequeue(); + System.out.println("The front element is " + q.peek()); + + System.out.println("The queue size is " + q.size()); + + q.dequeue(); + q.dequeue(); + + if (q.isEmpty()) { + System.out.println("The queue is empty"); + } + else { + System.out.println("The queue is not empty"); + } + + } + +} diff --git a/Basics/Data Structure/Queue-ticketingProcess/Queue.java b/Basics/Data Structure/Queue-ticketingProcess/Queue.java new file mode 100644 index 0000000..eb0ffed --- /dev/null +++ b/Basics/Data Structure/Queue-ticketingProcess/Queue.java @@ -0,0 +1,89 @@ +package Task1; + +public class Queue { + + private int maxSize; // size of queue array + private int [] queArray; + private int front; //front of the queue + private int rear; //rear of the queue + private int nItems; //no of items of the queue + private int tickets;//no of tickets per day + + + // constructor + public Queue(int s) { + maxSize = s; // set array size + queArray = new int [maxSize]; + front = 0; + rear = -1; + nItems = 0; // no items + tickets = s*3; + } + + //insert + public void insert(int j) { + // check whether queue is full + if (rear == (maxSize-1)){ + System.out.println("Queue is full"); + } + + else { + System.out.println("Inserting " + j); + queArray[++rear] = j; + nItems++; + } + } + + //remove + public int remove(int n) { + if (nItems == 0) { + System.out.println("Queue is empty"); + return -99; + } + else { + if(tickets != 0){ + + tickets = tickets - n; + int x = queArray[front++]; + + System.out.println("Removing " + x); + nItems--; + return x; + } + else + System.out.println("There are no tickets available"); + return -99; + + } + } + + + + //peekFront + public int peekFront() { + if (nItems == 0) { + System.out.println("Queue is empty"); + return -99; + } + else { + return queArray[front]; + } + } + + public class main { + + public static void main(String[] args) { + // TODO Auto-generated method stub + Queue queue = new Queue(5); + + queue.insert(1); + queue.insert(2); + queue.remove(1); + + System.out.println("No of tickets available: " + queue.tickets); + } + + } + + +} diff --git a/Basics/Data Structure/Queue-ticketingProcess/main.java b/Basics/Data Structure/Queue-ticketingProcess/main.java new file mode 100644 index 0000000..b2506fe --- /dev/null +++ b/Basics/Data Structure/Queue-ticketingProcess/main.java @@ -0,0 +1,15 @@ +package Task1; + + +public class main { + + public static void main(String[] args) { + // TODO Auto-generated method stub + Queue queue = new Queue(5); + + queue.insert(1); + queue.insert(2); + + } + +} diff --git a/Basics/Data Structure/Stack-Paranthesizer/Paranthesizer.java b/Basics/Data Structure/Stack-Paranthesizer/Paranthesizer.java new file mode 100644 index 0000000..035efec --- /dev/null +++ b/Basics/Data Structure/Stack-Paranthesizer/Paranthesizer.java @@ -0,0 +1,46 @@ +package Stack; + +import java.util.Scanner; + +public class Paranthesizer { + static String expr; + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + System.out.println("Enter your expression : "); + expr = sc.nextLine(); + boolean res = checker(); + System.out.println(res?"Valid Expression":"Invalid Expression"); + sc.close(); + } + + public static int countParanthesis(){ + int count = 0; + for (int i = 0; i < expr.length(); i++) { + if (expr.charAt(i) == '(' || expr.charAt(i) == '{' || expr.charAt(i) == '[') { + count++; + } + } + + return count; + } + + public static boolean checker(){ + StackX stk = new StackX(countParanthesis()); + + for (char element : expr.toCharArray()) { + if(element == '(' || element == '{' || element == '['){ + stk.push(element); + } + + if (element == ')' && stk.peek() == '(') { + stk.pop(); + }else if (element == '}' && stk.peek() == '{') { + stk.pop(); + }else if (element == ']' && stk.peek() == '[') { + stk.pop(); + } + } + + return stk.isEmpty(); + } +} diff --git a/Basics/Data Structure/Stack-Paranthesizer/StackX.java b/Basics/Data Structure/Stack-Paranthesizer/StackX.java new file mode 100644 index 0000000..fe3f5ae --- /dev/null +++ b/Basics/Data Structure/Stack-Paranthesizer/StackX.java @@ -0,0 +1,56 @@ +package Stack; + +public class StackX { + private char[] data; //stack array + private int top; //top of the stack + private int size; //size of stack array + + public StackX(int size){ + this.size = size; + data = new char[size]; + top = -1; + } + + //push method + public boolean push(char element){ + if (top < size - 1) { + data[++top] = element; + return true; + } + + return false; + + } + + public char pop(){ + if (top != -1) { + return data[top--]; + } + + return ' '; + } + + public char peek(){ + if (top != -1) { + return data[top]; + } + + return ' '; + } + + public boolean isFull(){ + if (top == size - 1) { + return true; + } + + return false; + } + + public boolean isEmpty(){ + if (top == -1) { + return true; + } + + return false; + } +} diff --git a/Basics/Data Structure/Stack-Reverser/Reverser.java b/Basics/Data Structure/Stack-Reverser/Reverser.java new file mode 100644 index 0000000..8a327ed --- /dev/null +++ b/Basics/Data Structure/Stack-Reverser/Reverser.java @@ -0,0 +1,38 @@ +package Stack; + +import java.util.Scanner; + +public class Reverser { + private String input,output; + + Reverser(String input){ + this.input = input; + output = ""; + } + + public String reverse(){ + StackX stack = new StackX(input.length()); + + for (char letter : input.toCharArray()) { + stack.push(letter); + } + + + + while (!stack.isEmpty()) { + output += stack.pop(); + + } + + return output; + } + + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + System.out.print("Enter any text : "); + String str = sc.nextLine(); + Reverser obj = new Reverser(str); + System.out.println("Reversed :" + obj.reverse()); + sc.close(); + } +} diff --git a/Basics/Data Structure/Stack-Reverser/StackX.java b/Basics/Data Structure/Stack-Reverser/StackX.java new file mode 100644 index 0000000..fe3f5ae --- /dev/null +++ b/Basics/Data Structure/Stack-Reverser/StackX.java @@ -0,0 +1,56 @@ +package Stack; + +public class StackX { + private char[] data; //stack array + private int top; //top of the stack + private int size; //size of stack array + + public StackX(int size){ + this.size = size; + data = new char[size]; + top = -1; + } + + //push method + public boolean push(char element){ + if (top < size - 1) { + data[++top] = element; + return true; + } + + return false; + + } + + public char pop(){ + if (top != -1) { + return data[top--]; + } + + return ' '; + } + + public char peek(){ + if (top != -1) { + return data[top]; + } + + return ' '; + } + + public boolean isFull(){ + if (top == size - 1) { + return true; + } + + return false; + } + + public boolean isEmpty(){ + if (top == -1) { + return true; + } + + return false; + } +} diff --git a/Basics/Data Structure/binaryTree/BinarySearchTree.java b/Basics/Data Structure/binaryTree/BinarySearchTree.java new file mode 100644 index 0000000..4187230 --- /dev/null +++ b/Basics/Data Structure/binaryTree/BinarySearchTree.java @@ -0,0 +1,86 @@ +package binaryTree; + +public class BinarySearchTree { + +private TreeNode root; + + private class TreeNode { + private int data; + private TreeNode left; + private TreeNode right; + + public TreeNode(int data) { + this.data = data; + } + } + + public void insert(int value) { + root = insert(root, value); + } + + public TreeNode insert(TreeNode root, int value) { + if(root == null) { + root = new TreeNode(value); + return root; + } + + if(value < root.data) { + root.left = insert(root.left, value); + } else { + root.right = insert(root.right, value); + } + return root; + } + + public void inOrder() { + inOrder(root); + } + + public void inOrder(TreeNode root) { + if(root == null) { + return; + } + inOrder(root.left); + System.out.print(root.data + " "); + inOrder(root.right); + } + + public TreeNode search(int key) { + return search(root, key); + } + + public TreeNode search(TreeNode root, int key) { + if(root == null || root.data == key) { // base case + return root; + } + + if(key < root.data) { + return search(root.left, key); + } else { + return search(root.right, key); + } + + } + + public static void main(String[] args) { + + BinarySearchTree tree = new BinarySearchTree(); + tree.insert(10); + tree.insert(8); + tree.insert(4); + tree.insert(1); + + tree.inOrder(); + + System.out.println(); + + if(null != tree.search(10)) { + System.out.println("Key found !!!"); + } else { + System.out.println("Key not found !!!"); + } + } + + } + + diff --git a/Basics/Data Structure/linkedList_datastructure/SinglyLinkedList.java b/Basics/Data Structure/linkedList_datastructure/SinglyLinkedList.java new file mode 100644 index 0000000..5b47508 --- /dev/null +++ b/Basics/Data Structure/linkedList_datastructure/SinglyLinkedList.java @@ -0,0 +1,351 @@ +package linkedList_datastructure; + +public class SinglyLinkedList { + + private ListNode head; + + private static class ListNode { + private int data; // Can be a generic type + private ListNode next; // Reference to next ListNode in list + + public ListNode(int data) { + this.data = data; + this.next = null; + } + } + + public void display() { + ListNode current = head; + while(current != null) { + System.out.print(current.data + " , "); + current = current.next; + } + System.out.print("null"); + } + + public int length() { + if(head == null) { + return 0; + } + int count = 0; + ListNode current = head; + while(current != null) { + count++; + current = current.next; + } + return count; + } + + public void insertFirst(int value) { + ListNode newNode = new ListNode(value); + newNode.next = head; + head = newNode; + } + + public void insert(int position, int value){ + + ListNode node = new ListNode(value); + + if(position == 1){ + node.next = head; + head = node; + } else { + ListNode previous = head; + int count = 1; // position - 1 + + while(count < position - 1){ + previous = previous.next; + count++; + } + + ListNode current = previous.next; + previous.next = node; + node.next = current; + } + + + } + + public void insertLast(int value) { + ListNode newNode = new ListNode(value); + if (head == null) { + head = newNode; + return; + } + ListNode current = head; + while (null != current.next) { + current = current.next; + } + current.next = newNode; + } + + public ListNode deleteFirst() { + if(head == null) { + return null; + } + ListNode temp = head; + head = head.next; + temp.next = null; + return temp; + } + + public void delete(int position){ + + if(position == 1){ + head = head.next; + } else { + ListNode previous = head; + int count = 1; + while(count < position - 1){ + previous = previous.next; + count++; + } + + ListNode current = previous.next; + previous.next = current.next; + } + } + + public ListNode deleteLast() { + if(head == null) { + return head; + } + + if(head.next == null) { + ListNode temp = head; + head = head.next; + return temp; + } + + ListNode current = head; + ListNode previous = null; + + while(current.next != null) { + previous = current; + current = current.next; + } + previous.next = null; // break the chain + return current; + } + + public boolean find(int searchKey) { + if(head == null) { + return false; + } + + ListNode current = head; + while(current != null) { + if(current.data == searchKey) { + return true; + } + current = current.next; + } + return false; + } + + public ListNode reverse() { + if(head == null) { + return null; + } + + ListNode current = head; + ListNode previous = null; + ListNode next = null; + + while(current != null) { + next = current.next; + current.next = previous; + previous = current; + current = next; + } + return previous; + } + + public ListNode getMiddleNode() { + if(head == null) { + return null; + } + ListNode slowPtr = head; + ListNode fastPtr = head; + + while(fastPtr != null && fastPtr.next != null) { + slowPtr = slowPtr.next; + fastPtr = fastPtr.next.next; + } + return slowPtr; + } + + public ListNode getNthNodeFromEnd(int n) { + if(head == null) { + return null; + } + + if(n <= 0) { + throw new IllegalArgumentException("Invalid value: n = " + n); + } + + ListNode mainPtr = head; + ListNode refPtr = head; + + int count = 0; + + while(count < n) { + if(refPtr == null) { + throw new IllegalArgumentException(n + " is greater than the number of nodes in list"); + } + refPtr = refPtr.next; + count++; + } + + while(refPtr != null) { + refPtr = refPtr.next; + mainPtr = mainPtr.next; + } + return mainPtr; + } + + public ListNode insertInSortedList(int value) { + ListNode newNode = new ListNode(value); + + if(head == null) { + return newNode; + } + + ListNode current = head; + ListNode temp = null; + + while (current != null && current.data < newNode.data) { + temp = current; + current = current.next; + } + + newNode.next = current; + temp.next = newNode; + return head; + } + + public void deleteNode(int key) { + ListNode current = head; + ListNode temp = null; + + if(current != null && current.data == key){ + head = current.next; + return; + } + + while(current != null && current.data != key){ + temp = current; + current = current.next; + } + + if(current == null){ + return; + } + + temp.next = current.next; + } + + public boolean containsLoop() { + ListNode fastPtr = head; + ListNode slowPtr = head; + + while(fastPtr != null && fastPtr.next != null) { + fastPtr = fastPtr.next.next; + slowPtr = slowPtr.next; + + if(fastPtr == slowPtr) { + return true; + } + } + return false; + } + + public ListNode startNodeInALoop() { + ListNode fastPtr = head; + ListNode slowPtr = head; + + while(fastPtr != null && fastPtr.next != null) { + fastPtr = fastPtr.next.next; + slowPtr = slowPtr.next; + + if(fastPtr == slowPtr) { + return getStartingNode(slowPtr); + } + } + return null; + } + + private ListNode getStartingNode(ListNode slowPtr) { + ListNode temp = head; + while(temp != slowPtr){ + temp = temp.next; + slowPtr = slowPtr.next; + } + return temp; // starting node of the loop + } + + public void removeLoop() { + ListNode fastPtr = head; + ListNode slowPtr = head; + + while(fastPtr != null && fastPtr.next != null) { + fastPtr = fastPtr.next.next; + slowPtr = slowPtr.next; + + if(fastPtr == slowPtr) { + removeLoop(slowPtr); + return; + } + } + } + + private void removeLoop(ListNode slowPtr) { + ListNode temp = head; + while(temp.next != slowPtr.next){ + temp = temp.next; + slowPtr = slowPtr.next; + } + slowPtr.next = null; + } + + public void createALoopInLinkedList() { + ListNode first = new ListNode(1); + ListNode second = new ListNode(2); + ListNode third = new ListNode(3); + ListNode fourth = new ListNode(4); + ListNode fifth = new ListNode(5); + ListNode sixth = new ListNode(6); + + head = first; + first.next = second; + second.next = third; + third.next = fourth; + fourth.next = fifth; + fifth.next = sixth; + sixth.next = third; + } + + public static void main(String[] args) { + + + SinglyLinkedList sll = new SinglyLinkedList(); + + + sll.insertLast(8); + sll.insertLast(10); + sll.insertLast(20); + sll.insertLast(18); + + sll.display(); + + sll.deleteLast(); + sll.deleteLast(); + System.out.println(sll.deleteLast().data); + System.out.println(sll.deleteLast().data); + + sll.display(); + + + } + +} diff --git a/Basics/Data Structure/queue_datastructure/Queue.java b/Basics/Data Structure/queue_datastructure/Queue.java new file mode 100644 index 0000000..d552d7c --- /dev/null +++ b/Basics/Data Structure/queue_datastructure/Queue.java @@ -0,0 +1,95 @@ +package queue_datastructure; + +import java.util.NoSuchElementException; + + +public class Queue { + + + private nodeList front; + private nodeList rear; + private int length; + + private class nodeList { + private int data; // Can be a generic type + private nodeList next; // Reference to next ListNode in list + + public nodeList(int data) { + this.data = data; + this.next = null; + } + } + + public Queue() { + front = null; + rear = null; + length = 0; + } + + public int length() { + return length; + } + + public boolean isEmpty() { + return length == 0; + } + + public void enqueue(int data) { + nodeList temp = new nodeList(data); + if(isEmpty()) { + front = temp; + } else { + rear.next = temp; + } + + rear = temp; + length++; + } + + public int dequeue() { + if(isEmpty()) { + throw new NoSuchElementException("Queue is empty"); + } + + int result = front.data; + front = front.next; + if(front == null) { + rear = null; + } + length--; + return result; + } + + public void print() { + + //checking weather queue is empty or not + if(isEmpty()) { + return; + } + + nodeList current = front; + while(current != null) { + System.out.print(current.data + ","); + current = current.next; + } + System.out.println("null"); + } + + public static void main(String[] args) { + + Queue queue = new Queue(); + queue.enqueue(10); + queue.enqueue(15); + queue.enqueue(20); + + queue.print(); + + queue.dequeue(); + queue.dequeue(); + queue.enqueue(30); + + queue.print(); + + } + +} diff --git a/Basics/Data Structure/stack_datastructure/Stack.java b/Basics/Data Structure/stack_datastructure/Stack.java new file mode 100644 index 0000000..2f6a343 --- /dev/null +++ b/Basics/Data Structure/stack_datastructure/Stack.java @@ -0,0 +1,73 @@ +package stack_datastructure; +import java.util.EmptyStackException; + +public class Stack { + + private nodeList top; + private int length; + + private class nodeList { + private int data; + private nodeList next; // Reference to next Node in list + + public nodeList(int data) { + this.data = data; + this.next = null; + } + } + + public Stack() { + top = null; + length = 0; + } + + public int length() { + return length; + } + + public boolean isEmpty() { + return length == 0; + } + + public void push(int data) { + nodeList temp = new nodeList(data); + temp.next = top; + top = temp; + length++; + } + + public int pop() { + if(isEmpty()) { + throw new EmptyStackException(); + } + int result = top.data; + top = top.next; + length--; + return result; + } + + public int peek() { + if(isEmpty()) { + throw new EmptyStackException(); + } + return top.data; + } + + public static void main(String[] args) { + + + Stack stack = new Stack(); + stack.push(10); + stack.push(15); + stack.push(20); + + System.out.println(stack.peek()); + stack.pop(); + System.out.println(stack.peek()); + stack.pop(); + System.out.println(stack.peek()); + + } + +} + diff --git a/Basics/Design Pattern/Bridge Pattern/.classpath b/Basics/Design Pattern/Bridge Pattern/.classpath new file mode 100644 index 0000000..fb50116 --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/Basics/Design Pattern/Bridge Pattern/.project b/Basics/Design Pattern/Bridge Pattern/.project new file mode 100644 index 0000000..1eaeaf9 --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/.project @@ -0,0 +1,28 @@ + + + Bridge Pattern + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + + + 1664908487928 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/Basics/Design Pattern/Bridge Pattern/src/Assemble.java b/Basics/Design Pattern/Bridge Pattern/src/Assemble.java new file mode 100644 index 0000000..002df5f --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/Assemble.java @@ -0,0 +1,10 @@ + +public class Assemble implements WorkShop { + + public void work() { + + System.out.println("And Assemble"); + + } + +} diff --git a/Basics/Design Pattern/Bridge Pattern/src/AutoMobile.java b/Basics/Design Pattern/Bridge Pattern/src/AutoMobile.java new file mode 100644 index 0000000..821031c --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/AutoMobile.java @@ -0,0 +1,17 @@ + +public abstract class AutoMobile { + + protected WorkShop workshop1; + protected WorkShop workshop2; + + protected AutoMobile (WorkShop workshop1, WorkShop workshop2 ) { + + this.workshop1 = workshop1; + this.workshop2 = workshop2; + + } + + abstract public void manufacture(); + + +} diff --git a/Basics/Design Pattern/Bridge Pattern/src/Bus.java b/Basics/Design Pattern/Bridge Pattern/src/Bus.java new file mode 100644 index 0000000..8f90eb6 --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/Bus.java @@ -0,0 +1,16 @@ + +public class Bus extends AutoMobile { + + protected Bus(WorkShop workshop1, WorkShop workshop2) { + super(workshop1, workshop2); + // TODO Auto-generated constructor stub + } + + public void manufacture() { + + System.out.println("Taxi is "); + workshop1.work(); + workshop2.work(); + } + +} diff --git a/Basics/Design Pattern/Bridge Pattern/src/Produce.java b/Basics/Design Pattern/Bridge Pattern/src/Produce.java new file mode 100644 index 0000000..8ab7132 --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/Produce.java @@ -0,0 +1,10 @@ + +public class Produce implements WorkShop { + + public void work() { + + System.out.println("Procuded"); + + } + +} diff --git a/Basics/Design Pattern/Bridge Pattern/src/User.java b/Basics/Design Pattern/Bridge Pattern/src/User.java new file mode 100644 index 0000000..35ed4be --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/User.java @@ -0,0 +1,13 @@ + +public class User { + + public static void main (String args[]) { + + AutoMobile bus = new Bus(new Produce(), new Assemble()); + bus.manufacture(); + + + } + + +} diff --git a/Basics/Design Pattern/Bridge Pattern/src/WorkShop.java b/Basics/Design Pattern/Bridge Pattern/src/WorkShop.java new file mode 100644 index 0000000..5f6be93 --- /dev/null +++ b/Basics/Design Pattern/Bridge Pattern/src/WorkShop.java @@ -0,0 +1,6 @@ + +public interface WorkShop { + + abstract public void work(); + +} diff --git a/Basics/Design Pattern/Command Pattern/.classpath b/Basics/Design Pattern/Command Pattern/.classpath new file mode 100644 index 0000000..fb50116 --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/Basics/Design Pattern/Command Pattern/.project b/Basics/Design Pattern/Command Pattern/.project new file mode 100644 index 0000000..ee7de90 --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/.project @@ -0,0 +1,17 @@ + + + Command Pattern + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/Basics/Design Pattern/Command Pattern/src/Command.java b/Basics/Design Pattern/Command Pattern/src/Command.java new file mode 100644 index 0000000..5ef761c --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/Command.java @@ -0,0 +1,6 @@ + +public interface Command { + + void execute(); + +} diff --git a/Basics/Design Pattern/Command Pattern/src/KitchedLight.java b/Basics/Design Pattern/Command Pattern/src/KitchedLight.java new file mode 100644 index 0000000..875ce7c --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/KitchedLight.java @@ -0,0 +1,19 @@ + +public class KitchedLight implements Light { + + @Override + public void on() { + // TODO Auto-generated method stub + + System.out.println("Kitchen Light On"); + } + + @Override + public void off() { + // TODO Auto-generated method stub + System.out.println("Kitchen Light Off"); + + } + + +} diff --git a/Basics/Design Pattern/Command Pattern/src/Light.java b/Basics/Design Pattern/Command Pattern/src/Light.java new file mode 100644 index 0000000..3578a3d --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/Light.java @@ -0,0 +1,8 @@ + +public interface Light { + + void on(); + + void off(); + +} diff --git a/Basics/Design Pattern/Command Pattern/src/LightOffCommand.java b/Basics/Design Pattern/Command Pattern/src/LightOffCommand.java new file mode 100644 index 0000000..0fd2b2a --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/LightOffCommand.java @@ -0,0 +1,20 @@ + +public class LightOffCommand implements Command { + + Light light; + + public LightOffCommand(Light light) { + + this.light = light; + + } + + + + public void execute() { + + light.off(); + + } + +} diff --git a/Basics/Design Pattern/Command Pattern/src/LightOnCommand.java b/Basics/Design Pattern/Command Pattern/src/LightOnCommand.java new file mode 100644 index 0000000..08b7251 --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/LightOnCommand.java @@ -0,0 +1,21 @@ + +public class LightOnCommand implements Command { + + Light light; + + public LightOnCommand(Light light) { + + this.light = light; + + } + + + + public void execute() { + + light.on(); + + } + + +} diff --git a/Basics/Design Pattern/Command Pattern/src/LivingRoomLight.java b/Basics/Design Pattern/Command Pattern/src/LivingRoomLight.java new file mode 100644 index 0000000..9d068b4 --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/LivingRoomLight.java @@ -0,0 +1,16 @@ + +public class LivingRoomLight implements Light { + + + public void on() { + + System.out.println("Living Room Light On"); + + } + + public void off() { + + System.out.println("Living Room Light Off"); + + } +} diff --git a/Basics/Design Pattern/Command Pattern/src/Test.java b/Basics/Design Pattern/Command Pattern/src/Test.java new file mode 100644 index 0000000..eb0bfba --- /dev/null +++ b/Basics/Design Pattern/Command Pattern/src/Test.java @@ -0,0 +1,23 @@ + +public class Test { + + public static void main(String[] args) { + // TODO Auto-generated method stub + + Light livingRoomLight = new LivingRoomLight(); + Light kitchenLight = new KitchedLight(); + + Command lightoncommand = new LightOnCommand(livingRoomLight); + lightoncommand.execute(); + Command lightoffcommand = new LightOffCommand(livingRoomLight); + lightoffcommand.execute(); + + Command lightoncommand1 = new LightOnCommand(kitchenLight); + lightoncommand1.execute(); + + Command lightoffcommand2 = new LightOffCommand(kitchenLight); + lightoffcommand2.execute(); + + } + +} diff --git a/Basics/Design Pattern/Template Pattern/.classpath b/Basics/Design Pattern/Template Pattern/.classpath new file mode 100644 index 0000000..fb50116 --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/Basics/Design Pattern/Template Pattern/.project b/Basics/Design Pattern/Template Pattern/.project new file mode 100644 index 0000000..90dbdc1 --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/.project @@ -0,0 +1,28 @@ + + + Template Pattern + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + + + 1664908487944 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/Basics/Design Pattern/Template Pattern/src/Beverages.java b/Basics/Design Pattern/Template Pattern/src/Beverages.java new file mode 100644 index 0000000..174ee2f --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/src/Beverages.java @@ -0,0 +1,28 @@ + +public abstract class Beverages { + + abstract void brew(); + + abstract void addCondiments(); + + void boilWater() { + + System.out.println("Boiling Water"); + } + + void pourInCup() { + + System.out.println("Pour into cup"); + } + + + public void PrepareRecipie() { + + boilWater(); + brew(); + addCondiments(); + pourInCup(); + + } + +} diff --git a/Basics/Design Pattern/Template Pattern/src/Coffee.java b/Basics/Design Pattern/Template Pattern/src/Coffee.java new file mode 100644 index 0000000..038f0c7 --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/src/Coffee.java @@ -0,0 +1,21 @@ + +public class Coffee extends Beverages { + + public Coffee() { + + super(); + } + + @Override + void brew() { + // TODO Auto-generated method stub + System.out.println("Stripping coffe through filter"); + } + + @Override + void addCondiments() { + // TODO Auto-generated method stub + System.out.println("Add Suger and milk"); + } + +} diff --git a/Basics/Design Pattern/Template Pattern/src/Tea.java b/Basics/Design Pattern/Template Pattern/src/Tea.java new file mode 100644 index 0000000..5258948 --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/src/Tea.java @@ -0,0 +1,29 @@ + +public class Tea extends Beverages { + + public Tea() { + + super(); + } + + + @Override + void brew() { + // TODO Auto-generated method stub + + System.out.println("Steeping the tea"); + + } + + @Override + void addCondiments() { + // TODO Auto-generated method stub + + System.out.println("Adding Lemon"); + + } + + + + +} diff --git a/Basics/Design Pattern/Template Pattern/src/Test.java b/Basics/Design Pattern/Template Pattern/src/Test.java new file mode 100644 index 0000000..fae1555 --- /dev/null +++ b/Basics/Design Pattern/Template Pattern/src/Test.java @@ -0,0 +1,17 @@ + +public class Test { + + static Beverages beverages = null; + + public static void main(String[] args) { + // TODO Auto-generated method stub + + Beverages tea = new Tea(); + tea.PrepareRecipie(); + + Beverages coffee = new Coffee(); + coffee.PrepareRecipie(); + + } + +} diff --git a/Basics/Design Pattern/abstractFactory/AbstractFactory.java b/Basics/Design Pattern/abstractFactory/AbstractFactory.java new file mode 100644 index 0000000..42ac05a --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/AbstractFactory.java @@ -0,0 +1,9 @@ +package design.pattern.abstractFactory; + +public abstract class AbstractFactory { + + public abstract Color getColor(String type); + + public abstract Shape getShape(String type); + +} diff --git a/Basics/Design Pattern/abstractFactory/AbstractFactoryPatternDemo.java b/Basics/Design Pattern/abstractFactory/AbstractFactoryPatternDemo.java new file mode 100644 index 0000000..3d93069 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/AbstractFactoryPatternDemo.java @@ -0,0 +1,29 @@ +package design.pattern.abstractFactory; + +public class AbstractFactoryPatternDemo { + + private static final String SHAPE = "SHAPE"; + private static final String CIRCLE = "CIRCLE"; + private static final String RECTANGLE = "RECTANGLE"; + private static final String SQUARE = "SQUARE"; + + private static final String COLOR = "COLOR"; + private static final String RED = "RED"; + private static final String GREEN = "GREEN"; + private static final String BLUE = "BLUE"; + + + public static void main(String[] args) { + + AbstractFactory shapeFactory = FactoryProducer.getFactory(SHAPE); + Shape shape = shapeFactory.getShape(CIRCLE); + shape.draw(); + + FactoryProducer.getFactory(SHAPE).getShape(RECTANGLE).draw(); + FactoryProducer.getFactory(SHAPE).getShape(SQUARE).draw(); + + FactoryProducer.getFactory(COLOR).getColor(RED).fill(); + FactoryProducer.getFactory(COLOR).getColor(GREEN).fill(); + FactoryProducer.getFactory(COLOR).getColor(BLUE).fill(); + } +} diff --git a/Basics/Design Pattern/abstractFactory/Blue.java b/Basics/Design Pattern/abstractFactory/Blue.java new file mode 100644 index 0000000..1b891cf --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Blue.java @@ -0,0 +1,9 @@ +package design.pattern.abstractFactory; + +public class Blue implements Color{ + + @Override + public void fill() { + System.out.println("Inside the Blue:fill() method"); + } +} diff --git a/Basics/Design Pattern/abstractFactory/Circle.java b/Basics/Design Pattern/abstractFactory/Circle.java new file mode 100644 index 0000000..097f63f --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Circle.java @@ -0,0 +1,9 @@ +package design.pattern.abstractFactory; + +public class Circle implements Shape{ + + @Override + public void draw() { + System.out.println("Inside the Circle:draw() method"); + } +} diff --git a/Basics/Design Pattern/abstractFactory/Color.java b/Basics/Design Pattern/abstractFactory/Color.java new file mode 100644 index 0000000..b3270f4 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Color.java @@ -0,0 +1,6 @@ +package design.pattern.abstractFactory; + +public interface Color { + + void fill(); +} diff --git a/Basics/Design Pattern/abstractFactory/ColorFactory.java b/Basics/Design Pattern/abstractFactory/ColorFactory.java new file mode 100644 index 0000000..b8565d9 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/ColorFactory.java @@ -0,0 +1,26 @@ +package design.pattern.abstractFactory; + +public class ColorFactory extends AbstractFactory{ + + @Override + public Color getColor(String color) { + + if(color.equalsIgnoreCase("RED")){ + return new Red(); + } + else if(color.equalsIgnoreCase("GREEN")){ + return new Green(); + } + else if(color.equalsIgnoreCase("BLUE")){ + return new Blue(); + } + else{ + return null; + } + } + + @Override + public Shape getShape(String type) { + return null; + } +} diff --git a/Basics/Design Pattern/abstractFactory/FactoryProducer.java b/Basics/Design Pattern/abstractFactory/FactoryProducer.java new file mode 100644 index 0000000..72480dc --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/FactoryProducer.java @@ -0,0 +1,17 @@ +package design.pattern.abstractFactory; + +public class FactoryProducer { + + public static AbstractFactory getFactory(String choice){ + + if(choice.equalsIgnoreCase("SHAPE")){ + return new ShapeFactory(); + } + else if(choice.equalsIgnoreCase("COLOR")){ + return new ColorFactory(); + } + else{ + return null; + } + } +} diff --git a/Basics/Design Pattern/abstractFactory/Green.java b/Basics/Design Pattern/abstractFactory/Green.java new file mode 100644 index 0000000..c678734 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Green.java @@ -0,0 +1,9 @@ +package design.pattern.abstractFactory; + +public class Green implements Color{ + + @Override + public void fill() { + System.out.println("Inside Green:fill() method"); + } +} diff --git a/Basics/Design Pattern/abstractFactory/Rectangle.java b/Basics/Design Pattern/abstractFactory/Rectangle.java new file mode 100644 index 0000000..23dd787 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Rectangle.java @@ -0,0 +1,11 @@ +package design.pattern.abstractFactory; + +public class Rectangle implements Shape{ + + @Override + public void draw() { + System.out.println("Inside the Rectangle:draw() method"); + } +} + + diff --git a/Basics/Design Pattern/abstractFactory/Red.java b/Basics/Design Pattern/abstractFactory/Red.java new file mode 100644 index 0000000..80dd8df --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Red.java @@ -0,0 +1,9 @@ +package design.pattern.abstractFactory; + +public class Red implements Color{ + + @Override + public void fill() { + System.out.println("Inside Red:fill() method."); + } +} diff --git a/Basics/Design Pattern/abstractFactory/Shape.java b/Basics/Design Pattern/abstractFactory/Shape.java new file mode 100644 index 0000000..57392a7 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Shape.java @@ -0,0 +1,6 @@ +package design.pattern.abstractFactory; + +public interface Shape { + + void draw(); +} diff --git a/Basics/Design Pattern/abstractFactory/ShapeFactory.java b/Basics/Design Pattern/abstractFactory/ShapeFactory.java new file mode 100644 index 0000000..3ca47cd --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/ShapeFactory.java @@ -0,0 +1,30 @@ +package design.pattern.abstractFactory; + +public class ShapeFactory extends AbstractFactory{ + + @Override + public Shape getShape(String shapeType) { + + if(shapeType == null){ + return null; + } + else if(shapeType.equalsIgnoreCase("CIRCLE")){ + return new Circle(); + } + else if(shapeType.equalsIgnoreCase("RECTANGLE")){ + return new Rectangle(); + } + else if(shapeType.equalsIgnoreCase("SQUARE")){ + return new Square(); + } + else{ + return null; + } + } + + @Override + public Color getColor(String type) { + return null; + } +} + diff --git a/Basics/Design Pattern/abstractFactory/Square.java b/Basics/Design Pattern/abstractFactory/Square.java new file mode 100644 index 0000000..5b396f5 --- /dev/null +++ b/Basics/Design Pattern/abstractFactory/Square.java @@ -0,0 +1,11 @@ +package design.pattern.abstractFactory; + +public class Square implements Shape{ + + @Override + public void draw() { + System.out.println("Inside the Square:draw() method"); + } +} + + diff --git a/Basics/Design Pattern/decorator/Consultant.java b/Basics/Design Pattern/decorator/Consultant.java new file mode 100644 index 0000000..cc51114 --- /dev/null +++ b/Basics/Design Pattern/decorator/Consultant.java @@ -0,0 +1,14 @@ +package design.pattern.decorator; + +public class Consultant extends Employee { + + public Consultant() { + description = "Consultant"; + } + + @Override + public double getSalary() { + return 70000; + } + +} diff --git a/Basics/Design Pattern/decorator/Employee.java b/Basics/Design Pattern/decorator/Employee.java new file mode 100644 index 0000000..88e0086 --- /dev/null +++ b/Basics/Design Pattern/decorator/Employee.java @@ -0,0 +1,13 @@ +package design.pattern.decorator; + +public abstract class Employee { + + public String description; + + public Employee() { + description = "General employee details"; + } + + abstract public double getSalary(); + +} diff --git a/Basics/Design Pattern/decorator/EmployeeCertification.java b/Basics/Design Pattern/decorator/EmployeeCertification.java new file mode 100644 index 0000000..f3badd6 --- /dev/null +++ b/Basics/Design Pattern/decorator/EmployeeCertification.java @@ -0,0 +1,21 @@ +package design.pattern.decorator; + +public class EmployeeCertification extends EmployeeQualification { + + Employee employee; + + public EmployeeCertification(Employee employee) { + this.employee = employee; + } + + @Override + public String getDescription() { + return " Employee Certification "; + } + + @Override + public double getSalary() { + return 30000 + employee.getSalary(); + } + +} diff --git a/Basics/Design Pattern/decorator/EmployeeQualification.java b/Basics/Design Pattern/decorator/EmployeeQualification.java new file mode 100644 index 0000000..fa132c6 --- /dev/null +++ b/Basics/Design Pattern/decorator/EmployeeQualification.java @@ -0,0 +1,7 @@ +package design.pattern.decorator; + +public abstract class EmployeeQualification extends Employee{ + + public abstract String getDescription(); + +} diff --git a/Basics/Design Pattern/decorator/Engineer.java b/Basics/Design Pattern/decorator/Engineer.java new file mode 100644 index 0000000..0f68af1 --- /dev/null +++ b/Basics/Design Pattern/decorator/Engineer.java @@ -0,0 +1,13 @@ +package design.pattern.decorator; + +public class Engineer extends Employee { + + public Engineer() { + description = "Engineer"; + } + + @Override + public double getSalary() { + return 60000; + } +} diff --git a/Basics/Design Pattern/decorator/Manager.java b/Basics/Design Pattern/decorator/Manager.java new file mode 100644 index 0000000..4625833 --- /dev/null +++ b/Basics/Design Pattern/decorator/Manager.java @@ -0,0 +1,14 @@ +package design.pattern.decorator; + +public class Manager extends Employee { + + public Manager() { + description = "Manager"; + } + + @Override + public double getSalary() { + return 80000; + } + +} diff --git a/Basics/Design Pattern/decorator/TestPattern.java b/Basics/Design Pattern/decorator/TestPattern.java new file mode 100644 index 0000000..afd2128 --- /dev/null +++ b/Basics/Design Pattern/decorator/TestPattern.java @@ -0,0 +1,27 @@ +package design.pattern.decorator; + +public class TestPattern { + + /** + * @param args + */ + public static void main(String[] args) { + + Employee employee = new Engineer(); + employee = new EmployeeCertification(employee); + employee = new WorkExperience(employee); + + System.out.println(employee.description + " " + employee.getSalary()); + + Employee employee2 = new Consultant(); + employee2 = new WorkExperience(new EmployeeCertification(employee2)); + + System.out.println(employee2.description + " " + employee2.getSalary()); + + System.out.println("PM salary = " + + new WorkExperience(new EmployeeCertification(new Manager())) + .getSalary()); + + } + +} diff --git a/Basics/Design Pattern/decorator/WorkExperience.java b/Basics/Design Pattern/decorator/WorkExperience.java new file mode 100644 index 0000000..02a992d --- /dev/null +++ b/Basics/Design Pattern/decorator/WorkExperience.java @@ -0,0 +1,20 @@ +package design.pattern.decorator; + +public class WorkExperience extends EmployeeQualification { + + Employee employee; + + public WorkExperience(Employee employee) { + this.employee = employee; + } + + @Override + public String getDescription() { + return "Add Work experience."; + } + + @Override + public double getSalary() { + return 20000 + employee.getSalary(); + } +} diff --git a/Basics/Design Pattern/singleton/Singleton.java b/Basics/Design Pattern/singleton/Singleton.java new file mode 100644 index 0000000..f17872c --- /dev/null +++ b/Basics/Design Pattern/singleton/Singleton.java @@ -0,0 +1,17 @@ +package design.pattern.singleton; + +public class Singleton { + + private static Singleton singleton; + + private Singleton() { } + + public static Singleton getInstance(){ + + if(singleton == null){ + singleton = new Singleton(); + System.out.println("Singleton invocation"); + } + return singleton; + } +} diff --git a/Basics/Design Pattern/singleton/Test.java b/Basics/Design Pattern/singleton/Test.java new file mode 100644 index 0000000..2b6bb8c --- /dev/null +++ b/Basics/Design Pattern/singleton/Test.java @@ -0,0 +1,18 @@ +package design.pattern.singleton; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Test { + + /** + * @param args + * @throws IOException + */ + public static void main(String[] args) throws IOException { + BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); + System.out.println("You inserted: " + bf.readLine()); + } + +} diff --git a/Basics/Design Pattern/singleton/TestSingleton.java b/Basics/Design Pattern/singleton/TestSingleton.java new file mode 100644 index 0000000..9fe08ea --- /dev/null +++ b/Basics/Design Pattern/singleton/TestSingleton.java @@ -0,0 +1,14 @@ +package design.pattern.singleton; + +public class TestSingleton { + + /** + * @param args + */ + public static void main(String[] args) { + + for (int i = 0; i < 10; i++) { + Singleton.getInstance(); + } + } +} diff --git a/Basics/Design Pattern/singleton/TestThreadSingleton.java b/Basics/Design Pattern/singleton/TestThreadSingleton.java new file mode 100644 index 0000000..8db9ce7 --- /dev/null +++ b/Basics/Design Pattern/singleton/TestThreadSingleton.java @@ -0,0 +1,28 @@ +package design.pattern.singleton; + +public class TestThreadSingleton implements Runnable{ + + /** + * @param args + */ + public static void main(String[] args) { + + new Thread(new TestThreadSingleton()).start(); + + for (int i = 0; i < 10; i++) { + Singleton.getInstance(); + ThreadSafeSingleton.getInstance(); + } + } + + /** + * Invoke thread + */ + public void run(){ + for (int i = 0; i < 10; i++) { + Singleton.getInstance(); + ThreadSafeSingleton.getInstance(); + } + } +} + diff --git a/Basics/Design Pattern/singleton/ThreadSafeSingleton.java b/Basics/Design Pattern/singleton/ThreadSafeSingleton.java new file mode 100644 index 0000000..aa8ee00 --- /dev/null +++ b/Basics/Design Pattern/singleton/ThreadSafeSingleton.java @@ -0,0 +1,22 @@ +package design.pattern.singleton; + +public class ThreadSafeSingleton { + + private static ThreadSafeSingleton threadSafeSingleton; + + private ThreadSafeSingleton() {} + + public static ThreadSafeSingleton getInstance(){ + + if(threadSafeSingleton == null){ + synchronized (ThreadSafeSingleton.class) { + if(threadSafeSingleton == null){ + threadSafeSingleton = new ThreadSafeSingleton(); + System.out.println("Object created for ThreadSafeSingleton."); + } + } + } + return threadSafeSingleton; + } +} + diff --git a/Basics/Design Pattern/strategy/Duck.java b/Basics/Design Pattern/strategy/Duck.java new file mode 100644 index 0000000..df216f3 --- /dev/null +++ b/Basics/Design Pattern/strategy/Duck.java @@ -0,0 +1,30 @@ +package design.pattern.stratergy; + +public abstract class Duck { + + IFlyBehaviour flyBehaviour; + + IQuackBehaviour quackBehaviour; + + public abstract void display(); + + public void performFly(){ + flyBehaviour.fly(); + } + + public void performQuack(){ + quackBehaviour.quack(); + } + + public void swim(){ + System.out.println("All ducks float even Decoy"); + } + + public void setFlyBehaviour(IFlyBehaviour flyBehaviour) { + this.flyBehaviour = flyBehaviour; + } + + public void setQuackBehaviour(IQuackBehaviour quackBehaviour) { + this.quackBehaviour = quackBehaviour; + } +} diff --git a/Basics/Design Pattern/strategy/FlyNoWay.java b/Basics/Design Pattern/strategy/FlyNoWay.java new file mode 100644 index 0000000..f9aada5 --- /dev/null +++ b/Basics/Design Pattern/strategy/FlyNoWay.java @@ -0,0 +1,11 @@ +package design.pattern.stratergy; + +public class FlyNoWay implements IFlyBehaviour{ + + @Override + public void fly() { + System.out.println("I can't fly"); + } +} + + diff --git a/Basics/Design Pattern/strategy/FlyRocketPower.java b/Basics/Design Pattern/strategy/FlyRocketPower.java new file mode 100644 index 0000000..65568a7 --- /dev/null +++ b/Basics/Design Pattern/strategy/FlyRocketPower.java @@ -0,0 +1,12 @@ +package design.pattern.stratergy; + +public class FlyRocketPower implements IFlyBehaviour{ + + @Override + public void fly() { + System.out.println("I am flying with a rocket"); + } +} + + + diff --git a/Basics/Design Pattern/strategy/FlyWithWings.java b/Basics/Design Pattern/strategy/FlyWithWings.java new file mode 100644 index 0000000..f3b5c95 --- /dev/null +++ b/Basics/Design Pattern/strategy/FlyWithWings.java @@ -0,0 +1,9 @@ +package design.pattern.stratergy; + +public class FlyWithWings implements IFlyBehaviour{ + + @Override + public void fly() { + System.out.println("I am flying with wings"); + } +} diff --git a/Basics/Design Pattern/strategy/IFlyBehaviour.java b/Basics/Design Pattern/strategy/IFlyBehaviour.java new file mode 100644 index 0000000..9b85840 --- /dev/null +++ b/Basics/Design Pattern/strategy/IFlyBehaviour.java @@ -0,0 +1,8 @@ +package design.pattern.stratergy; + +public interface IFlyBehaviour { + + public void fly(); +} + + diff --git a/Basics/Design Pattern/strategy/IQuackBehaviour.java b/Basics/Design Pattern/strategy/IQuackBehaviour.java new file mode 100644 index 0000000..971c4b3 --- /dev/null +++ b/Basics/Design Pattern/strategy/IQuackBehaviour.java @@ -0,0 +1,8 @@ +package design.pattern.stratergy; + +public interface IQuackBehaviour { + + public void quack(); +} + + diff --git a/Basics/Design Pattern/strategy/ModelDuck.java b/Basics/Design Pattern/strategy/ModelDuck.java new file mode 100644 index 0000000..578eccd --- /dev/null +++ b/Basics/Design Pattern/strategy/ModelDuck.java @@ -0,0 +1,15 @@ + +package design.pattern.stratergy; + +public class ModelDuck extends Duck{ + + public ModelDuck() { + quackBehaviour = new Quack(); + flyBehaviour = new FlyNoWay(); + } + + @Override + public void display() { + System.out.println("I am a model Duck"); + } +} diff --git a/Basics/Design Pattern/strategy/ModelQuack.java b/Basics/Design Pattern/strategy/ModelQuack.java new file mode 100644 index 0000000..0a0f7ae --- /dev/null +++ b/Basics/Design Pattern/strategy/ModelQuack.java @@ -0,0 +1,9 @@ +package design.pattern.stratergy; + +public class ModelQuack implements IQuackBehaviour{ + + @Override + public void quack() { + System.out.println("Quack Model duck"); + } +} diff --git a/Basics/Design Pattern/strategy/MollardDuck.java b/Basics/Design Pattern/strategy/MollardDuck.java new file mode 100644 index 0000000..46b05e4 --- /dev/null +++ b/Basics/Design Pattern/strategy/MollardDuck.java @@ -0,0 +1,14 @@ +package design.pattern.stratergy; + +public class MollardDuck extends Duck{ + + public MollardDuck() { + quackBehaviour = new Quack(); + flyBehaviour = new FlyWithWings(); + } + + @Override + public void display() { + System.out.println("I am a real Mollard Duck."); + } +} diff --git a/Basics/Design Pattern/strategy/Quack.java b/Basics/Design Pattern/strategy/Quack.java new file mode 100644 index 0000000..bf09eaa --- /dev/null +++ b/Basics/Design Pattern/strategy/Quack.java @@ -0,0 +1,11 @@ +package design.pattern.stratergy; + +public class Quack implements IQuackBehaviour{ + + @Override + public void quack() { + System.out.println("Quack..Quack..."); + } +} + + diff --git a/Basics/Design Pattern/strategy/TestDuck.java b/Basics/Design Pattern/strategy/TestDuck.java new file mode 100644 index 0000000..463aa1e --- /dev/null +++ b/Basics/Design Pattern/strategy/TestDuck.java @@ -0,0 +1,28 @@ +package design.pattern.stratergy; + +public class TestDuck { + + /** + * @param args + */ + public static void main(String[] args) { + + System.out.println("Start Mollard Duck"); + System.out.println("=================="); + Duck mollard = new MollardDuck(); + mollard.performFly(); + mollard.performQuack(); + + System.out.println("Start Model Duck"); + System.out.println("=================="); + Duck model = new ModelDuck(); + + model.performFly(); + model.setFlyBehaviour(new FlyRocketPower()); + model.performFly(); + + model.performQuack(); + model.setQuackBehaviour(new ModelQuack()); + model.performQuack(); + } +} diff --git a/Basics/Thread/ThreadJoin.java b/Basics/Thread/ThreadJoin.java new file mode 100644 index 0000000..775b028 --- /dev/null +++ b/Basics/Thread/ThreadJoin.java @@ -0,0 +1,38 @@ +public class ThreadJoin extends Thread{ + + public void run () { + + Thread t = Thread.currentThread(); + System.out.println("Started Executing " +t.getName()); + + for(int i=0; i <10; i++) { + + System.out.println(t.getName() + i); + + } + + System.out.println("Finished Executing " +t.getName()); + + } + + public static void main(String[] args) throws Exception{ + + Thread t = new Thread (new ThreadJoin(), "New Thread"); + t.start(); + System.out.println("Started executing main thread"); + + t.join(); + + + for(int i =0; i<10; i++) { + + System.out.println(Thread.currentThread().getName() +i); + + } + + System.out.println("Finished Executing " +Thread.currentThread().getName()); + + } + + +} \ No newline at end of file diff --git a/Basics/Thread/ThreadNotifyTest.java b/Basics/Thread/ThreadNotifyTest.java new file mode 100644 index 0000000..360dcf1 --- /dev/null +++ b/Basics/Thread/ThreadNotifyTest.java @@ -0,0 +1,24 @@ +public class ThreadNotifyTest { + + public static void main (String args[]) { + + ThreadNotifyTest threadnotifytest = new ThreadNotifyTest(); + + Thread t1 = new Thread1(threadnotifytest, "New Thread1"); + Thread t2 = new Thread2(threadnotifytest, "New Thread2"); + Thread t3 = new Thread3(threadnotifytest, "New Thread3"); + + t1.start(); + t2.start(); + t3.start(); + + + + + + } + + + + +} \ No newline at end of file diff --git a/Basics/Thread/ThreadYield.java b/Basics/Thread/ThreadYield.java new file mode 100644 index 0000000..677052f --- /dev/null +++ b/Basics/Thread/ThreadYield.java @@ -0,0 +1,40 @@ +public class ThreadYield extends Thread { + + public void run() { + + Thread t = Thread.currentThread(); + System.out.println("Started Executing " +t.getName()); + + for(int i=0; i<10; i++) { + + System.out.println(t.getName() + i); + + } + + System.out.println("Finished Executing " +t.getName()); + + } + + public static void main(String args[]) throws Exception { + + Thread t = new Thread(new ThreadYield(),"New Thread"); + t.start(); + + System.out.println("Started executing main thread"); + + t.yield(); + + for(int i= 0; i<10; i++) { + + System.out.println(Thread.currentThread().getName() +i); + + } + + System.out.println("Finished Executing " +Thread.currentThread().getName()); + + + } + + + +} \ No newline at end of file diff --git a/MID Exam/Revision/Answers.txt b/MID Exam/Revision/Answers.txt new file mode 100644 index 0000000..59368b1 --- /dev/null +++ b/MID Exam/Revision/Answers.txt @@ -0,0 +1,8 @@ +1 - 3 +2 -5* +3-5 +4-2,4,5* +5 -4 +6-2 +7-1* +8-4 \ No newline at end of file diff --git a/MID Exam/Revision/MID revision.docx b/MID Exam/Revision/MID revision.docx new file mode 100644 index 0000000..2c1b94f Binary files /dev/null and b/MID Exam/Revision/MID revision.docx differ diff --git a/Online Assignement 2021 June/Randula[Answer]/BlueSoldier.java b/Online Assignement 2021 June/Randula[Answer]/BlueSoldier.java new file mode 100644 index 0000000..c2502e2 --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/BlueSoldier.java @@ -0,0 +1,21 @@ +package com.dot_hunter; + +public class BlueSoldier extends Soldier{ + + + + public BlueSoldier() { + super(); + // TODO Auto-generated constructor stub + } + + @Override + void hunt() { + // TODO Auto-generated method stub + System.out.println("Killed using a knife"); + + //call game over + Board.gameOver(); + } + +} diff --git a/Online Assignement 2021 June/Randula[Answer]/Board.java b/Online Assignement 2021 June/Randula[Answer]/Board.java new file mode 100644 index 0000000..7fb1a6d --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/Board.java @@ -0,0 +1,104 @@ +package com.dot_hunter; + +public class Board { + + //attributes + private int dots; + private int superDots; + private String dotType; + private Hunter myHunter; + private Soldier[] threeSoldiers; + + //return Dots + public int getDots() { + return dots; + } + + //assign Dots + public void setDots(int dots) { + this.dots = dots; + } + + //return Super Dots + public int getSuperDots() { + return superDots; + } + + //assign Super Dots + public void setSuperDots(int superDots) { + this.superDots = superDots; + } + + //return Dot Type + public String getDotType() { + return dotType; + } + + //assign Dot Type + public void setDotType(String dotType) { + this.dotType = dotType; + } + + //return MyHunter + public Hunter getMyHunter() { + return myHunter; + } + + //assign MyHunter + public void setMyHunter(Hunter myHunter) { + this.myHunter = myHunter; + } + + //return Three Solders + public Soldier[] getThreeSoldiers() { + return threeSoldiers; + } + + // + public void setThreeSoilders(Soldier[] threeSoilders) { + this.threeSoldiers = threeSoilders; + } + + public Board(String dotType, Hunter myHunter, Soldier[] threeSoldiers) { + + super(); + this.dotType = dotType; + this.myHunter = myHunter; + this.threeSoldiers = threeSoldiers; + + this.init(); + } + + public void init() { + + //set initial values for Dots and Super Dots + this.setDots(97); + this.setSuperDots(3); + + //set soldiers' positions + //generate a random number using Math.random function + for (int i = 0 ; i < threeSoldiers.length ; i++) + { + threeSoldiers[i].setxPOS((int) Math.random() * 250); + threeSoldiers[i].setyPOS((int) Math.random() * 360); + + } + + //set hunter positions + myHunter.setxPOS(0); + myHunter.setyPOS(0); + + //prompt as ready + System.out.println("Board is ready and three soldiers and the hunter is positioned in the board"); + } + + //game over method + public static void gameOver(){ + + //Prompt + System.out.println("Game Over"); + + //Terminate the program + System.exit(0); + } +} diff --git a/Online Assignement 2021 June/Randula[Answer]/GreenSoldier.java b/Online Assignement 2021 June/Randula[Answer]/GreenSoldier.java new file mode 100644 index 0000000..d895033 --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/GreenSoldier.java @@ -0,0 +1,20 @@ +package com.dot_hunter; + +public class GreenSoldier extends Soldier{ + + + public GreenSoldier() { + super(); + // TODO Auto-generated constructor stub + } + + @Override + void hunt() { + // TODO Auto-generated method stub + System.out.println("Killed using a gun"); + + //call game over + Board.gameOver(); + } + +} diff --git a/Online Assignement 2021 June/Randula[Answer]/Hunter.java b/Online Assignement 2021 June/Randula[Answer]/Hunter.java new file mode 100644 index 0000000..314f0ce --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/Hunter.java @@ -0,0 +1,134 @@ +package com.dot_hunter; + +public class Hunter { + + //attributes + private String name; + private String color; + private int x; + private int y; + + //default constructor + public Hunter() { + super(); + } + + //overload constructor + public Hunter(String name, String color) { + super(); + this.name = name; + this.color = color; + } + + //return name + public String getName() { + return name; + } + + //assign name + public void setName(String name) { + this.name = name; + } + + //return color + public String getColor() { + return color; + } + + //assign color + public void setColor(String color) { + this.color = color; + } + + //return x value + public int getxPOS() { + return x; + } + + //set x value + public void setxPOS(int x) { + this.x = x; + } + + //return y value + public int getyPOS() { + return y; + } + + //set y value + public void setyPOS(int y) { + this.y = y; + } + + //move method + public void move(Hunter myHunter) + { + //handle the exception using try-catch + try { + + //condition checking if the hunter hits the wall + if(myHunter.x >= 250 || myHunter.y >= 360) + { + throw new SoundException("Oh oo!!"); + } + else { + System.out.println("Hunter is moving, X:" + myHunter.x + " Y:" + myHunter.y); + } + //handle sound exception + } catch (SoundException e) { + // TODO: handle exception + System.out.println(e.getMessage()); + + } + } + + //hunt method + public void hunt(Board myBoard) + { + + //dot type of the board + String dotType = myBoard.getDotType(); + + //position of soldiers + Soldier[] threeSoldiers = myBoard.getThreeSoldiers(); + int x = myBoard.getMyHunter().getxPOS(); + int y = myBoard.getMyHunter().getyPOS(); + + //game over when all dots are hunted + if (myBoard.getDots() == 0 && myBoard.getSuperDots() == 0) + { + Board.gameOver(); + } + + //Hunter get special power when hunting superDot + for(int i = 0; i < threeSoldiers.length; i++) { + + if(x == threeSoldiers[i].getxPOS() && y == threeSoldiers[i].getyPOS()) { + + //if hunted dot is a normalDot, no soldier gets killed + if(dotType.equals("dot")) { + Board.gameOver(); + } + + //if hunted dot is a superDot, hunter gets special power + //soldier gets killed + else if(dotType.equals("superDot")) { + System.out.println("Soldier KILLS"); + + } + } + } + + //reduce Dot by one + if(dotType.equals("dot")) { + myBoard.setDots(myBoard.getDots() - 1); + System.out.println("Hunting Dots"); + } + + //reduce superDot by one + else if(dotType.equals("superDot")) { + myBoard.setSuperDots(myBoard.getSuperDots() - 1); + System.out.println("Hunting Super Dots"); + } + } +} diff --git a/Online Assignement 2021 June/Randula[Answer]/MainApp.java b/Online Assignement 2021 June/Randula[Answer]/MainApp.java new file mode 100644 index 0000000..05c5614 --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/MainApp.java @@ -0,0 +1,21 @@ +package com.dot_hunter; + +import java.util.Scanner; + +public class MainApp { + public static void main(String[] args) + { + System.out.println("Hello world"); + Scanner scan = new Scanner(System.in); + Hunter myhunter = new Hunter("Maha Deva" , "Brown"); + Soldier threeSoilders[] = {new RedSoldier() , new RedSoldier() , new GreenSoldier()}; + Board myboard = new Board("superDot" , myhunter , threeSoilders); + + System.out.println("Use the keyboard up , down , left , right arrow keys to move the hunter"); + myhunter.setxPOS(scan.nextInt()); + myhunter.setyPOS(scan.nextInt()); + myhunter.move(myhunter); + myhunter.hunt(myboard); + threeSoilders[2].hunt(); + } +} diff --git a/Online Assignement 2021 June/Randula[Answer]/RedSoldier.java b/Online Assignement 2021 June/Randula[Answer]/RedSoldier.java new file mode 100644 index 0000000..ca4be4c --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/RedSoldier.java @@ -0,0 +1,20 @@ +package com.dot_hunter; + +public class RedSoldier extends Soldier{ + + + public RedSoldier() { + super(); + // TODO Auto-generated constructor stub + } + + @Override + void hunt() { + // TODO Auto-generated method stub + System.out.println("Killed using a knife"); + + //call game over + Board.gameOver(); + } + +} diff --git a/Online Assignement 2021 June/Randula[Answer]/Soldier.java b/Online Assignement 2021 June/Randula[Answer]/Soldier.java new file mode 100644 index 0000000..3b35bd2 --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/Soldier.java @@ -0,0 +1,41 @@ +package com.dot_hunter; + +abstract class Soldier { + + //attributes + private int x; + private int y; + + //define abstract method + abstract void hunt(); + + public Soldier() + { + x = 0; + y = 0; + } + + //return x value + public int getxPOS() { + return x; + } + + //set x value + public void setxPOS(int x) { + this.x = x; + } + + //return y value + public int getyPOS() { + return y; + } + + //set y value + public void setyPOS(int y) { + this.y = y; + //y = 6; + } + + + +} diff --git a/Online Assignement 2021 June/Randula[Answer]/SoundException.java b/Online Assignement 2021 June/Randula[Answer]/SoundException.java new file mode 100644 index 0000000..a4b7cf1 --- /dev/null +++ b/Online Assignement 2021 June/Randula[Answer]/SoundException.java @@ -0,0 +1,8 @@ +package com.dot_hunter; + +public class SoundException extends Exception { + + SoundException (String message){ + super(message); + } +} diff --git a/Online Assignement Repeat 2021/Calculations.java b/Online Assignement Repeat 2021/Calculations.java deleted file mode 100644 index 3bdaff0..0000000 --- a/Online Assignement Repeat 2021/Calculations.java +++ /dev/null @@ -1,3 +0,0 @@ -interface Calculations { - public double calculateRevenue(Counsellor counsellor); -} diff --git a/Online Assignement Repeat 2021/Counsellor.java b/Online Assignement Repeat 2021/Counsellor.java deleted file mode 100644 index 67587f8..0000000 --- a/Online Assignement Repeat 2021/Counsellor.java +++ /dev/null @@ -1,36 +0,0 @@ -import java.util.ArrayList; - -class Counsellor extends User { - - private String email; - private String specialistArea; - private ArrayList arrivalHospitalList = new ArrayList<>(); - - - public Counsellor(String name, String nic, String email, String specialistArea) { - super(name, nic); - this.email = email; - this.specialistArea = specialistArea; - } - - - @Override - public void printDetails() { - super.printDetails(); - System.out.println("Email: " + email); - System.out.println("Specialist Area: " + specialistArea); - System.out.println("Hospital List: "); - printHospital(); - } - - public void addHospital(String hospitalName) { - - arrivalHospitalList.add(hospitalName); - } - - public void printHospital() { - for (int i = 0; i < arrivalHospitalList.size(); i++) { - System.out.println("\t" + arrivalHospitalList.get(i)); - } - } -} diff --git a/Online Assignement Repeat 2021/MyMain.java b/Online Assignement Repeat 2021/MyMain.java deleted file mode 100644 index be28654..0000000 --- a/Online Assignement Repeat 2021/MyMain.java +++ /dev/null @@ -1,25 +0,0 @@ -public class MyMain { - - /** - * @param args - */ - public static void main(String[] args) { - - Receptionist rs = new Receptionist("Thushara","981234567V", 1); - - Counsellor co = new Counsellor("Thiwanka", "981234567V", "thiwanka@gmail.com", "Neurologist"); - co.addHospital("Osro Hospitals (Pvt) Ltd"); - co.addHospital("Lanka Hospitals"); - co.addHospital("Royal Hospital"); - co.addHospital("Nawaloka Hospital"); - co.addHospital("Asiri Surgical Hospital"); - - double revenue = rs.calculateRevenue(co); - System.out.println("Revenue for " + co.getName() + " : " + revenue + "\n"); - - rs.printDetails(); - System.out.println(); - - co.printDetails(); - } -} diff --git a/Online Assignement Repeat 2021/Receptionist.java b/Online Assignement Repeat 2021/Receptionist.java deleted file mode 100644 index 5ca88fd..0000000 --- a/Online Assignement Repeat 2021/Receptionist.java +++ /dev/null @@ -1,49 +0,0 @@ -import java.util.Scanner; - -class Receptionist extends User implements Calculations{ - - private int employeeNumber; - - - public Receptionist(String name, String nic, int employeeNumber) { - super(name, nic); - this.employeeNumber = employeeNumber; - } - - - /** - * @return the employeeNumber - */ - public int getEmployeeNumber() { - return employeeNumber; - } - - /** - * @param employeeNumber the employeeNumber to set - */ - public void setEmployeeNumber(int employeeNumber) { - this.employeeNumber = employeeNumber; - } - - - - @Override - public void printDetails() { - super.printDetails(); - - } - - - @Override - public double calculateRevenue(Counsellor counsellor) { - - Scanner input = new Scanner(System.in); - System.out.print("Enter the number of appointments: "); - - int noOfAppointments = input.nextInt(); - double revenue = noOfAppointments * 2500; - - input.close(); - return revenue; - } -} diff --git a/Online Assignement Repeat 2021/Repeat Assignement 2021 - IT2030.pdf b/Online Assignement Repeat 2021/Repeat Assignement 2021 - IT2030.pdf deleted file mode 100644 index e285450..0000000 Binary files a/Online Assignement Repeat 2021/Repeat Assignement 2021 - IT2030.pdf and /dev/null differ diff --git a/Online Assignement Repeat 2021/User.java b/Online Assignement Repeat 2021/User.java deleted file mode 100644 index 351c415..0000000 --- a/Online Assignement Repeat 2021/User.java +++ /dev/null @@ -1,57 +0,0 @@ -class User { - protected String name; - protected String nic; - - public User() {} - - /** - * @param name - * @param nic - */ - public User(String name, String nic) { - this.name = name; - this.nic = nic; - } - - public User(User u) { - this.name = u.getName(); - this.nic = u.getNic(); - } - - /** - * @return the name - */ - public String getName() { - return name; - } - - - /** - * @param name the name to set - */ - public void setName(String name) { - this.name = name; - } - - - /** - * @return the nic - */ - public String getNic() { - return nic; - } - - - /** - * @param nic the nic to set - */ - public void setNic(String nic) { - this.nic = nic; - } - - - public void printDetails() { - System.out.println("Name: " + name); - System.out.println("NIC: " + nic); - } -} diff --git a/Past Papers/2021 OOP Final.pdf b/Past Papers/2021 OOP Final.pdf new file mode 100644 index 0000000..f698f93 Binary files /dev/null and b/Past Papers/2021 OOP Final.pdf differ diff --git a/Past Papers/IT2030 - Mock paper.pdf b/Past Papers/IT2030 - Mock paper.pdf new file mode 100644 index 0000000..15c3f97 Binary files /dev/null and b/Past Papers/IT2030 - Mock paper.pdf differ diff --git a/Past Papers/Mock Exam.pdf b/Past Papers/Mock Exam.pdf new file mode 100644 index 0000000..5f4db93 Binary files /dev/null and b/Past Papers/Mock Exam.pdf differ diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.classpath b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.classpath new file mode 100644 index 0000000..51a8bba --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.project b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.project new file mode 100644 index 0000000..c98ae47 --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.project @@ -0,0 +1,28 @@ + + + Designpattern3 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + + + 1664908487937 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + + diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.settings/org.eclipse.jdt.core.prefs b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..6709bd3 --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,576 @@ +eclipse.preferences.version=1 +enableParallelJavaIndexSearch=true +org.eclipse.jdt.core.builder.annotationPath.allLocations=disabled +org.eclipse.jdt.core.builder.cleanOutputFolder=clean +org.eclipse.jdt.core.builder.duplicateResourceTask=warning +org.eclipse.jdt.core.builder.invalidClasspath=abort +org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder=ignore +org.eclipse.jdt.core.builder.resourceCopyExclusionFilter= +org.eclipse.jdt.core.circularClasspath=warning +org.eclipse.jdt.core.classpath.exclusionPatterns=enabled +org.eclipse.jdt.core.classpath.mainOnlyProjectHasTestOnlyDependency=error +org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled +org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource=error +org.eclipse.jdt.core.codeComplete.argumentPrefixes= +org.eclipse.jdt.core.codeComplete.argumentSuffixes= +org.eclipse.jdt.core.codeComplete.camelCaseMatch=enabled +org.eclipse.jdt.core.codeComplete.deprecationCheck=disabled +org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck=disabled +org.eclipse.jdt.core.codeComplete.fieldPrefixes= +org.eclipse.jdt.core.codeComplete.fieldSuffixes= +org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck=enabled +org.eclipse.jdt.core.codeComplete.forceImplicitQualification=disabled +org.eclipse.jdt.core.codeComplete.localPrefixes= +org.eclipse.jdt.core.codeComplete.localSuffixes= +org.eclipse.jdt.core.codeComplete.staticFieldPrefixes= +org.eclipse.jdt.core.codeComplete.staticFieldSuffixes= +org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes= +org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes= +org.eclipse.jdt.core.codeComplete.subwordMatch=disabled +org.eclipse.jdt.core.codeComplete.suggestStaticImports=enabled +org.eclipse.jdt.core.codeComplete.visibilityCheck=enabled +org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled +org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore +org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull +org.eclipse.jdt.core.compiler.annotation.nonnull.secondary= +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary= +org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable +org.eclipse.jdt.core.compiler.annotation.nullable.secondary= +org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.lambda.genericSignature=do not generate +org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate +org.eclipse.jdt.core.compiler.codegen.shareCommonFinallyBlocks=disabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.doc.comment.support=enabled +org.eclipse.jdt.core.compiler.emulateJavacBug8031744=enabled +org.eclipse.jdt.core.compiler.generateClassFiles=enabled +org.eclipse.jdt.core.compiler.maxProblemPerUnit=100 +org.eclipse.jdt.core.compiler.problem.APILeak=warning +org.eclipse.jdt.core.compiler.problem.annotatedTypeArgumentToUnannotated=info +org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.autoboxing=ignore +org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning +org.eclipse.jdt.core.compiler.problem.deadCode=warning +org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement=disabled +org.eclipse.jdt.core.compiler.problem.deprecation=warning +org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled +org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled +org.eclipse.jdt.core.compiler.problem.discouragedReference=warning +org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore +org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning +org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning +org.eclipse.jdt.core.compiler.problem.forbiddenReference=error +org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning +org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled +org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning +org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning +org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadoc=ignore +org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled +org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=public +org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning +org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag +org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled +org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=public +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore +org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning +org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning +org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error +org.eclipse.jdt.core.compiler.problem.nullReference=warning +org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error +org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning +org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation=ignore +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore +org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore +org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning +org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore +org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning +org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning +org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled +org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled +org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed=info +org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled +org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore +org.eclipse.jdt.core.compiler.problem.tasks=warning +org.eclipse.jdt.core.compiler.problem.terminalDeprecation=warning +org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning +org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning +org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=ignore +org.eclipse.jdt.core.compiler.problem.uninternedIdentityComparison=disabled +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=warning +org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict=disabled +org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=info +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName=warning +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled +org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedImport=warning +org.eclipse.jdt.core.compiler.problem.unusedLabel=warning +org.eclipse.jdt.core.compiler.problem.unusedLocal=warning +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled +org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning +org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation=warning +org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning +org.eclipse.jdt.core.compiler.processAnnotations=disabled +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=1.8 +org.eclipse.jdt.core.compiler.storeAnnotations=disabled +org.eclipse.jdt.core.compiler.taskCaseSensitive=enabled +org.eclipse.jdt.core.compiler.taskPriorities=NORMAL,HIGH,NORMAL +org.eclipse.jdt.core.compiler.taskTags=TODO,FIXME,XXX +org.eclipse.jdt.core.computeJavaBuildOrder=ignore +org.eclipse.jdt.core.encoding=utf8 +org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false +org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647 +org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line=true +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false +org.eclipse.jdt.core.formatter.align_with_spaces=false +org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package=49 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter=0 +org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type=49 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assertion_message=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow=16 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon=16 +org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0 +org.eclipse.jdt.core.formatter.alignment_for_module_statements=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16 +org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_record_components=16 +org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0 +org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow=20 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_type_annotations=0 +org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0 +org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0 +org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=0 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=0 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_constructor=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_record_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped=true +org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=true +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=false +org.eclipse.jdt.core.formatter.comment.indent_root_tags=false +org.eclipse.jdt.core.formatter.comment.indent_tag_description=false +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true +org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true +org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off +org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=false +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_permitted_types=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert +org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert +org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.join_lines_in_comments=false +org.eclipse.jdt.core.formatter.join_wrapped_lines=false +org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false +org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false +org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never +org.eclipse.jdt.core.formatter.lineSplit=120 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines +org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=space +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.text_block_indentation=0 +org.eclipse.jdt.core.formatter.use_on_off_tags=true +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator=true +org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false +org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true +org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true +org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true +org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true +org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true +org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true +org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true +org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true +org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator=false +org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true +org.eclipse.jdt.core.incompatibleJDKLevel=ignore +org.eclipse.jdt.core.incompleteClasspath=error +org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter +org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc=50 diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Action.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Action.java new file mode 100644 index 0000000..cb0169f --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Action.java @@ -0,0 +1,4 @@ + +public interface Action { + public void Do(); +} diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Developer.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Developer.java new file mode 100644 index 0000000..94785be --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Developer.java @@ -0,0 +1,17 @@ + +public class Developer { + public static void main(String args[]) { + IDE ide=new IDE(); + Receiver intendedreceiver = new Receiver(); + System.out.println("Pressed save button!"); + SaveAction saveaction = new SaveAction(intendedreceiver); + ide.SetAction(saveaction); + ide.ExecuteAction(); + + System.out.println("Pressed saveAll button!"); + SaveAllAction saveallaction = new SaveAllAction(intendedreceiver); + ide.SetAction(saveallaction); + ide.ExecuteAction(); + } + +} diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/IDE.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/IDE.java new file mode 100644 index 0000000..876d84f --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/IDE.java @@ -0,0 +1,11 @@ + +public class IDE { + Action action; + public void SetAction(Action action) { + this.action = action; + } + public void ExecuteAction() { + action.Do(); + } +} + diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Receiver.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Receiver.java new file mode 100644 index 0000000..08aa960 --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/Receiver.java @@ -0,0 +1,9 @@ + +public class Receiver { + public void PerformSave() { + System.out.println("Saving file..."); + } + public void PerformSaveAll() { + System.out.println("Saving all the files..."); + } +} diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAction.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAction.java new file mode 100644 index 0000000..1fa2e0e --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAction.java @@ -0,0 +1,11 @@ + +public class SaveAction implements Action{ + Receiver receiver; + public SaveAction(Receiver receiver) { + this.receiver = receiver; + } + public void Do() { + receiver.PerformSave(); + } + +} diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAllAction.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAllAction.java new file mode 100644 index 0000000..4c1c758 --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Designpattern3/src/SaveAllAction.java @@ -0,0 +1,10 @@ + +public class SaveAllAction implements Action{ + Receiver receiver; + public SaveAllAction(Receiver receiver) { + this.receiver = receiver; + } + public void Do() { + receiver.PerformSaveAll(); + } +} diff --git a/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Threads/WrappingPaperArt.java b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Threads/WrappingPaperArt.java new file mode 100644 index 0000000..bea2c3c --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/Mock Esay Answers/Threads/WrappingPaperArt.java @@ -0,0 +1,97 @@ +import java.util.Scanner; + +public class WrappingPaperArt { + + public static void main(String[] args) { + Object lock = new Object(); + Scanner sc = new Scanner(System.in); + System.out.print("Enter Pattern 1 = "); + String pattern1 = sc.next(); + System.out.print("Enter Pattern 2 = "); + String pattern2 = sc.next(); + System.out.print("Enter count = "); + int count = sc.nextInt(); + + System.out.println("========Threads start printing patterns.======="); + + Thread patternThread1 = new Thread(new Pattern01(lock, pattern1, count)); + Thread patternThread2 = new Thread(new Pattern02(lock, pattern2, count)); + + patternThread1.setName("Pattern 01 Thread"); + patternThread2.setName("Pattern 02 Thread"); + patternThread1.start(); + patternThread2.start(); + } +} + +class Pattern01 implements Runnable{ + + Object lock; + String pattern; + int count; + + public Pattern01(Object lock, String pattern, int count) { + this.lock = lock; + this.pattern = pattern; + this.count = count; + } + + @Override + public void run() { + synchronized (lock) { + for (int x = 0; x < count; x++){ + try { + lock.wait(); + for (int y = count; y >= x; y--) { + System.out.print(" "); + } + for (int y = 0; y <= x; y++) { + System.out.print("+ "); + } + System.out.println(); + Thread.sleep(1000); + lock.notify(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + } +} + +class Pattern02 implements Runnable{ + + Object lock; + String pattern; + int count; + + public Pattern02(Object lock, String pattern, int count) { + this.lock = lock; + this.pattern = pattern; + this.count = count; + } + + @Override + public void run() { + synchronized (lock) { + for (int x = 0; x < count; x++){ + try { + lock.notify(); + + for (int y = count; y >= x; y--) { + System.out.print(" "); + } + for (int y = 0; y <= x; y++) { + System.out.print("- "); + } + System.out.println(); + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + } +} + diff --git a/Past Papers/Mock paper Answers-20211018/mock MCQ - answers.txt b/Past Papers/Mock paper Answers-20211018/mock MCQ - answers.txt new file mode 100644 index 0000000..5e00fb1 --- /dev/null +++ b/Past Papers/Mock paper Answers-20211018/mock MCQ - answers.txt @@ -0,0 +1,10 @@ +1->E +2->C +3->A,C +4->B,C,D,E +5->C +6->E +7->C +8->C +9->B +10->A,B,C,D \ No newline at end of file diff --git a/README.md b/README.md index 6bad73e..b31112d 100644 --- a/README.md +++ b/README.md @@ -51,10 +51,10 @@ Thanks goes to these wonderful people :heart: - - chetanbhasney02 + + ShanukaPrabodha
- Chetanbhasney02 + Shanuka Prabodha @@ -63,6 +63,35 @@ Thanks goes to these wonderful people :heart:
Kavindu Chethani + + + + chetanbhasney02 +
+ Chetanbhasney02 + + + + + + ShehaniHettiarachchi +
+ Shehani Hettiarachchi + + + + + ImgBotApp +
+ Imgbot + + + + + Randula98 +
+ Randula Yashasmith Mawaththa + diff --git a/Resources/Code Conventions.pdf b/Resources/Code Conventions.pdf new file mode 100644 index 0000000..8822f2d Binary files /dev/null and b/Resources/Code Conventions.pdf differ diff --git a/Resources/Exceptions.jpg b/Resources/Exceptions.jpg new file mode 100644 index 0000000..3c2a41b Binary files /dev/null and b/Resources/Exceptions.jpg differ diff --git a/Resources/Hierarchy of Java Exception Classes.jpg b/Resources/Hierarchy of Java Exception Classes.jpg new file mode 100644 index 0000000..3dc14d0 Binary files /dev/null and b/Resources/Hierarchy of Java Exception Classes.jpg differ diff --git a/Resources/Java Exception - CheatSheet.pdf b/Resources/Java Exception - CheatSheet.pdf new file mode 100644 index 0000000..0c32ca8 Binary files /dev/null and b/Resources/Java Exception - CheatSheet.pdf differ diff --git a/Resources/Java Generics - CheatSheet.pdf b/Resources/Java Generics - CheatSheet.pdf new file mode 100644 index 0000000..ccf3217 Binary files /dev/null and b/Resources/Java Generics - CheatSheet.pdf differ diff --git a/Resources/Java OOP - CheatSheet.pdf b/Resources/Java OOP - CheatSheet.pdf new file mode 100644 index 0000000..9228c6d Binary files /dev/null and b/Resources/Java OOP - CheatSheet.pdf differ diff --git a/Resources/Javabook.pdf b/Resources/Javabook.pdf new file mode 100644 index 0000000..0cde5a7 Binary files /dev/null and b/Resources/Javabook.pdf differ diff --git a/Resources/Useful Links.txt b/Resources/Useful Links.txt new file mode 100644 index 0000000..ecd5f3d --- /dev/null +++ b/Resources/Useful Links.txt @@ -0,0 +1,7 @@ +https://www.javatpoint.com/java-tutorial + +https://www.tutorialspoint.com/java/ + +https://www.udacity.com/course/java-programming-basics--ud282 + +https://docs.oracle.com/javase/tutorial/ \ No newline at end of file diff --git a/Tutorials/Turorial2Question1answer/Main.java b/Tutorials/Tutorial 02/Turorial2Question1answer/Main.java similarity index 100% rename from Tutorials/Turorial2Question1answer/Main.java rename to Tutorials/Tutorial 02/Turorial2Question1answer/Main.java diff --git a/Tutorials/Turorial2Question1answer/Student.java b/Tutorials/Tutorial 02/Turorial2Question1answer/Student.java similarity index 100% rename from Tutorials/Turorial2Question1answer/Student.java rename to Tutorials/Tutorial 02/Turorial2Question1answer/Student.java