00054707
Encapsulation
Encapsulation in Java is where data and variables are wrapped and grouped together by using methods. The variables of the class will be hidden initially and will only be displayed if the method of the same class is utilized
Two things must be done to achieve encapsulation * Declare the variables of a class as private. * Provide public setter and getter methods to modify and view the variables

Inheritance
This is where a class that is derived from another class is called subclass and inherits all fields and methods of its superclass (the main class) Variables and methods can then be added to the subclass as fit. The inheritance is also one way meaning that the superclass cannot inherit from the subclass

Class Sandwich {
}
Class sub Chicken extends Sandwich {
}

Polymorphism

Polymorphism is the ability of an object to take on many forms. This can be where a child class is created and extends a parent class to inherit their common variables and add new variables to match the requirements
Public interface Food {}
Public class Burger {}
Public class Bigmac extends Burger implements Food {}

Class
A class is a blue print from which individual objects are created and modified. There are three type of variables
Local variables: Variables that are defined inside method
Instance variables: Instance variables are variables within a class but outside any method
Class variables: Class variables are variables declared with in a class

Interface
An interface is a reference type in Java and is made up of a collection of abstract methods. A class implements an interface and inherits the abstract methods of the interface. It can never be declared only implemented

Public human {
Public void eat ();
Public void drink (); }
Object
This is a representation of a real world entity Objects have states and behaviours. For example a human has states - name, race as well as behaviours –talking, eating etc. An object is also an instance of a class.
Public Shivam ( String name, String age){
System.out.print(“My name is” + name + “And my age is” + age);
}

Constructor
Generally used in classes, if the programmer does not create a constructor for the class there is a default one. Objects use this in their creation and needs to invoke the constructor public class Dude { private String fname; public Doctor ( String fn) { fname= fn; }
Instance variables: Instance variables are variables within a class but outside any method public class Dude2 { private int age; private String fname;
}
Class variables: Class variables are variables declared with in a class public Doctor ( String fn, int ag) { fname = fn; age = ag;
}

Exception handling Used to try a piece of code and looks out for a error. Instead of exiting the program we can edit our code to take some form of action when this error occurs public void error1 (){ System.out.print("Enter age\n"); try { int age = in.nextInt(); System.out.println(age); } catch (InputMismatchException ex) { System.out.println("Wrong format entered"); } finally { System.out.println("The finally block ran"); } System.out.println("Program continues"); }
Class Diagram (UML) Unified Modelling Language is a type of static diagram that shows the processes, classes and variables of code. It shows the relationship between classes and methods and gives insight to what private variables are available and what classes have access to them Method Overloading
Method Overloading is a feature that allows a class to have two or more methods in the same class with the same name. The variables present can be the same or differ but this is used mostly when we want a different functionally in the method (to add instead of minus)