// Creation of an Object
public class Main22 {
int x = 5;
public static void main(String[] args) {
Main22 myObj = new Main22();
System.out.println(myObj.x);
}
}
Output:
//Multiple Objects Cretion
public class Main23 {
int x = 5;
public static void main(String[] args) {
Main23 myObj1 = new Main23(); //
Object 1
Main23 myObj2 = new Main23(); //
Object 2
System.out.println(myObj1.x);
System.out.println(myObj2.x);
}
}
Output:
//Using Multiple Classes
public class Main24 {
int x = 5;
}
class Second {
public static void main(String[] args) {
Main24 myObj = new Main24();
System.out.println(myObj.x);
}
}
Output:
Javac Main24.java
Javac Second.java
Java Second
//Example: Java Class and Objects
class Lamp {
// stores the value for light
// true if light is on
// false if light is off
boolean isOn;
// method to turn on the light
void turnOn() {
isOn = true;
System.out.println("Light on? " + isOn);
// method to turnoff the light
void turnOff() {
isOn = false;
System.out.println("Light on? " + isOn);
}
}
class Main25 {
public static void main(String[] args) {
// create objects led and halogen
Lamp led = new Lamp();
Lamp halogen = new Lamp();
// turn on the light by
// calling method turnOn()
led.turnOn();
// turn off the light by
// calling method turnOff()
halogen.turnOff();
}
}
Output:
//Example: Create objects inside the same
class
class Lamp {
// stores the value for light
// true if light is on
// false if light is off
boolean isOn;
// method to turn on the light
void turnOn() {
isOn = true;
System.out.println("Light on? " + isOn);
public static void main(String[] args) {
// create an object of Lamp
Lamp led = new Lamp();
// access method using object
led.turnOn();
}
}
Output:
//Java Program to illustrate how to define a
class and fields
//Defining a Student class.
class Student{
//defining fields
int id;//field or data member or instance
variable
String name;
//creating main method inside the Student
class
public static void main(String args[]){
//Creating an object or instance
Student s1=new Student();//creating an
object of Student
//Printing values of the object
System.out.println(s1.id);//accessing
member through reference variable
System.out.println(s1.name);
}
}
Output:
//Java Program to demonstrate having the
main method in
//another class
//Creating Student class.
class Student12{
int id;
String name;
}
//Creating another class TestStudent1
which contains the main method
class TestStudent1{
public static void main(String args[]){
Student12 s1=new Student12();
System.out.println(s1.id);
System.out.println(s1.name);
}
}
Output:
//1) Object and Class Example:
Initialization through reference
class Student{
int id;
String name;
}
class TestStudent2{
public static void main(String args[]){
Student s1=new Student();
s1.id=101;
s1.name="Sonoo";
System.out.println(s1.id+"
"+s1.name);//printing members with a
white space
}
}
Output:
class Student{
int id;
String name;
}
//Object and Class Example: Initialization
through reference
class TestStudent3{
public static void main(String args[]){
//Creating objects
Student s1=new Student();
Student s2=new Student();
//Initializing objects
s1.id=101;
s1.name="Sonoo";
s2.id=102;
s2.name="Amit";
//Printing data
System.out.println(s1.id+" "+s1.name);
System.out.println(s2.id+" "+s2.name);
}
}
Output:
//2) Object and Class Example:
Initialization through method
class Student{
int rollno;
String name;
void insertRecord(int r, String n){
rollno=r;
name=n;
}
void
displayInformation(){System.out.println(r
ollno+" "+name);}
}
class TestStudent4{
public static void main(String args[]){
Student s1=new Student();
Student s2=new Student();
s1.insertRecord(111,"Karan");
s2.insertRecord(222,"Aryan");
s1.displayInformation();
s2.displayInformation();
}
}
Output:
//3) Object and Class Example:
Initialization through a constructor
class Employee{
int id;
String name;
float salary;
void insert(int i, String n, float s) {
id=i;
name=n;
salary=s;
}
void display(){System.out.println(id+"
"+name+" "+salary);}
}
public class TestEmployee {
public static void main(String[] args) {
Employee e1=new Employee();
Employee e2=new Employee();
Employee e3=new Employee();
e1.insert(101,"ajeet",45000);
e2.insert(102,"irfan",25000);
e3.insert(103,"nakul",55000);
e1.display();
e2.display();
e3.display();
}
}
Output:
//Object and Class Example: Rectangle
class Rectangle{
int length;
int width;
void insert(int l, int w){
length=l;
width=w;
}
void
calculateArea(){System.out.println(length
*width);}
}
class TestRectangle1{
public static void main(String args[]){
Rectangle r1=new Rectangle();
Rectangle r2=new Rectangle();
r1.insert(11,5);
r2.insert(3,15);
r1.calculateArea();
r2.calculateArea();
}
}
Output:
//Creating multiple objects by one type
only
//Java Program to illustrate the use of
Rectangle class which
//has length and width data members
class Rectangle{
int length;
int width;
void insert(int l,int w){
length=l;
width=w;
}
void
calculateArea(){System.out.println(length
*width);}
}
class TestRectangle2{
public static void main(String args[]){
Rectangle r1=new Rectangle(),r2=new
Rectangle();//creating two objects
r1.insert(11,5);
r2.insert(3,15);
r1.calculateArea();
r2.calculateArea();
}
}
Output:
//Real World Example: Account
//Java Program to demonstrate the working
of a banking-system
//where we deposit and withdraw amount
from our account.
//Creating an Account class which has
deposit() and withdraw() methods
class Account{
int acc_no;
String name;
float amount;
//Method to initialize object
void insert(int a,String n,float amt){
acc_no=a;
name=n;
amount=amt;
}
//deposit method
void deposit(float amt){
amount=amount+amt;
System.out.println(amt+" deposited");
}
//withdraw method
void withdraw(float amt){
if(amount<amt){
System.out.println("Insufficient Balance");
}else{
amount=amount-amt;
System.out.println(amt+" withdrawn");
}
}
//method to check the balance of the
account
void
checkBalance(){System.out.println("Balan
ce is: "+amount);}
//method to display the values of an object
void
display(){System.out.println(acc_no+"
"+name+" "+amount);}
}
//Creating a test class to deposit and
withdraw amount
class TestAccount{
public static void main(String[] args){
Account a1=new Account();
a1.insert(832345,"Ankit",1000);
a1.display();
a1.checkBalance();
a1.deposit(40000);
a1.checkBalance();
a1.withdraw(15000);
a1.checkBalance();
}}
Output:
// Class Declaration
public class Dog {
// Instance Variables
String name;
String breed;
int age;
String color;
// Constructor Declaration of Class
public Dog(String name, String breed,
int age,
String color)
{
this.name = name;
this.breed = breed;
this.age = age;
this.color = color;
}
// method 1
public String getName() { return name;
}
// method 2
public String getBreed() { return breed;
}
// method 3
public int getAge() { return age; }
// method 4
public String getColor() { return color; }
@Override public String toString()
{
return ("Hi my name is " +
this.getName()
+ ".\nMy breed,age and color are
"
+ this.getBreed() + "," +
this.getAge()
+ "," + this.getColor());
}
public static void main(String[] args)
{
Dog tuffy
= new Dog("tuffy", "papillon", 5,
"white");
System.out.println(tuffy.toString());
}
}
Output:
public class GFG {
// sw=software
static String sw_name;
static float sw_price;
static void set(String n, float p)
{
sw_name = n;
sw_price = p;
}
static void get()
{
System.out.println("Software name is:
" + sw_name);
System.out.println("Software price is:
"
+ sw_price);
}
public static void main(String args[])
{
GFG.set("Visual studio", 0.0f);
GFG.get();
}
}
Output:
Class Object
Class is the blueprint of an object. It is
An object is an instance of the class.
used to create objects.
No memory is allocated when a class is Memory is allocated as soon as an object
declared. is created.
An object is a real-world entity such as a
A class is a group of similar objects.
book, car, etc.
Class is a logical entity. An object is a physical entity.
Objects can be created many times as per
A class can only be declared once.
requirement.
Objects of the class car can be BMW,
An example of class can be a car.
Mercedes, Ferrari, etc.
public class Puppy {
int puppyAge;
public Puppy(String name) {
// This constructor has one parameter,
name.
System.out.println("Name chosen is :"
+ name );
}
public void setAge( int age ) {
puppyAge = age;
}
public int getAge( ) {
System.out.println("Puppy's age is :" +
puppyAge );
return puppyAge;
}
public static void main(String []args) {
/* Object creation */
Puppy myPuppy = new Puppy(
"tommy" );
/* Call class method to set puppy's age
*/
myPuppy.setAge( 2 );
/* Call another class method to get
puppy's age */
myPuppy.getAge( );
/* You can access instance variable as
follows as well */
System.out.println("Variable Value :"
+ myPuppy.puppyAge );
}
}
Output:
import java.io.*;
public class Employee {
String name;
int age;
String designation;
double salary;
// This is the constructor of the class
Employee
public Employee(String name) {
this.name = name;
}
// Assign the age of the Employee to the
variable age.
public void empAge(int empAge) {
age = empAge;
}
/* Assign the designation to the variable
designation.*/
public void empDesignation(String
empDesig) {
designation = empDesig;
}
/* Assign the salary to the variable
salary.*/
public void empSalary(double
empSalary) {
salary = empSalary;
}
/* Print the Employee details */
public void printEmployee() {
System.out.println("Name:"+ name );
System.out.println("Age:" + age );
System.out.println("Designation:" +
designation );
System.out.println("Salary:" + salary);
}
}
import java.io.*;
public class EmployeeTest {
public static void main(String args[]) {
/* Create two objects using constructor
*/
Employee empOne = new
Employee("James Smith");
Employee empTwo = new
Employee("Mary Anne");
// Invoking methods for each object
created
empOne.empAge(26);
empOne.empDesignation("Senior
Software Engineer");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("Software
Engineer");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}
Output:
public class Main59 {
// Static method
static void myStaticMethod() {
System.out.println("Static methods can
be called without creating objects");
}
// Public method
public void myPublicMethod() {
System.out.println("Public methods
must be called by creating objects");
}
// Main method
public static void main(String[] args) {
myStaticMethod(); // Call the static
method
// myPublicMethod(); This would
compile an error
Main59 myObj = new Main59(); //
Create an object of Main
myObj.myPublicMethod(); // Call the
public method on the object
}
}
Output:
