Gallery
Share
Explore

Java Interfaces and SETS

Interfaces in Java

See lab code here:

⁠
⁠
⁠
An interface in Java is a blueprint of a class, or you can say it is a collection of abstract methods and static constants.
An Interface tells a Class WHAT to do but leaves it up to the Programmer to determine HOW to do it.
The REASON WHY Interfaces were introduced into Java is because when we are programming enterprise scale systems, we devide the work into numerous teams.
Team A can code part of the solution, Team B codes another part, and Team C can integrate all teams’ code because we know that all the classes were written to obey the formative and structural rules of the enterprise architecture.
I can write classes to call methods in other classes written by you, and I can be sure that those methods will be there. AND you method will a result set OBJECT which I can write code to iterate over and process.
In an interface, each method is public and abstract but it does not contain any constructor.
Along with abstraction, interfaces also help to achieve multiple inheritance in Java.
Does Java support multiple inheritance?

Contract-based programming and COMPONENT-oriented UML Design
Interfaces essentially provide a contract that classes agreeing to the interface must follow.
This contract states what a class should do, but not how it should do it.
This kind of abstraction is incredibly powerful for large-scale applications where different teams might be working on different parts of the software.
It ensures a standard way of interacting with objects, regardless of their underlying implementation.
Here's a concrete example to illustrate this:
public interface DataStorage {
void saveData(String data);
String fetchData();
}

Team A might decide to implement DataStorage with a local file storage system:

public class FileDataStorage implements DataStorage {
@Override
public void saveData(String data) {
// Save data to a local file.
}

@Override
public String fetchData() {
// Fetch data from a local file.
return "File data";
}
}

While Team B might choose to implement DataStorage using a cloud-based system:

public class CloudDataStorage implements DataStorage {
@Override
public void saveData(String data) {
// Save data to the cloud.
}

@Override
public String fetchData() {
// Fetch data from the cloud.
return "Cloud data";
}
}

Team C, responsible for integrating the software, doesn't need to know the details of how data is being stored. They can interact with both FileDataStorage and CloudDataStorage through the DataStorage interface, treating them as the same type of object:
javaCopy code
public class DataProcessor {
private DataStorage dataStorage;

// The constructor accepts any class that implements DataStorage.
public DataProcessor(DataStorage dataStorage) {
this.dataStorage = dataStorage;
}

public void process() {
dataStorage.saveData("Important data");
String data = dataStorage.fetchData();
System.out.println("Fetched data: " + data);
}
}

This level of abstraction allows teams to work independently without having to worry too much about what the other teams are doing. As long as the contract provided by the interface is followed, everything will work as expected when it's time to integrate the different parts of the software.

Defining an Interface

Here is a simple example of how you can define an interface:
javaCopy code
public interface Animal {
void eat();
void sleep();
}

In this example, we've defined an Animal interface with two methods: eat and sleep. Any class that implements this interface will have to provide an implementation for these methods.

Implementing an Interface

Here's how a class can implement an interface:
javaCopy code
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog eats");
}

@Override
public void sleep() {
System.out.println("The dog sleeps");
}
}

In this example, we've created a Dog class that implements the Animal interface. As a result, we had to provide an implementation for the eat and sleep methods.

Using an Interface

You can use an interface to call the methods of an object:
javaCopy code
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.eat();
dog.sleep();
}
}

Here, we're creating a Dog object but referencing it with an Animal interface. We're then calling the eat and sleep methods.

Interfaces and Inheritance

A class can implement multiple interfaces, achieving something similar to multiple inheritance. Here's an example:
javaCopy code
public interface Mammal {
void feedMilk();
}

public class Dog implements Animal, Mammal {
// implementation of Animal and Mammal methods
@Override
public void eat() {
System.out.println("The dog eats");
}

@Override
public void sleep() {
System.out.println("The dog sleeps");
}

@Override
public void feedMilk() {
System.out.println("The dog feeds milk to its puppies");
}
}

In this example, Dog is implementing both the Animal and Mammal interfaces, and so it provides an implementation for all three methods: eat, sleep, and feedMilk.
This should give you a basic understanding of how interfaces work in Java. They can be a powerful tool for abstraction and multiple inheritance. For a deeper understanding, you could look into default methods in interfaces, the Comparable and Iterable interfaces, and how interfaces can be used in combination with abstract classes.

interfaces and contract-based programming are fundamental aspects of component-oriented design and UML (Unified Modeling Language).

Contract-Based Programming
In contract-based programming, also known as Design by Contract (DbC), software components (like classes and methods) have a contract that defines their obligations and benefits. These contracts often include preconditions, postconditions, and invariants.
Preconditions: What must be true before a method is executed.
Postconditions: What the method guarantees is true after its execution.
Invariants: What always remains true, before and after the execution.
Java interfaces are an example of a contract. The interface defines a contract of methods that the implementing class must provide. Here is a simple contract example in Java:
public interface Sorter {
// The contract stipulates that any class implementing Sorter
// must have a method that takes an array of integers and sorts them.
void sort(int[] numbers);
}

Any class implementing the Sorter interface is under contract to provide a sort method that takes an array of integers.
Component-Oriented Design and UML
Component-oriented design focuses on the decomposition of the design into individual functional or logical components. The goal is to build large software systems by integrating existing and new components, where each component provides a specific functionality. This is where UML comes in.
UML is a standardized modeling language that visually represents a system along with its main actors, roles, actions, artifacts, and the interactions among these concepts. It can represent components, interfaces, and their relationships.
In the context of interfaces and component-based design, UML diagrams can be used to depict the system. For example, in a UML class diagram, an interface is represented as a circle, and the relationship between the interface and classes that implement the interface is represented as a lollipop notation or a dashed line with a closed, hollow arrowhead.
Here's a textual representation of what it might look like:
cssCopy code
[ Sorter ]
^
|
______|______
| |
[QuickSort] [MergeSort]

In this UML diagram, Sorter is an interface and QuickSort and MergeSort are classes that implement the Sorter interface. The arrow from each class points to the Sorter interface, indicating that they implement it.
This kind of diagram can help design and communicate the structure of a component-based system. It gives you a high-level overview of how different parts of the system relate to each other and what contracts they need to adhere to.

Java Set Interface

The Set interface is one of the core interfaces provided in the Java Collection framework. It extends the Collection interface and represents a collection that contains no duplicate elements. Sets also don't provide a control over the position where you can insert an element. This means, you can't ensure any specific order of elements in a Set.
Here is a simple example of how you can use a Set in Java:
javaCopy code
import java.util.HashSet;
import java.util.Set;

public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
System.out.println(set);
}
}

In this example, we're creating a Set of String objects and adding three fruits to it. When we print the Set, you'll notice that the order of the elements may not be the same as the order in which we added them. That's because Set does not guarantee any specific order.

Java HashSet Class

HashSet is a class in Java that implements the Set interface. It uses a mechanism called hashing to store elements. HashSet doesn't maintain any order of its elements, and it allows at most one null value. HashSet is generally faster than TreeSet (another implementation of the Set interface) because it uses a hash table internally.
Here is a simple example of a HashSet:
javaCopy code
import java.util.HashSet;

public class Main {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
set.add("Apple");
System.out.println(set);
}
}

In this example, we're adding "Apple" twice to the HashSet. When we print the HashSet, you'll notice that "Apple" appears only once because HashSet does not allow duplicates.

Hashing and HashSet

The way HashSet works is that it uses the hashCode method of the objects being inserted to determine where to put the object internally. When you call the add method, HashSet calls the hashCode method on the passed object to compute the hash code, which is then used to find the appropriate bucket location where the element is stored.
If two elements are the same (according to their equals method), they will have the same hash code, and thus the second object will not be added to the HashSet.
This is just a high-level overview, but I hope it gives you a good starting point for understanding the Set interface and HashSet class in Java. For a deeper understanding, I'd recommend looking into how the hashing mechanism works, and exploring the other classes that implement the Set interface, such as TreeSet and LinkedHashSet.
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.