Object in java
- Objects are real-world entity.
- Objects may have different state and behavior.
- Example - In world different animals have different names like Lion, Goat, they eat different food, have different skin colour, height, weight etc.
Lion eat flesh, Goat eat grass.
Class in java
- Classes are blueprint/ template,
- objects are created from classes.
A Class basically consists of >
class MyClass { //class name
public MyClass() {} //constructor
private String name; //instance variable/ member variable
public void setName(String name) { //method
this.name = name;
}
}
|
A typical Class can consist of following >
/** Copyright (c), AnkitMittal JavaMadeSoEasy.com */
class MyClass { //class name
/* Static initialization block */
static {
System.out.println("static block");
}
/*Non-Static block (Instance initialization block)*/
{
System.out.println("non-static block");
}
public MyClass() { //constructor
super();
}
private int instanceVar; //instance variable/ member variable
private static int staticVar; //static variable/ class variable
public void instanceMethod() { //instance method
this.instanceVar=2;
class LocalInnerClass {} //LocalInnerClass
MyClass obj=new MyClass(){}; //Anonymous inner class
}
public static void staticMethod() { //static method
}
class InnerClass{} //inner class
static class StaticNestedClass {} //StaticNestedClass
interface NestedInterface{} //nested interface
static interface staticNestedInterface{} //static nested interface
}
|
Blocks>
Variables>
Instance and
Static variables
Methods>
Instance and
Static methods
(Method definition formation) -
Method definition is formed by using following 5 terms -
Note : Return type may be void, in that case method doesn’t return anything.
public String food(int x) throws Exception {
// Method body
return null;
}
|
Optionally, we may add static keyword, after or before public.
Must read : Copy by value and copy by reference in java - Primitive are passed by value & objects by reference
Inner Classes>
Inner class/ nested class,
static nested class,
local inner class and
anonymous inner class in java
nested interface>
nested interface
static nested interface
access modifiers - We may use different access modifiers with all variables, methods, constructor, inner class like private, package-private(Default), protected and public.
Program 1 to create Class and Objects >
We have Animal class (as used in Program), let’s understand this line -
Animals animal1 = new Animals();
|
We could divide above line into two lines -
Animals animal1; //animal1 is reference variable, currently it is pointing to null.
animal1 = new Animals(); //new animals() creates object and allocates memory.
|
There are 3 steps for creating objects from classes and initializing them.
STEP1 : Declaration of referencer variable:
Animals animal1;
|
animal1 is reference variable, currently it is pointing to null, till now no memory has been allocated, till now no real world animal exists.
STEP 2: Instantiation of class - create object using new keyword.
animal1 = new Animals();
|
new Animals() calls constructor and creates object and allocates memory, and animal1 is reference variable which is pointing to that newly created object.
STEP 3: Initialization of class - assigning values to member variables
animal1.setName("lion");
animal1.setFood("flesh");
|
Diagram >
So, what we understand is >
Class >
- Class Animals is blueprint/ template (it does not hold any memory),
- object animal1 is created from class Animals. (it holds memory)
Object >
- Object animal1 is real-world entity.
- Object animal1 have different state and behaviour- it’s name is lion and eat flesh.
- Object animal2 have different state and behaviour- it’s name is goat and eat grass.
Let’s code Program 1 to create Animal Class and Objects.
class Animals {
public Animals() {} //constructor
private String name; //instance variable/ member variable
private String food;
public String getName() { //method
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
}
/** Copyright (c), AnkitMittal JavaMadeSoEasy.com */
public class ClassObjectTest{
public static void main(String[] args) {
Animals animal1 = new Animals(); //creating object
animal1.setName("lion");
animal1.setFood("flesh");
Animals animal2 = new Animals();
animal2.setName("goat");
animal2.setFood("grass");
System.out.println("--animal1---");
System.out.println(animal1.getName());
System.out.println(animal1.getFood());
System.out.println("\n--animal2---");
System.out.println(animal2.getName());
System.out.println(animal2.getFood());
}
}
/*OUTPUT
--animal1---
lion
flesh
--animal2---
goat
grass
*/
|
Program 2 to create Class and Objects >
We have Employees class (as used in Program), let’s understand this line -
Employees emp1 = new Employees();
|
We could divide above line into two lines -
Employees emp1; //emp1 is reference variable, currently it is pointing to null.
emp1 = new Employees(); //new Employees() creates object and allocates memory.
|
Employees emp1;
emp1 is reference variable, currently it is pointing to null, till now no memory has been allocated, till now no real world employee exists.
emp1 = new Employees();
new Employees() calls constructor and creates object and allocates memory, and emp1 is reference variable which is pointing to that newly created object.
So, what we understand is >
Class >
- Class Employees is blueprint/ template (it does not hold any memory),
- object emp1 is created from class Employees. (it holds memory)
Object
- Object emp1 is real-world entity.
- Object emp1 have different state and behaviour- it’s name is ankit and id is 1.
- Object emp2 have different state and behaviour- it’s name is sam and id is 2.
Let’s code Program 2 to create Employees Class and Objects.
class Employees {
public Employees() {} //constructor
private int id;
private String food;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
}
/** Copyright (c), AnkitMittal JavaMadeSoEasy.com */
public class ClassObjectTest{
public static void main(String[] args) {
Employees emp1 = new Employees();
emp1.setId(1);
emp1.setFood("ankit");
Employees emp2 = new Employees();
emp2.setId(2);
emp2.setFood("sam");
System.out.println("--emp1---");
System.out.println(emp1.getId());
System.out.println(emp1.getFood());
System.out.println("\n--emp2---");
System.out.println(emp2.getId());
System.out.println(emp2.getFood());
}
}
/*OUTPUT
--emp1---
1
ankit
--emp2---
2
sam
*/
|
RELATED LINKS>
Interface in java - Multiple inheritance, Marker interfaces, When to use interface practically, 12 features
Abstract class in java - When to use abstract class or interface practically, 10 features
Constructor in java - Constructor chaining, access modifiers with constructors, constructor overloading, exception thrown, constructors are not inherited
Labels:
Core Java