Thursday, 27 August 2015

Java Tutorial : What is an Interface (Remote)

Click here to watch in Youtube :
https://www.youtube.com/watch?v=rLyF_27YtWw&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

Java Tutorial : What is an Interface (Remote)

Person.java

public class Person
{

    private String name;
    private int age;

    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    @Override
    public String toString()
    {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    public void switchOnTheTV()
    {
        System.out.println(name+" is calling switchOn method of Remote ");
        Remote remote = new LEDTVRemote();
        remote.switchOn();
    }

    public void switchOffTheTV()
    {
        System.out.println(name+" is calling switchOff method of Remote ");
        Remote remote = new LEDTVRemote();
        remote.switchOff();
    }
    
}

Remote.java

/**
 * An interface is a group of related methods with empty bodies.
 */
public interface Remote
{
    void switchOn();

    void switchOff();
}

LEDTVRemote.java

public class LEDTVRemote implements Remote
{

    @Override
    public void switchOn()
    {
        System.out.println("switchOn method of LEDTVRemote is called"
                + " and Remote is calling switchOnTV method of LED TV ");
        LedTV ledtv = new LedTV("106 Cm",true);
        ledtv.switchOnTV();
    }

    @Override
    public void switchOff()
    {
        System.out.println("switchOff method of LEDTVRemote is called"
                + " and Remote is calling switchOffTV method of LED TV ");
        LedTV ledtv = new LedTV("106 Cm",true);
        ledtv.switchOffTV();
    }

}

LedTV.java

public class LedTV
{

    private String displaySize;
    private boolean isSmartTv;

    public LedTV(String displaySize, boolean isSmartTv)
    {
        super();
        this.displaySize = displaySize;
        this.isSmartTv = isSmartTv;
    }

    public String getDisplaySize()
    {
        return displaySize;
    }

    public void setDisplaySize(String displaySize)
    {
        this.displaySize = displaySize;
    }

    public boolean isSmartTv()
    {
        return isSmartTv;
    }

    public void setSmartTv(boolean isSmartTv)
    {
        this.isSmartTv = isSmartTv;
    }
    
    public void switchOnTV()
    {
        System.out.println("switchOnTV method of LEDTV is called.");
        System.out.println("LED TV is Switched on.");
    }

    public void switchOffTV()
    {
        System.out.println("switchOffTV method of LEDTV is called.");
        System.out.println("LED TV is Switched off.");
    }

}

InterfaceDemo.java

public class InterfaceDemo
{

    public static void main(String[] args)
    {
        Person peter = new Person("Peter",28);
        peter.switchOnTheTV();
        System.out.println("-----------------------------------------------");
        peter.switchOffTheTV();
    }
}

Output

Peter is calling switchOn method of Remote 
switchOn method of LEDTVRemote is called and Remote is calling switchOnTV method of LED TV 
switchOnTV method of LEDTV is called.
LED TV is Switched on.
-----------------------------------------------
Peter is calling switchOff method of Remote 
switchOff method of LEDTVRemote is called and Remote is calling switchOffTV method of LED TV 
switchOffTV method of LEDTV is called.
LED TV is Switched off.

To Download InterfaceDemoLedApp Project Click the below link
https://sites.google.com/site/javaee4321/java/InterfaceDemoLedApp.zip?attredirects=0&d=1

See also:

All JavaEE Viedos Playlist

All JavaEE Viedos

All JAVA EE Links

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Java Tutorial : What is an Interface (Switch)

Click here to watch in Youtube :
https://www.youtube.com/watch?v=x8SqfAWYE9E&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

Java Tutorial : What is an Interface (Switch)

Person.java

public class Person
{

    private String name;
    private int age;

    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    @Override
    public String toString()
    {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    public void switchOnTheBulb()
    {
        Switch bulbswitch = new LEDBulbSwitch();
        bulbswitch.switchOn();
    }

    public void switchOffTheBulb()
    {
        Switch bulbswitch = new LEDBulbSwitch();
        bulbswitch.switchOff();
    }
    
}

Switch.java

/**
 * An interface is a group of related methods with empty bodies.
 */
public interface Switch
{
    void switchOn();

    void switchOff();
}

LEDBulbSwitch.java

public class LEDBulbSwitch implements Switch
{

    @Override
    public void switchOn()
    {
        LedBulb ledbulb = new LedBulb("'A' shape","2.3 inch");
        ledbulb.switchOnTheLedBulb();
    }

    @Override
    public void switchOff()
    {
        LedBulb ledbulb = new LedBulb("'A' shape","2.3 inch");
        ledbulb.switchOffTheLedBulb();
    }

}

LedBulb.java

public class LedBulb
{

    private String shape;
    private String diameter;

    public LedBulb(String shape, String diameter)
    {
        super();
        this.shape = shape;
        this.diameter = diameter;
    }

    public String getShape()
    {
        return shape;
    }

    public void setShape(String shape)
    {
        this.shape = shape;
    }

    public String getDiameter()
    {
        return diameter;
    }

    public void setDiameter(String diameter)
    {
        this.diameter = diameter;
    }

    public void switchOnTheLedBulb()
    {
        System.out.println(shape +" Led Bulb is switched on");
    }

    public void switchOffTheLedBulb()
    {
        System.out.println(shape +" Led Bulb is switched off");
    }

}

InterfaceDemo.java

public class InterfaceDemo
{

    public static void main(String[] args)
    {
        Person peter = new Person("Peter",28);
        peter.switchOnTheBulb();
        peter.switchOffTheBulb();
    }
}

Output

'A' shape Led Bulb is switched on
'A' shape Led Bulb is switched off

To Download InterfaceDemoSwitchApp Project Click the below link
https://sites.google.com/site/javaee4321/java/InterfaceDemoSwitchApp.zip?attredirects=0&d=1

See also:

All JavaEE Viedos Playlist

All JavaEE Viedos

All JAVA EE Links

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Tuesday, 25 August 2015

Java Tutorial : Inheritance Has A Relationship (Person)

🚀 Master Java with Ram N Java!

Enjoyed the video? Subscribe for more easy-to-follow coding tutorials!

SUBSCRIBE NOW

Understanding the "HAS-A" Relationship in Java

In object-oriented programming, creating clean and reusable code is key. One of the most important concepts to master is the HAS-A relationship, also known as Aggregation. In this guide, we'll break it down using a simple "Person, Employee, and Student" example.

What is a "HAS-A" Relationship?

While inheritance (IS-A) lets a class inherit features from a parent, a HAS-A relationship means one class contains an instance of another class. It's all about composition and code reusability!

The Core Concept: Person vs. Address

IS-A: An Employee is a Person. This is Inheritance.
HAS-A: An Employee has an Address. This is Aggregation.

How it Works in Java

In the video, we see three main classes working together:

Person Class: The base class with common properties like name and age.
Address Class: A separate class containing street, city, and zip.
Employee & Student Classes: These extend Person (Inheritance) but also include an Address object as a property (Aggregation).

Why Use Aggregation?

Aggregation is best used for code reusability when there is no "is-a" relationship. For example, a student isn't an address, but they have one. By keeping the address logic in its own class, we can use it for both Employees and Students without writing the same code twice!

Watch More From My Channel

Click here to watch in Youtube :
https://www.youtube.com/watch?v=p_4U_LVMbSk&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge

Java Tutorial : Inheritance Has A Relationship (Person)

Person.java
public class Person

{

    private String name;
    private int age;

    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    @Override
    public String toString()
    {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    
}

Address.java

public class Address
{
    private String street;
    private String city;
    private String state;
    private String zip;

    public Address(String street, String city, String state, String zip)
    {
        super();
        this.street = street;
        this.city = city;
        this.state = state;
        this.zip = zip;
    }

    public String getStreet()
    {
        return street;
    }

    public void setStreet(String street)
    {
        this.street = street;
    }

    public String getCity()
    {
        return city;
    }

    public void setCity(String city)
    {
        this.city = city;
    }

    public String getState()
    {
        return state;
    }

    public void setState(String state)
    {
        this.state = state;
    }

    public String getZip()
    {
        return zip;
    }

    public void setZip(String zip)
    {
        this.zip = zip;
    }

    @Override
    public String toString()
    {
        return "Address [street=" + street + ", city=" + city + ", state="
                + state + ", zip=" + zip + "]";
    }

}

Employee.java

/**
 * 
 * Employee class extends Person class means Employee IS-A Person.
 * 
 * Employee extends Person and thus inherits all methods and properties from
 * Person (except final and static).
 * 
 * Employee can also define all its specific functionality.
 */
public class Employee extends Person
{
    private String departmentName;
    private int employeeId;

    /*
     * Employee HAS-A Address
     */
    private Address address;

    public Employee(String name, int age, String departmentName,
            int employeeId, Address address)
    {
        super(name, age);
        this.departmentName = departmentName;
        this.employeeId = employeeId;
        this.address = address;
    }

    public String getDepartmentName()
    {
        return departmentName;
    }

    public void setDepartmentName(String departmentName)
    {
        this.departmentName = departmentName;
    }

    public int getEmployeeId()
    {
        return employeeId;
    }

    public void setEmployeeId(int employeeId)
    {
        this.employeeId = employeeId;
    }

    public Address getAddress()
    {
        return address;
    }

    public void setAddress(Address address)
    {
        this.address = address;
    }

    @Override
    public String toString()
    {
        return "Employee [departmentName=" + departmentName + ", employeeId="
                + employeeId + ", address=" + address + ", getName()="
                + getName() + ", getAge()=" + getAge() + "]";
    }

}

Student.java

/**
 * 
 * Student class extends Person class means Student IS-A Person.
 * 
 * Student extends Person and thus inherits all methods and properties from
 * Person (except final and static).
 * 
 * Student can also define all its specific functionality.
 */
public class Student extends Person
{

    private double grade;
    private int rollNo;

    /*
     * Student HAS-A Address
     */
    private Address address;

    public Student(String name, int age, double grade, int rollNo,
            Address address)
    {
        super(name, age);
        this.grade = grade;
        this.rollNo = rollNo;
        this.address = address;
    }

    public double getGrade()
    {
        return grade;
    }

    public void setGrade(double grade)
    {
        this.grade = grade;
    }

    public int getRollNo()
    {
        return rollNo;
    }

    public void setRollNo(int rollNo)
    {
        this.rollNo = rollNo;
    }

    public Address getAddress()
    {
        return address;
    }

    public void setAddress(Address address)
    {
        this.address = address;
    }

    @Override
    public String toString()
    {
        return "Student [grade=" + grade + ", rollNo=" + rollNo + ", address="
                + address + ", getName()=" + getName() + ", getAge()="
                + getAge() + "]";
    }

}

RelationshipDemo.java

public class RelationshipDemo
{

    public static void main(String[] args)
    {

        Address peterAddress = new Address("13th Cross", "Bangalore",
                "Karnataka", "560001");

        Employee peter = new Employee("Peter", 33, "Income Tax Department",
                350, peterAddress);
        
        System.out.println("Employee Peter Details : ");
        System.out.println(peter);
        
        System.out.println("----------------------------------------------");
        
        Address johnAddress = new Address("17th Cross", "Chennai",
                "TamilNadu", "600100");

        Student john = new Student("John", 33, 3.5,
                2, johnAddress);
        
        System.out.println("Student john Details : ");
        System.out.println(john);


    }
}

Output

Employee Peter Details : 
Employee [departmentName=Income Tax Department, employeeId=350, 
address=Address [street=13th Cross, city=Bangalore, 
state=Karnataka, zip=560001], getName()=Peter, getAge()=33]
----------------------------------------------
Student john Details : 
Student [grade=3.5, rollNo=2, address=Address [street=17th Cross,
city=Chennai, state=TamilNadu, zip=600100], getName()=John, 
getAge()=33]

To Download InheritanceDemo-HAS-A-PersonApp Project Click the below link
https://sites.google.com/site/javaee4321/java/InheritanceDemo-HAS-A-PersonApp.zip?attredirects=0&d=1

See also:

All JavaEE Viedos Playlist

All JavaEE Viedos

All JAVA EE Links

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Monday, 24 August 2015

Java Tutorial : Inheritance Has A Relationship (Car)

🚀 Master Java Programming Today!

Join the Ram N Java community for the simplest coding tutorials.

SUBSCRIBE TO CHANNEL

Understanding the "HAS-A" Relationship in Java

In the world of Java, building complex systems requires us to connect different classes. While Inheritance (IS-A) is popular, the HAS-A Relationship (also known as Composition or Aggregation) is often more flexible and powerful for real-world scenarios.

What Exactly is a HAS-A Relationship?

A HAS-A relationship occurs when one class uses an instance of another class as a member variable. Instead of inheriting properties, the class "owns" or "has" those properties through another object.

Example: A Car has an Engine. The Car doesn't "become" an Engine (which would be inheritance); it simply contains one to function.

Key Components in the Video

In this tutorial, we break down the logic using two main entities:

The Car Class: This acts as the main container.
The Engine/Specific Parts: These are separate classes that define specific behaviors.

Why Should You Use HAS-A?

Code Reusability: You can use the same Engine class for a Car, a Truck, or a Boat.
Better Flexibility: You can easily change the parts of a class without rewriting the entire inheritance tree.
Simplicity: It keeps your classes focused on one specific job (Single Responsibility Principle).

Friday, 21 August 2015

Java Tutorial : Inheritance IS A Relationship Introduction

🔥 Master Java the Easy Way!

Don't miss out on more beginner-friendly coding guides from Ram N Java.

SUBSCRIBE TO RAM N JAVA

The Fundamentals of "IS-A" Relationship in Java

One of the most powerful features of Object-Oriented Programming (OOP) is Inheritance. In Java, this is commonly referred to as the IS-A relationship. It allows us to create a new class based on an existing class, making our code more organized and efficient.

What is an IS-A Relationship?

An "IS-A" relationship is a way of saying that one object is a specialized version of another. In Java, we achieve this by using the extends keyword for classes or the implements keyword for interfaces.

Think about it like this: A Dog IS-A Animal. A Car IS-A Vehicle. In these examples, the Dog inherits all the general traits of an Animal but adds its own unique behaviors.

Why Use Inheritance?

Code Reusability: You don't have to write the same code over and over.
Method Overriding: You can change how a specific behavior works in a child class.
Better Structure: It creates a clear hierarchy that is easy for developers to read.

Key Terms to Remember

Super Class (Parent): The class whose features are inherited.
Sub Class (Child): The class that inherits the features.

Check Out More From My Channel

👉 What is IS-A Relationship in Java Inheritance? 👉 Java Inheritance IS-A Relationship (Animal Example) 👉 Different Types of Java Inheritance Explained

Click the below Image to Enlarge

Java Tutorial : Inheritance IS A Relationship Introduction

🚀 Master Java with Ram N Java!

Want to become a pro developer? Join our community for simple, daily coding lessons!

SUBSCRIBE NOW

Understanding the "IS-A" Relationship in Java

In Java, the IS-A relationship is the foundation of inheritance. It allows us to create a hierarchy where a specialized class (child) inherits the properties and behaviors of a more general class (parent). This makes our code clean, reusable, and easy to maintain.

What is an "IS-A" Relationship?

The term "IS-A" refers to the relationship between a parent class and its child class. When we say one class extends another, we are saying that the child class is a specific type of the parent class.

Example: If you have a class Vehicle and a class Car that extends it, we say a Car IS-A Vehicle.

Key Keywords You Need to Know

extends: Used for class inheritance. It signifies that one class is a sub-type of another.
implements: Used when a class inherits from an interface, representing an "IS-A" relationship with a contract.

Benefits for Beginners

No More Redundancy: You don't have to rewrite common logic for every new class.
Scalability: It's easier to add new features to your application without breaking existing code.
Polymorphism: It allows you to use a parent reference to hold child objects, making your code dynamic.

Thursday, 27 August 2015

Java Tutorial : Java Inheritance Has-A Relationship - Playlist

Java Tutorial : Java Inheritance IS-A and Has-A Relationship - Playlist

Java Tutorial : Java Inheritance IS-A Relationship - Playlist

Java Tutorial : Java Interface - Playlist

Java Tutorial : What is an Interface (Remote)

Java Tutorial : What is an Interface (Switch)

Tuesday, 25 August 2015

Java Tutorial : Inheritance Has A Relationship (Person)

Understanding the "HAS-A" Relationship in Java

What is a "HAS-A" Relationship?

The Core Concept: Person vs. Address

How it Works in Java

Why Use Aggregation?

Watch More From My Channel

Monday, 24 August 2015

Java Tutorial : Inheritance Has A Relationship (Car)

🚀 Master Java Programming Today!

Understanding the "HAS-A" Relationship in Java

What Exactly is a HAS-A Relationship?

Key Components in the Video

Why Should You Use HAS-A?

Recommended Tutorials for You

Friday, 21 August 2015

Java Tutorial : Inheritance IS A Relationship Introduction

🔥 Master Java the Easy Way!

The Fundamentals of "IS-A" Relationship in Java

What is an IS-A Relationship?

Why Use Inheritance?

Key Terms to Remember

Check Out More From My Channel

Thursday, 20 August 2015

Java Tutorial : Inheritance IS A Relationship

🚀 Master Java with Ram N Java!

Understanding the "IS-A" Relationship in Java

What is an "IS-A" Relationship?

Key Keywords You Need to Know

Benefits for Beginners

More Recommended Java Tutorials

Tutorials