Forem: Ibrahim Suleiman

Using React Higher-Order Components (HOC) in your React apps

Ibrahim Suleiman — Wed, 06 Apr 2022 11:24:19 +0000

You have probably used Higher-Order functions in your JavaScript apps at one point or the other and the power and functionality it gives to developers fascinate you. But do you know you can achieve similar satisfaction using React? This is where React’s Higher-Order component comes to play!

Prerequisites
Introduction to Higher-Order Components
Recap of Higher-Order functions
- .map()
- .forEach()
- .filter()
Deep dive into Higher-Order Components
Using a Higher-Order Component
Other Use Cases
Conclusion

Prerequisites

This is an advance concept in React. To follow along you will need the following:

Fundamental knowledge of JavaScript
Fundamental knowledge of React
NPM installed on your computer
The latest version of React installed on your computer, and
The grit to complete the tutorial :-)

Introduction to Higher-Order Components

The concept of a Higher-Order component (HOC) in React is an advanced technique that allows the reuse of a components’ logic by other components. It enables software developers to factor out common patterns or functionalities among various components or a group of components and creates a single component that you can then reuse in place of all the components having common structures or properties.

A typical React application comprises of various components and sometimes these components might have some similarities. Because of the hassle of having to copy and paste similar components next to each other just to change that little detail between them, the React team came up to use “Higher-Order components”.

HOCs allow software developers to write cleaner and more maintainable code by not repeating the same piece of code repeatedly. This abides by the principle of don’t-repeat-yourself (DRY) which is a core principle to follow in every software development.

HOCs in React are built upon the foundation Higher-Order functions. So before we go deep into the details of HOCs, let’s do a quick recap of Higher-Order functions.

Recap of Higher-Order Functions

A Higher-Order function in JavaScript is a function that takes in functions as parameters and/or returns a function as an output.

Below are some examples of the built-in Higher-Order functions built into JavaScript.

.map(): When called on an array, the method executes a callback function on each element of the array. The callback function takes in each array element one at a time, performs an operation with it, and then returns the result. It then stores the result in a new array which the method then returns.

Please note that this method does not modify the original array it is called upon, but it returns a new array whose elements might differ from the original array it was called upon.

The example below shows the .map() method in action.

const nums = [1, 2, 3, 4];
const squares = nums.map((num) => num * num)

console.log(nums) // [1, 2, 3, 4]
console.log(squares) // [1, 4, 9, 16]

The first log statement shows that the original array is not modified. The second log statement shows how the method returns a new array whose element is determined by the callback function.

Note: A callback function is a function that is passed into another function as an argument, usually Higher-Order functions. This callback function can then be executed inside the Higher-Order function it was passed in.

.forEach(): This method also takes in a callback function as an argument and passes each element of the array it was called upon into the callback function one at a time. The array element passed into the callback function is then used inside it to operate.

Unlike the .map() method, this method returns undefined. It does not modify the array elements it was called upon as well.

The example below shows the .forEach() method in action.

const even = [2, 4, 6, 8];
const array = even.forEach((num) => {
    console.log(num + 1);
})
console.log(array)

// Output
// 3
// 5
// 7
// 9
// undefined

The code example increments each number by 1 and logs the output. The last line (undefined) shows the return value of the .forEach() method.

.filter(): The method behaves similar to the two methods mentioned above, i.e. it takes a callback function that works on each element of the original array it was called upon. The only difference is that it returns an array that is a subset of the original array.

As the name applies, this method filters an array to return a new array. It does not modify the elements of the original array.
The elements that get added from the original array to this new array are dependent on whether the callback function returns true or false.

Below is an example of using the .filter() method:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const even = numbers.filter((num) => num % 2 === 0)

console.log(numbers) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
console.log(even) //[ 2, 4, 6, 8, 10 ]

The first log statement above shows that this method does not modify the original array, and the second array shows the returned array that was filtered (even numbers) from the original array.

The above methods are just a few examples and uses of Higher-Order functions. There are a bunch of Higher-Order functions in JavaScript that you can utilize in your code, and the best thing is that you can also create your own.

Now that we have had a quick recap of Higher-Order functions, it’s a good time to continue with the discussion on Higher-Order Components.

Deep dive into Higher-Order Components

In simple terms, a Higher-Order component is a function that takes in a component and returns a new component, which can then be stored as a component. The new component returned wraps over and does not modify the previous input component.

HOCs were inspired by Higher-Order functions, which is the main reason we had to go over a quick recap of what Higher-Order functions are.

Below is a pattern that most HOCs follow:

const higherOrderComponent = InputComponent => {
  class Wrapper extends React.Component {
    render() {
      return <InputComponent />
    }
  }
  return Wrapper
}

Below are a few things you need to know about HOCs

They are functions
This might sound conflicting, but let us look at it closely. When a HOC takes in a component, it returns a new component, which is then stored in a variable. This variable is then referred to as a component because it contains a component returned from the function.
They take in one or more components as an argument
In most cases, they also take in another parameter along with these components. This parameter is then used to determine the output of the new component. The parameter can either be a callback function, a data object, a variable, or whatever you chose.
They return a new component
This new component that is returned is the input component wrapped with more functionality or design.
They are pure functions
HOCs have no effects on the component they take in. They don’t change the behavior of the input components.

Using a Higher-Order Component

Having discussed a bit of the story about HOCs, it’s now time we get into the application. The examples below show where you can use HOCs in your everyday apps. From the examples, you will get to know more about HOCs and why you need to use them in your React applications.

For this example, we will create a simple prototype of a blog site that contains social media links, navigation links, and the actual blog content of the page. Each page should contain navigation links and the blog’s social media handles.

If you are new to React, ensure to go through the note below, else you can simply just jump through.

Note: We will use create-react-app to bootstrap our project. Before starting on the project, follow these steps below:

Navigate to your desired directory and run the command npx create-react-app my-app. This will create a my-app directory, which is your project directory containing all you need to spin up a react app in your browser.

Navigate to the src folder and delete all its content except index.js and App.js. We are building a very simple app and we won’t need the other files.

Let’s start by creating a sample blog page.
Once you are inside the src folder in the project directory, create a file named page1.js and add the following contents to the file:

const Page1 = () => {
  return (
    <div>
      <h1>Page 1</h1>
      <p>Page 1 contents here</p>
    </div>
  )
}

export default Page1

The code above creates a simple functional component that returns some content. This component is then exported so it can be imported into other components.

We will create three pages for this tutorial to simulate a website with one blog post per page. The second and third pages will contain similar contents to page1.js we just created. You can create both of them as page2.js and page3.js. Then add the contents of page1.js we just created above to the two pages you just created. The last step is to change every occurrence of “Page 1” to “Page 2” and “Page 3” in both files, respectively.

After creating the pages, the next step is to create a wrapper we will use to wrap each page. This is because we want each page of the blog to have a link to the blog’s social media accounts and the navigation bar.

Inside the src directory, create a file named Wrapper.js and the following contents into the newly created file:

const Wrapper = (Page) => {
  const PageWrapper = () => {
    return (
      <div style={{height: “100vh”}}>
        <div>
          Connect with us on
          <a href=“” > Facebook </a>
          <a href=“”>Instagram </a>
          <a href=“”>Twitter</a>
        </div>
        <hr />
        <p>Home</p>
        <p>About</p>
        <p>Contact</p>
        <hr />

       // Input component displays here
        <Page />
      </div>
    );
  };

  return PageWrapper;
};

export default Wrapper;

We created a functional component named Wrapper which takes in another component named Page. Inside of the Wrapper component is another component named PageWrapper that is used to wrap around the Page component. The PageWrapper contains other contents we would like to be displayed on every page on the blog, and then the <Page /> component, which contains contents specific to that page alone.

Note: We added a little styling to the wrapper component to make each page occupy the entire height of the screen. This is just to simulate the behavior of a typical blog page.

Towards the end of the file, the PageWrapper component is returned to the Wrapper component. The return statement implies that when we call the Wrapper component with an input component (Page in this case) we get the PageWrapper component in return.

The last line of the file is exporting the component so it can be used outside of the file.

Having created a wrapper that can wrap all the pages, the next step is to use the wrapper on each of the pages we created. We can achieve this by importing the wrapper into each of the pages like this:

import Wrapper from ‘./Wrapper’

And then replace the export statement at the bottom of each Page component with this line (please edit the Wrapper argument as appropriate i.e to match Page2 and Page3 components respectively):

export default Wrapper(Page1)

What we just did up there was taking the whole content of each page and wrapping it with the wrapper before exporting it. Recall that Wrapper takes in a component, so we must pass in this input component wherever Wrapper is called.

Now that we are done creating the files, the next step is to import these components into our App.js. Replace the content of your App.js file with the following code:

import React from “react”;
import WrappedPage1 from “./Page1”;
import WrappedPage2 from “./Page2”;
import WrappedPage3 from “./Page3”;

const App = () => {

  return (
    <div>
      <WrappedPage1 />
      <WrappedPage2 />
      <WrappedPage3 />
    </div>
  );
};

export default App;

The first set of import statements imports the contents of our blog pages with a suitable name that can refer to these imported pages.

The next block of code is a functional component named App which returns a div. Inside of this div is where we include the wrapped components we imported earlier. You might notice that we are using the tag < and /> to display these imported components. This is because the Wrapped component we created earlier returns another component. So for React to treat it as a component, we must include the tag.

At this point, if you navigate to the project directory inside your terminal and run the command

npm start

It will open a new window in your browser, which will look similar to the one below:

And if you scroll down to the next page, you will notice the navigation and the social media links are still present at the top of the page. This is the same for the third page as well.

So from the example above, you notice that because we are using Higher-Order components; we didn’t have to repeat similar patterns between pages. We simply create a component that has all these similarities and wraps all other components with it.

The steps we went through above might seem stressful just to achieve something as little as that. But imagine if you have over 3 pages, say 5, or 10, or even 50 pages, it will become hard and eventually become impossible to copy and paste the social media account and navigation links into all the pages.

Another benefit we derived from using HOC for the above example is that it made our code simple and easy to debug. If there is any change that needs to be done on any of the social media links, we can make the change only in the wrapper component and it will reflect everywhere.

Other Use Cases

The example we illustrated above is just one out of the many areas where you can apply HOCs in your React apps. Below are some other areas where they can be used:

Controlled display: You can use a HOC to control the components that will be displayed to the currently logged-in user based on their role. For instance, users who are not logged in will only be able to see the Login component. Logged in users will see the page content but cannot see all users of the app, nor those online. But the admin can see all of these.

This might seem like something that can be achieved using conditional rendering. But imagine an app where tens or even hundreds of components on a single page where the currently logged-in user can be multiple roles from a bunch of roles. Having such logic in the main app component is not the ideal design. In some situations, the main app component might also have some logic running within it, so combining that with the logic of conditional rendering will be cumbersome and hard to maintain.

Automatically pass properties into components: You might have a bunch of properties you want to pass into several components. This process might seem repetitive. You can easily achieve this using a HOC to wrapping each component. The HOC then passes these props into every component it takes in.
Display loading page: You might also want to display a loading page for the user while a data fetch from an external source is still loading. And then display the page contents when the data is done loading. Both the loading page and the content page will be wrapped inside a HOC, which will then return one component at a time.

This is a good design practice because it abstracts that little functional logic in our code from the main logic.

The above examples are a few of the use cases of HOCs. There are many more out there that are easy to detect. Compare them with the examples we have discussed here and you will not have a hard time deciding whether to use a HOC in your next React app or not.

Conclusion

The aim of this tutorial is to enlighten the readers on what HOCs are and how they can use them in their everyday React applications. In this tutorial, you just learned the basics of Higher-Order functions, what HOCs really are, and the application of HOCs.

The concept of Higher-Order components might be difficult for beginners to follow along. It is advisable go grasp the basic of JavaScript and Higher-Order functions before coming back to the tutorial.

With Higher-Order components, we are able to factor out common fragments in our code and reuse them across these components. We have also use HOCs to filter what components to display, as well as reducing the logic of conditional rendering on the main component. This made our code easy to debug and new developers can easily follow along. If you are interested in learning more about React HOCs, do well to checkout the React documentation where they dive deeper into using HOCs. I hope you start using HOCs in you apps as soon as you grasp the concept.

Happy coding!

Making Decisions in Python

Ibrahim Suleiman — Thu, 09 Dec 2021 12:44:01 +0000

As humans and an intelligent species, we always make decisions before taking some actions. These decisions can either be based on knowledge or choice. It is true that every human has the ability to make decisions, but what about the computer? Is it yet intelligent enough to make decisions for itself? We will find out from this article.

Making decisions in Python
- The if statement
- The if … else statement
- The if … elif … else statement
Conclusion

Prerequisite

Have the latest version of Python installed on your computer

Making Decisions In Python

Python allows us to write programs that are executed only if some conditions are true. This paradigm of programming are sometimes called control flows. They control the flow of execution from one part of the program to another. They decide which part of our programs should be executed and which part should not. This is the basis on which the computer makes decisions.

Python provides for us mainly three constructs for making decisions, which are:

The if statement
The if … else statement
The if … elif … else statement

The "if" Statement

The basic syntax for the if statement is:

if this is true:
do this

Two important things to note from this syntax are the colon : and the indentation. Unlike other languages like Java and JavaScript that use curly braces to wrap a block of code, Python uses indentation instead. You will see the indentation syntax more often when you start dealing with functions and methods in python.

For your code to run properly, the colon and the indentation must be properly written. The recommended way to indent in Python is to use 4 space indentation according to PEP8 style guide. If the statement to execute when an expression is true is not indented, it will still execute, but irrespective of whether the boolean expression is true or not.

command = 'Greet'

if command == 'Greet':
   print('Hello, World!')


## output
# Hello, World!

The program above checks for the value of command == Greet and prints ”Hello, World!” to the console if it evaluates to true. This condition is known as a Boolean expression. An expression that evaluates to either true or false. Also, note the == operator that was used for the boolean expression. This is called the comparison operator and it’s different from the assignment operator =.

Below are the comparison operators Python uses to evaluate a boolean expression:

Operator	Meaning
==	is equal to
!=	is not equal to
>	is strictly greater than
<	is strictly less than
>=	is greater than or equal to
<=	is less than or equal to

These operators return either True or False when used and they all accept two arguments, to the left, and to the right.

Let’s now modify the program above to see what will happen if the boolean expression is not true:

command = 'Greet'
# when the boolean expression is not true

if command == 'greet':
   print('Hello, World!')
print('Bye')


## output
# Bye

The code inside the if block was not executed because Greet is not equal to greet. They both have different Unicode values. The if statement is the basic way our programs can make decisions by themselves.

The "if … else" Statement

The syntax for the if … else statement is:

if <this is true>:
<do this>
else:
<then do this>

This syntax is similar to the if statement, but the code in the else block is executed only when the conditions in the if block evaluate to false. The else block is never executed when the if block evaluates to true.

greet = False
if greet:
   print('Hello, World!')
else:
   print('The system is unable to greet you')
print('Bye')


## output
# The system is unable to greet you
# Bye

The variable greet is used to hold a boolean value, which is what a boolean expression will return when executed. But greet is false, which means the if block won’t get executed, leaving the else block to get executed. And the last line of the code that prints ”Bye” gets executed no matter what.

Nested "if" statement

The nested if statements allow you to nest an if statement inside another if statement. This is useful when you want to make decisions if a particular decision is true or not.

i_am_human = True
height = 6
if i_am_human:
   if height >= 6:
       print('I am a tall human')
   else:
       print('I am an average height human')
else:
   print('I am not a human')


## output
# I am a tall human

The output of the program is based on the fact that i_am_human is true and height is 6 or above. If i_am_human was false, then the program won’t bother to check for the inner conditions, but rather jump to the else block and output ” I am not a human”.

The "if … elif … else" Statement

The if … elif … else statements solve the problem when there exists more than one condition to be tested. In a more complex program, if a condition fails to be true, the system doesn’t quit immediately. Some other conditions need to be tested before quitting.
The syntax for the if … elif … else statements is:

If <this is true>:
<do this>
elif <the above is not true>:
<do this>
else:
<do this if none of the above is true>

The elif is short for else if. You can have as many elif as desired in your programs. The last else is optional. You can choose to add it or leave it out of your programs. Let's see how this works:

age = 19
if age == 17:
   print('I am 17 years old')
elif age == 18:
   print('I am 18 years old')
elif age == 19:
   print('I am 19 years old')
else:
   print('Age not found')


## output
# I am 19 years old

Suppose you change the value of age to 18 as follows:

age = 18

Then the output is returned:

I am 18 years old

But what if the age is not among the ages to be compared. This is where the else block is executed. When the age from the example above is set to 21, then none of the conditions are satisfied. Only then, the else block is executed.

age = 21

The output will be:

Age not found

Conclusion

The advent of control structures in programming that allows programmers to write programs that makes decision is big turn around as programmers don't have to programs that only run in sequence anymore. Python took advantage of this structure and implemented it in using selection statements like "if", "if ... else", and "if ... elif ... else".
This article gives a brief overview of all you need to know about the basics of selection statements in Python and how to apply them if your everyday programs.
To know more about selection statements and Python as a whole, I recommend you check out the Python documentation tutorial.

Feel free to drop your thoughts and suggestions in the discussion box. I will be available to attend to them. And also, if you have any questions, you can as well drop them in the discussion box.

Data Types in Python

Ibrahim Suleiman — Sun, 05 Dec 2021 20:16:34 +0000

Have you ever stored some piece of information in the computer and wondered how the computer represents these information? Well, for you it might seems like a bunch of text or a bunch of numbers. But the computer sees this information differently. This is the reason why the computer can perform more rigorous and complex computations than all the human efforts combined. This is made possible through the concept of ”Data Types”.
Because the computer knows how to represent this data in the memory, that is why it can manipulate the data so well. A human will out of the box tell you that 1 + 1 = 2, but a computer can’t directly give you the answer without first checking how the expression is represented in the memory. This is where the concept of data types comes to play.

What is a data type
Basic Data types in Python
- Numeric Types
  - Integer
  - Float
  - Complex
- Boolean Values
- Sequence Types
  - Strings
  - List
  - Tuples
Conclusion

Prerequisite

Have the latest version of Python installed on your computer

What is a Data Type

A datatype is an attribute of a data which tells the computer how a data is to be used. The data type of a variable defines the meaning of a data, the operations that can be performed on that data, and how the data is stored in the memory.

Basic Data Types in Python

Python provides for us a rich set of built-in data types that can be used in programs without creating them from scratch. However, you can also write your own data type in Python to add some of the custom features not included in the ones provided by Python.
This article discuses some of the basic data types in Python.

Numeric Types

The three numeric data types python provides are integers, float, and complex.

Integer

An integer is a whole number, it can be positive or negative. In Python, there is no limit to how long an integer can be. It can be as long as you want it, except that it is constrained by the memory of your computer. Numbers like -1, 0, 3, 99999999999999999 are a perfect fit for integers.

Float

A float in Python is any number that has a decimal point. It designates a floating-point number. Floats can be positive or negative numbers. It also doesn't have a limit to how long it can be just like integers. Numbers like -0.1, 0.0, 1.5, 12345.678890000000. Note that floating-point numbers can contain only 1 decimal point. Using more than one decimal point for a floating number will throw a SyntaxError.

You could also append the letter e or E followed by an integer to represent a scientific notation.

Python represents floating-point numbers with 64-bit double-precision values in almost all platforms. This implies that the maximum value a floating-point number can be is approximately 1.8 ⨉ 10³⁰⁸. Any number greater than this will be indicated with the string inf implying Infinity.

Similarly, the minimum value a floating number can be is 5.0 ⨉ 10^-324. Any number smaller than this will be effectively zero.

Complex

A complex number is a number containing a real and imaginary part. A typical complex number looks like a+bj, where a is the real part and b is the imaginary part. You can create a complex number using the complex() function. This function takes in two arguments. The first is the real part and the second is the imaginary part.

You can alternatively create a complex number by just appending a j to the end of the imaginary part. This will set the real part to zero and the imaginary part to whatever value was specified.

Complex numbers also provide two attributes that you can use to get the real and imaginary parts of the complex number. If the variable a is a complex number, then you can access the real and imaginary parts of a using a.real and a.imag.

Boolean Values

Boolean values in Python are used to represent truth values. They consist of constants True and False. Boolean values can also behave like integers when used in numeric concepts, where True evaluates to 1 and False evaluates to 0.
Python provides for us the in-built function bool() which can be used to convert any value to a Boolean. The bool() function takes in an input and returns the boolean values True or False depending on the input. By default, the output is True. It is False if it falls under any of the following:

Every constant returns False, including None and False
The zero value of any numeric data type returns False. E.g 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
Empty sequence returns False. E.g '', (), [], {}, set(), range(0)

Boolean values are handy when using conditionals and loops such as if … else, while, for in your programs. The truth value of a boolean expression is what determines whether a particular section of code is executed on not as in loops and conditionals.

Sequence Types

In Python, a sequence is an ordered collection of data. This data can be similar or different data types. Some of the sequence types in Python include:

Strings
List
Tuples

Strings

A string is a sequence of letters, space, punctuation marks, or even numbers. It is an immutable sequence of code points. Python handles any form of textual data using the str object. Unlike integers, strings are represented differently in the computer’s memory that is why they cannot be used to perform arithmetic operations.

Strings are represented using either single, double, or triple quotes. Python does not have a type for a single character. A single character is a string with a length of 1.

Creating Strings

# Creating a string with a single quote
single = 'Hello, World!'
print(single)

# Creating a string with double-quote
double = "Hi, i'm Prince"
print(double)

# Creating a string with a triple quote
triple = """
            The conversation went as follows:
            Me: Hello
            Her: Hey
        """
print(triple)


## Output

# Hello, World!
# Hi, i'm Prince
#             The conversation went as follows:
#             Me: Hello
#             Her: Hey

Python represents strings in either single, double, or triple quotes. The starting quote of a string must be the same as the end quote. A string cannot start with a single quote and end with a double quote. This will throw a SyntaxError. But a single quote string can contain a double quote string inside, and a double quote string can contain a single quote string inside, like the double variable in the above snippet.

The triple quote string can span multiple lines. Making it possible to write multi-line strings.

Accessing the elements of a string

In Python, the elements of a string can be accessed using Indexing. Indexing allows us to use the index of a string to access it. The first index of a string is 0, the second is 1, and so on. The last index of a string is -1, the second to last is -2, and so on.

# Accessing elements of a string
message = "Hello, World!"
print(message[0]) # The first element of the string
print(message[-1]) # The last element of a string
print(message[13]) # IndexError


## output

# H
# !
# IndexError: string index out of range

When accessing string elements using indexing, ensure that the index is within the range of the string. If the index entered is out of range, Python will throw an IndexError.

List

A list is a mutable sequence of data that is used to store data. List in Python is similar to arrays in other languages, but they don’t have to be of the same type. A list can be created either by using a pair of square brackets containing iterables or using the type constructor list() that takes in an iterable.

An iterable is any sequence or container that can be iterated upon (loop through).

# List
# create an empty list
a = []
b = list()
print(a)
print(b)

# list with values of different types
mixed = [1, 2, 3, 4, True, False, 'a', 'b', 'c', 'd']
print(mixed)

# using the list() function
list_function = list(mixed) # create a copy of the `mixed` list
print(list_function)
iterable = list(range(10))
print(iterable)
tuple_inside_function = list((1, 2, 3))
print(tuple_inside_function)


## output

# []
# []
# [1, 2, 3, 4, True, False, 'a', 'b', 'c', 'd']
# [1, 2, 3, 4, True, False, 'a', 'b', 'c', 'd']
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [1, 2, 3]

A list can either be a single-dimensional or multidimensional list. A single-dimensional list contains a sequence of data. A multidimensional list contains iterable such as a list. A list containing lists is an example of a multidimensional list.

# List dimensions
# single dimensional
alphanumeric = ['a', 'b', 'c', 'z', 0, 1, 2, 9]
print(alphanumeric)
print(alphanumeric[5])

# multidimensional
alphanumeric = [['a', 'b', 'c', 'd'], [0, 1, 2, 9]]
print(alphanumeric)
print(alphanumeric[0][2])


## output

# ['a', 'b', 'c', 'z', 0, 1, 2, 9]
# 1
# [['a', 'b', 'c', 'd'], [0, 1, 2, 9]]
# c

The syntax for the multidimensional list is list[a][b], where a is the outer list and b is the inner list or iterable.

Tuples

Tuples in Python are immutable sequences of data that cannot be modified after they are created. Similar to lists, tuples can contain different data types and the elements are accessed using indexing.

Tuples are created using the built-in tuple function that takes in an iterable. They are also created with or without the use of parentheses containing the tuple element. A tuple can also contain a single element, but the element must have a trailing comma for it to be a tuple.

# Tuples
# empty tuple
empty = ()
print(empty)

# singleton tuple
single = 2,
print(single)

# tuple with strings
string_tuple = ('Hello',)
print(string_tuple)

# tuple from list
_list = [1, 2, 3]
list_tuple = tuple(_list)
print(list_tuple)

# nested tuple
tuple_a = ('a', 'b', 'c')
tuple_b = (1, 2, 3)
combined = (tuple_a, tuple_b)

print(combined)


## output
# ()
# (2,)
# ('Hello',)
# (1, 2, 3)
# (('a', 'b', 'c'), (1, 2, 3))

Conclusion

Python has a bunch of built-in types that you can checkout here. While these types are handy to use and provides basic functionalities, Python also allow you to write your own data structures that can be used as types and add more custom functionalities to it.
This article discussed the basic data types needed to get you started in your Python journey. To know more about Python built-in data types, checkout the official documentation.

Feel free to drop your thoughts and suggestions in the discussion box. I will be available to attend to them. And also, if you have any questions, you can as well drop them in the discussion box.

Variables in Python

Ibrahim Suleiman — Sat, 04 Dec 2021 17:13:14 +0000

A variable in programming is generally a container or location in the computer’s memory used to store values temporarily. Variables in Python are nothing different from the general programming definition of a variable. Values stored in the variable can then later be used or modified in our programs. This article discusses all the basics you need to know in Python programming language.

What are variables?
Variables in Python
- Variable Naming convention
- Variable declaration and usage
- Reassigning variables
- Operation on variables
- Variable scope: Local and global variables
Conclusion

What are Variables?

Variable are reserved locations in the memory of the computer used to hold values that can be used later.
Because the computer stores variables in the Random Access Memory (RAM), variables are created in the memory only when our program is in execution and are lost immediately after the program is terminated. What this means is that the value of a variable can only be accessed when a program is running. When the program has finished execution, these variables are not accessible anymore from anywhere in the computer. In order to use them again, you will have to run the program once again.

If you wish to store and retrieve variable values in your programs, consider using a file or database to store these variables. Variables stored in files and databases are stored in the secondary storage of the computer (e.g. Hard Disk Drive (HDD)) and remains for as long as you want them. They can also be retrieved from the computer’s memory even after shutting down and booting up the computer.

Variables in Python

In Python, variables are nothing different from the definition above. Python allows us to create variables and use them in our programs, as well as manipulate the values of these variables.

Variable Naming Convention

Below are some of the rules that variables you must abide by when naming variables in Python.

Do not use reserved keywords as a variable name. For example , keywords like class, int, def, while, else, try, e.t.c.
You cannot use special characters such as @, #, $, %, ^, & , e.t.c. when naming variables
Variable names are case sensitive. For example, age and Age are two different variables.
Variable names should start with an alphabet or an underscore(_) character.
A variable name can only contain the characters A-Z, a-z, 0-9 and underscore(_).
You cannot start the variable name with a number.

Variable Declaration and Usage

Variables in python can be declared and used in different ways. Here, we will be exploring some of the ways variables can be declared and used.
The snippet below declares and used the variable message

# prints the value of message to the console
message = "Hello, World!"
print(message) 


## output
# Hello, World!

The snippet above is the simplest way you can declare a variable in Python. But wait, what if I need to make my variable names more descriptive? Python has got your back. According to PEP 8 Style guide, variable names should be lowercase, with words separated by underscores as necessary to improve readability. In a situation where you might want to use long and descriptive variable names, you can simply separate it with an underscore like in the snippet below:

# long and descriptive variable names
secret_message = "Hey, here is my secret"
print(secret_message)


## output
# Hey, here is my secret

Python also allows you to declare variables in a more flexible and dynamic way. Unlike other statically typed programming languages like Java, Python is a dynamically typed language and you don’t need to care much about the type of a variable during declaration. You can declare multiple variables of different types on the same line. Let’s see how this looks:

# Declare multiple variables in a single line
# doing it the conventional way
name = "Prince"
age = 12
hobby = "Swimming"
print("Name:", name, " Age:", age, " Hobby: ", hobby)

# doing it the Python way
my_name, my_age, my_hobby = "Prince", 12, "Swimming"
print("Name:", my_name, " Age:", my_age, " Hobby: ", my_hobby)


## output
# Name: Prince  Age: 12  Hobby:  Swimming
# Name: Prince  Age: 12  Hobby:  Swimming

Reassigning Variables

Python allows you to reassign variables after they are declared, just like most programming languages allow you to. This process is known as “writing into a variable”. When you reassign a variable, the previous value is lost and the new value is then stored.

# Reassigning variables
my_age = 20
print(my_age)

# reassign the value of my_age
my_age = 21
print(my_age)


## output
# 20
# 21

The value of my_age was initially 20, but after printing it on the console and then reassigning it, the value changed to 21.

Operation on Variables

You can also perform some operations on the values of your variables. This is one of the great benefits variables give to us. In a situation where you want to perform operations on a very lengthy value many times in your programs. You don’t need to use that length value everywhere in your program. You can simply store the value with a shorter variable name and use it throughout your program. Let’s try this out:

# Operations on variables

PI = 3.142857143
radius = 44
perimeter = 2 * PI * radius
print(perimeter)


## output
# 276.571428584

You can perform any arithmetic operations on numbers in Python. From the snippet above, we can also operate on variables and literals (2 from the code example), provided they are all numbers (either integers or with decimal points). The value 3.142857143 from the code example is long and you might have a hard time holding it in your head. Storing it in PI makes it easily accessible and can be used throughout our programs.
Strings are also not left out here as well as you can perform operations on strings as shown in the code example below.

# String operations
msg1 = "Hello"
msg2 = "World"
full_msg = msg1 + msg2
print(full_msg)


## output
# HelloWorld

The most common operation on string is concatenation. This is simply appending one string to the end of the other using the (+) operator. You can only concatenate a string with another string. If you try to do otherwise, Python will throw a TypeError.
The (*) operator can also be used on strings. But instead of appending to the end of the string, it rather duplicates the string according to the integer value specified.

# String operations
fav_language = "Python"
output = fav_language * 5
print(output)


## output
# PythonPythonPythonPythonPython

Also note that the value specified must be an integer. Using otherwise will also throw a TypeError.

Variable Scope: Local and Global Variables

Variables declared in the programs we have written so far are available throughout the program. This means it can be accessed from anywhere in the program.
But things begin to get complicated when we start writing complex programs that involve functions which carry out a particular task. This is where the concept of variable scope come in.
The scope of a variable is the region of our program where the variable can be accessed. A variable can either have two scopes: Local and Global.
A local variable is a variable accessible within the function or method it is defined. This is useful when we want to isolate a variable from the remaining part of our program.

# Variable scope
# local variable 
def some_function():
    my_real_age = 19
    print(my_real_age) # my__real_age is locally available in some_function

some_function() # execute some_function
print(my_real_age) # my_real_age is not available outside some_function 


## output
# 19
# NameError: name 'my_real_age' is not defined

When some_function() is executed, it prints out the value of my_real_age to the console because my_real_age is defined inside the function. But again, when we tried to print my_real_age outside some_function, a NameError was thrown because my_real_age is only available inside some_function and not throughout the program. This is because my_real_age is a local variable.
A global variable is a variable accessible throughout our program. It remains the same throughout our program and also throughout the module. Use the global variable when you want to use the variable throughout the methods and functions of your program. Let us use the same example from above, but this time making my_real_age a global variable:

# Variable scope
# global variable
def some_function():
    global my_real_age
    my_real_age = 19 # globally available throughout this program
    print(my_real_age) 

some_function()
print(my_real_age) # my_real_age is now available outside the some_function 


## output
# 19
# 19

The program above runs successfully without any errors because my_real_age is now declared as a global variable.
Declaring variables either local or global is useful in cases where you wouldn't want variables to clash in your Python packages and modules. Other programming languages like Java use class variables, instance variables, and local variables for this concept. But it is more simplified with just local and global variables as presented by Python.

Conclusion

Having a good knowledge of variables in any programming language is as important as learning the language itself. This article discusses an overview of variables in Python. It starts with a general view of a variable and then narrows down to the Python view of a variable.
And then discussed the naming convention of variables, declaration and usage, how to reassign variables, the numerous operations you can perform on variables, and finally the scope of a variable.

Check out the official Python documentation to know more about variables.

Feel free to drop your thoughts and suggestions in the discussion box. I will be available to attend to them. And also, if you have any questions, you can as well drop them in the discussion box.

Python Hello World

Ibrahim Suleiman — Fri, 03 Dec 2021 20:34:05 +0000

Hello, World! seems to be the first line to code any programmer would run to test if the coding environment is properly set up. This culture has been a norm for both new and existing developers. As a new developer, or new to a language, you would definitely want your first program to be the famous “Hello, World!” program.

One reason why this culture is still practiced in the developer’s ecosystem is because the famous “Hello, World!” program is one of the easiest and bug-free programs you would write in any programming language.

In this article, we would maintain the same culture and write our first “Hello, World!” using the Python programming language. But wait, what the heck is Python? That snake? Well, we’ll find out soon enough.

Brief history of Python
Introduction
Your First Hello World in Python
Breaking down the Hello World program
Ways you can write your first Hello World
Adding comments to the Hello World program
Advantages of documenting our programs
Conclusion

Prerequisites

Have the latest version of Python installed on your computer

Brief History of Python

In the late ’80s, a Dutch programmer was looking for a hobby project to work on during the Christmas break. So he decided to write an interpreter for the new scripting language he had in mind for some while. He chose “Python” as the title of the project (Being a big fan of “Monty Python Flying Circus”. The old BBC television comedy sketch series). His name is Guido van Rossum. He created the Python programming language

Introduction

Python is a general-purpose, high-level, and object-oriented programming language. It is a widely-used and interpreted language, which makes it more human-readable.

Python is a good choice for beginners because you can use it to write complex programs in an easy and efficient way. Unlike programming languages like Java that provide support for object-oriented paradigm, Python has support for many programming paradigms. Some of the paradigms include functional, object-oriented, and procedural (structured) programming.

Your First “Hello, World!” in Python

print("Hello, World!")

Yay! You just wrote your first “Hello, World!” in Python. While this looks extremely easy and straightforward, it is not the case with other programming languages like C# and Java. Any beginner would be able to relate to the program above because it looks like writing plain English to the computer. This is one of the advantages Python provides over other object-oriented languages.

Breaking Down The “Hello, World!” Program

The “Hello, World!” above seems easy and straightforward, but I bet you will still need an explanation for the syntax and how things are the way they are.

The program above instructs the python interpreter to print the string “Hello, World!” to the console. The print() function is a built-in function (it comes installed with Python) that takes in a couple of arguments and prints it out to the console. The print() function is one of the many built-in functions that come installed with python, and it is made available during execution.

In Python, functions are invoked using parentheses immediately after the function name. If the function takes in arguments, then these arguments are passed into the parenthesis -- just like our print() function above.

The print function does not only take in strings such as “Hello, World!” above. It can take in as an argument any Python data type which can be numbers or boolean values and prints it to the console. It can also take in variables and print them to the console as well.

Note that the “Hello, World!” is enclosed in double-quotes. Python is flexible enough to let you print the same “Hello, World!” in a single quote.

print('Hello, World!')

This flexibility is also what makes it popular among beginners, as you don’t need to bother about which to use when writing simple programs. Unlike Java that uses a single quote for a character and a double quote for strings, any of both can be used in Python for simple programs like the “Hello, World!” above (except for some special cases).

Ways You Can Write Your First “Hello, World!”

In the developer’s ecosystem, there are usually many ways of writing programs and solving problems as there are many ways that lead to the river. We will be exploring some of those ways in this section of the article.

Using the Python Shell

Go to your terminal and type the command

python

If python is properly installed on your machine, it will open the Python shell as shown below.

Then go ahead and write your “Hello, World!” program on the prompt as shown below.

Using the Python IDLE

Locate the Windows icon on your taskbar (If you are using a Windows OS), select “All apps”, and then search for the Python as shown below. If you have different versions of Python installed, they will all pop up here. Select one of them as shown below.

Click on the “IDLE” app from the dropdown and a new window will pop up on the screen as shown below.

Then run your “Hello, World!” code and see the output.

The Python IDLE allows you to run python codes on the Python shell. It behaves similar to the method above. The main difference is that you don’t have to type in the python command before activating it. And also, the IDLE looks more aesthetically pleasing.

Writing Python codes in a file

One of the limitations of using the methods mentioned above is that it is not flexible to write multiple lines of python codes on either the Python shell or the Python IDLE.
Python provides us a way around this by creating a file directly from the IDLE and writing your code in it.

Locate and click on “File” from the tabs above. Then select “New file” which will open up a new window to write your Python codes. Alternatively, you can enter “Ctrl + N” on the keyboard which is a shortcut for opening a new window for your Python code.

Write your “Hello, World!” code in the editor provided and save it with a suitable name, and in a suitable location where you can easily find it.

Locate and click on the “Run” button from the tabs above and select “Run Module” when the dropdown comes. Alternatively, you can use the shortcut key - F5 to run the program directly.

The above methods are the most fundamental ways you can write and run your Python programs without having to install any code editors. All of the tools used above came bundled with Python, so you don't have to download them anymore. When you get more comfortable with the methods above, then try and use other third-party code editors like PyCharm, VSCode, Atom, Sublime, e.t.c.

Adding Comments To The “Hello, World!” Program

Python allows us to add comments to our program which is a way of reminding us of what the program does, in case we will ever go through it in the future. Let us add a comment to our “Hello, World!” program describing what it does.

Python allows us to use the pound/number (#) sign in order to write comments in our code. When we use the pound sign in front of a statement, the Python compiler completely ignores anything after the pound sign, and then continues on the next line. There are several types of comments in Python but we will be considering the simplest one for our “Hello, World!” program.

Advantages Of Documenting Our Programs

Writing comments in your program is a means of documenting the program. This is one of the best practices every programmer is advised to stick to. Some advantages of writing comments includes:

Clarity: When you need to make reference to your code writing some time ago and you can’t remember what the program actually does. The comments that are written along with the program can give you a hint of what each function or statement does. This is particularly useful in complex and large programs containing a bunch of functions and packages. With the help of the comments, it will be easy to map out what the program does.
Reusability: The fact that you can still understand and remember what your code does after a long time doesn't mean everybody can. In a case where you are deploying a package to be used by other developers, they might get stuck at some point and attempt to check the codebase. Without proper comment or description of what each code does, it will be hard for the programmers to identify where the problem is thereby discouraging them from using the package any further.
OSS: Open Source Software (OSS) is software that anybody can modify because it is “Open” and publicly accessible to everyone. Python is an example of an OSS that anyone can contribute to. OSS is mostly developed by programmers all over the world. Because of this diversity, confusion might come up because the codebase is written by different sets of people in different locations and at different points in time. These people might not (or never get to) know each other. This problem is solved by proper documentation of a project. Adding comments to programs is a way of documenting a program for future reference. This is the reason why many robust open-source software like Python is still in existence today.

Conclusion

Knowing the history and basics of a programming language is a very important as leaning the language itself.
This article gives us a high level overview of the basics of the Python programming language, its creator, history, and how the name came about. It then moved on to breakdown the famous "Hello, World!" using Python. Lastly, it branches through the writing comments and its importance the programming.
While this article covers some of the basics of Python, check out the official Python documentation to know more about Python.

Feel free to drop your thought and suggestions in the discussion box. I will be available to attend to them. And also, if you have any questions, you can as well drop them in the discussion box.

OOP Series: Abstraction and Interface In Java

Ibrahim Suleiman — Tue, 09 Nov 2021 07:19:01 +0000

INTRODUCTION

Abstraction is one of the four basic principles of Object-Oriented Programming (OOP). It enables us to give structure to our programs and applications. Abstract classes are used to create structure or design in which all other subclasses must follow.
Consider a smartphone, for example, smartphones have a screen that the user can touch to interact with the phone. Other properties of the smartphone are camera, speaker, battery, earphones, buttons, etc., and a smartphone can do some things like play music, make a call, receive a call, take pictures/ videos, etc. Considering some models of phones like Android, iOS, Blackberry, etc. An android phone, for instance, must at least be able to make a call, receive a call and browse the internet before we can consider it a smartphone.
For us to consider Android, iOS, and Blackberry in the class of phones, they must also be able to perform the basic functionalities listed above. Then can we conclude that we have abstracted Android and iOS from the Phone.

CONTENT

Prerequisite
Abstraction
Abstract class and Concrete class
Abstraction vs Encapsulation
Code Example
Interface
Properties of Interface
Code example
Conclusion

PREREQUISITE

Basic understanding of OOP - Methods, Classes and Objects
Some OOP principles - Inheritance, Encapsulation

ABSTRACTION

Abstraction in Java is the process of creating abstract classes and methods which define the structure of subclasses. We can achieve abstraction in Java by adding the keyword abstract to a class declaration name and providing abstract methods to the class.
It is also achieved using interfaces and abstract classes.

An abstract method is an instance method that is declared with the keyword abstract and does not have a body i.e. it is delimited by a semicolon.

public abstract void testMethod();

Below are some of the properties of an abstract class:

You must declare it with the keyword abstract. Classes declared without the abstract keyword but containing at least one abstract method will throw a compilation error.
It cannot be instantiated. We cannot create objects of the class using the new keyword.
All subclasses inheriting from the abstract class must provide an implementation for the superclass abstract methods.
It can be sub-classed. Abstract classes can also act as a subclass and inherit the properties of a superclass.
It can contain zero or more abstract methods.
It can contain concrete methods. Concrete methods are methods with a body and implementation, unlike abstract methods that are delimited by a semicolon and do not provide an implementation.
All other members of the abstract class like instance variables and concrete methods continue to abide by the rules of inheritance. Subclasses handle them as they will for other concrete classes.

Abstract class and Concrete class

An abstract class is any class declared with the keyword abstract and contains some abstract methods. Some of the properties of the abstract class are listed above. A concrete class is somewhat opposite to an abstract class. A concrete class is a class that is not declared with the keyword abstract and does not contain any abstract method. While an abstract class cannot be instantiated, a concrete class can be instantiated.
Meanwhile, a concrete subclass inheriting from an abstract superclass must implement all of the superclass abstract methods otherwise the subclass must also be declared as an abstract class.

Abstraction Vs Encapsulation

You can achieve encapsulation without abstraction but cannot achieve abstraction without encapsulation.

Abstraction and encapsulation are two of the most misused concepts of OOP. Abstraction focuses on the design of the object in focus, while encapsulation focuses on the implementation.
The key to understanding the difference between the two is

Abstract all the things you need

and

Encapsulate all the things you don’t need.

Consider a car, for example, some of the basic necessities of a car are the steering wheel, accelerator pedal, brake pedal, gear selector, etc. Since a car needs all these things to be classified as a car, we can conclude that these things are being abstracted from the car. This is because a car can't do without them.
But the functionalities of these parts of the car are not made visible to the driver and the driver does not need to know how the steering wheel rotates the tire, or how the accelerator and brake pedal controls the speed of the car. This is known as encapsulation. The implementation and the details of these parts are hidden from the driver so the driver only interacts with the few parts made available by the car like the parts listed above. In this case, we are hiding the complexities from the driver, which is encapsulation.

Code Example

The three programs below explain the concept of abstraction in Java using three classes. The Phone abstract class and two other concrete classes - the Android class and IOS class.

The Phone Class

The image depicts the Phone class hierarchy. The Phone class is blurred in the image to signify it is an abstract class.

package Abstraction;

public abstract class Phone {

    private String color;
    private String brand;

    // initialize instance variables
    public Phone(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    // set and get methods

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    // abstract methods

    public abstract void makeCall();

    public abstract void receiveCall();

    public abstract void browseInternet();

    // overrides Object's method
    @Override
    public String toString() {
        return String.format("%s specs", getBrand());
    }
}

The Phone class starts by adding an abstract class declaration in its signature with the keyword abstract. This is the default syntax for declaring a class as abstract in Java.
The class moves on to declare its instance variables and then to the constructor used to initialize these variables, followed by setters and getters methods used to access and modify these instance variables.
The next set of methods includes the abstract methods makeCall(), receiveCall(), and browseInternet() that demonstrates the must have of a smartphone. This is similar to the smartphones we use in real life, most smartphones perform these three basic functionalities. Every other type of phone inheriting the properties of our Phone class must be able to make a call, receive a call, and browse the internet. The implementation of these methods might vary, but functionality must be the same.
One thing to note here is that the Phone class contains concrete methods with implementations along with its abstract methods.
The next two classes will be inheriting these properties of the Phone class.

The Android Class

package Abstraction;

public class Android extends Phone {

    private String version; // android version

    public Android(String color, String brand, String version) {
        super(color, brand); // initialize superclass variables
        this.version = version; // initialize instance variable
    }

    // set and get methods

    public void setVersion(String version) {
        this.version = version;
    }

    public String getVersion() {
        return version;
    }

    // abstract methods implementation

    @Override
    public void makeCall() {
        System.out.println("Calling with Android ...");
        System.out.println("Call ended.");
    }

    @Override
    public void receiveCall() {
        System.out.println("Calling with Android ...");
        System.out.println("Call ended.");
    }

    @Override
    public void browseInternet() {
        System.out.println("Browsing with iPhone ...");
        System.out.println("Session ended.");
    }

    @Override
    public String toString() {
        return String.format("%s%nVersion: %s%nColor: %s%n",
                super.toString(), getVersion(), super.getColor());
    }
}

The Android class like any other regular subclass class inherits from a superclass which is the Phone class using the keyword extends (similar to inheritance) in its class declaration. It includes an instance variable and a constructor to initialize the variable, then the setter and getter method to manipulate the variable.
Our focus here are the methods makeCall(), receiveCall(), and browseInternet(). They override the superclass methods using the @Override annotation. Here, the Android class must override these abstract methods and provide implementation (a body) in order to be called a concrete method. This is because the Phone class it is inheriting from contains these abstract methods.
This is very useful in designing smartphones in real life where each smartphone has a basic requirement they must meet. Because of these design constraints, users won't be overwhelmed by the variations of smartphone design each brand is producing.

The IOS Class

package Abstraction;

public class IOS extends Phone {

    private int camera; // number of camera

    public IOS(String color, String brand, int camera) {
        super(color, brand); // initialize superclass variables
        this.camera = camera; // initialize instance variable
    }

    // set and get methods

    public void setCamera(int camera) {
        this.camera = camera;
    }

    // get the number of camera
    public int getCamera() {
        return camera;
    }

    // abstract methods implementation

    @Override
    public void makeCall() {
        System.out.println("Calling with iPhone ...");
        System.out.println("Call ended.");
    }

    @Override
    public void receiveCall() {
        System.out.println("Receiving call with iPhone ...");
        System.out.println("Call ended.");
    }

    @Override
    public void browseInternet() {
        System.out.println("Browsing with iPhone ...");
        System.out.println("Session ended.");
    }

    // override Object's method

    @Override
    public String toString() {
        return String.format("%s%nColor: %s%nNumber of Camera: %d%n",
                super.toString(), super.getColor(), getCamera());
    }
}

The IOS class above is similar in structure to the Android class. It contains an instance variable, a constructor to initialize the instance variable, and a setter and getter method to manipulate the instance variable.
The main difference between the Android class and the IOS class is the implementation of the inherited abstract methods. In this case, both have similar methods and prints different message which in real life it might be some block of code with actual functionalities. But for the sake of this article, we are keeping things simple by printing some text to the console. Now, if a user is to transition from an IOS to an Android device, they won't be much difference in the functionalities of the two devices. Because from the onset, both share the same design. This is another good advantage of abstraction in the real world.

The PhoneTest Class

package Abstraction;

public class PhoneTest {

    public static void main(String[] args) {

        // create objects
        Android android = new Android("Android", "Diamond Black", "8.9.9");
        IOS ios = new IOS("iOS", "Pale Blue", 5);

        // display objects
        System.out.println(android);
        System.out.println(ios);

        // perform action with objects
        android.makeCall();
        System.out.println("--------------------------------------"); // white space
        ios.receiveCall();
    }

}

We use the PhoneTest Class above to test the implementation of the three classes created above - Phone, Android, and IOS class.
It starts by creating objects of both the Android and IOS classes and initializing their instance variables by passing the values into their constructor call.
The next set of statements display the string representation of the respective objects created above. Note that we printed the objects without any helper methods but rather with the help of the toString() method overridden inside each class. It helps to display objects of that class in a custom way.
The next statements perform some actions with the objects by making a call with the android object and then receiving a call with the ios object, and the implementation of each method is printed in the console.

Below is the output of executing the PhoneTest class.

INTERFACE

Interface specifies what to do and not how to do it.

An interface in Java is a type that contains static constants and abstract methods and defines the behavior of classes. Interface is an extreme case of abstraction and is used to achieve 100% abstraction. This implies that interfaces cannot contain concrete methods and all the abstract methods it contains must be implemented by the concrete subclass.
Interface comes into play when classes that are not related need to share a common design. This happens when we need objects of different classes to respond to the same method call.
Interface in Java acts as an interface between different classes sharing a common design. Consider the TV remote control, for example, most remote control contains at least one button, so if a particular model/brand of remote control is to implement the remote interface, it must contain at least one button because the default design of a remote includes at least one button.

Properties of Interface

Similar to abstract classes, interfaces cannot be instantiated. An object of an interface cannot be created using the new keyword.
All fields in an interface are implicitly public, static, and final.
Interface cannot have concrete methods.
Interface cannot extend other classes.
All methods in an interface are implicitly public and abstract methods.
A class must implement all of the methods of an interface, otherwise it must be declared abstract.
Interface can extend (but cannot implement) other interfaces.
A class can implement multiple interfaces. This is done using a comma-separated list of interfaces after the keyword implements in the class declaration.

public class className extends superClassName implements interface1, interface2, interface3, ...

Code Example

The code snippets below explain the concept of interfaces in Java.

The Camera Class

package Abstraction;

public interface Camera {

    public void takePicture();

    public void flashlight();       

}

The program above contains an interface Camera that has only two methods. As seen from the program, the class declaration includes the keyword interface they are no concrete methods here because interface in Java does not accept it. The methods that this interface has included some of the basic functionalities of a camera. So any class that wants to implement a Camera interface must be able to take a picture and includes a flashlight (at least).

Modification to the Android Class

The two snippets below modify the Android class to implement the Camera interface.

public class Android extends Phone implements Camera {

The snippet above implements the Camera interface using the Android class by adding the keyword implements followed by the name of the interface to implement, in this case; Camera is the interface to implement. This is the default syntax for implementing an interface in Java. In real life, for an Android phone to have a camera interface, it must be able to take pictures along with a flashlight, this is exactly what our Camera class is doing here - enforcing the Camera design on Android.

// overridden interface methods

    @Override 
    public void takePicture() {
        System.out.println("Taking picture ...");
        System.out.println("Picture taken");
    }

    @Override
    public void flashlight() {
        System.out.println("Flashlight is turned on ...");
        System.out.println("Flashlight is now off");
    }

The snippet above shows another modification done to the Android class. All other parts of the program remain the same except for these two methods added to the class because of the interface the class is implementing.
The two methods above provide implementation to the takePicture() and flashlight() methods in the Camera interface. As seen from the properties of an interface, all of the methods must be implemented in the Android class else the compiler will throw an error.

        android.flashlight();

The above line of code was added to the phone test class to demonstrate one of the methods the Android class is implementing.

Below is an output of running the PhoneTest class with the modifications done to the android class.

The output above remains similar to the first output except for the last two lines that display the output of implementing the flashlight() method.

Conclusion

This article starts by introducing the concept of abstraction in Java and its properties as well. The knowledge of Abstraction is a very valuable concept in OOP and programming as a whole because of its numerous advantages and applications in the real world.

Interface, on the other hand, is an extreme case of abstraction. Most software engineers encourage the use of interface as it helps to preserve design and also helps in modeling software.
This article briefly introduces the concept of abstraction and interface in Java. Visit the official Java documentation to know more about the concepts discussed here.

OOP Series: Encapsulation In Java

Ibrahim Suleiman — Fri, 15 Oct 2021 23:18:35 +0000

Introduction

Encapsulation is one of the four core principles of Object-Oriented Programming (OOP). It is also known as information hiding. Encapsulation refers to the packaging or bundling of data along with the methods that manipulate this data, thereby restricting direct external access to the data. These data are usually in form of variables with private access declared inside of a class, and a setters and getters method that can be used to update and retrieve the values of the variables.

An example of encapsulation can be seen from a medicine capsule. Here, the capsule protects its contents from direct external access. Before taking a capsule, we mostly don't open it to look at its content, but rather take the whole of it irrespective of the fact that we don't know what's inside and then expect it to start its functionalities. In this case, it is safe to say that the capsule has encapsulated its content from us. This is the same thing classes do; they protect their variables from external or clients access. In this case, the clients cannot manipulate this information because they don’t have direct access to them, and they cannot as well see the internal workings or implementations of objects created from that class.

Background Knowledge
Advantages of using Encapsulation
The Account class
The AccountTest class
Conclusion

Expectations

By the end of this article, you will:

Have a high-level knowledge of what encapsulation is.
Know some of the advantages of using encapsulation.
Write simple Java applications that apply the concept of encapsulation.

Background Knowledge

This article gives a high-level overview of one of the core principles of OOP. You are expected to have basic knowledge of OOP including:

Objects
Classes and methods
Inheritance

Please check out Inheritance in Java for an article on inheritance.

Advantages of Using Encapsulation

Data hiding: The use of private access modifiers in fields declaration protects that field in the class from an external source. Therefore, they can be used to store important information without the fear of information leakage.
Control: The use of setters and getters methods to access private fields in a class gives more control over that variable. Suppose the setBalance method in an Account class processes only positive values and set negative values to zero, and a user wants to set an account balance to a negative value, because of the validation done in this method, zero will be stored in the balance instead of the negative value.
Reduces Exceptions: Suppose a user enters their age in a name field, the program is supposed to throw an exception because a String value is expected but it found an int value. With encapsulation, this can be avoided by validating the input using a simple if-else statement of regular expression and handling the exception if one happens instead of terminating the program due to exceptions.

The Account Class

The account class depicts a bank account containing information related to the account. This class is used to demonstrate how encapsulation works and its benefits as well.

package Encapsulation;

public class Account {

    private String firstName, lastName;
    private double balance;   

    // set and get methods

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setBalance(int balance) {
        // handles invalid balance
        if (balance >= 0.0)
            this.balance = balance;
        else 
            this.balance = 0.0;
    }

    public double getBalance() {
        return balance;
    }

    @Override
    public String toString() {
        return String.format("%s%n%s: %s%n%s: %s%n%s: %.2f%n", 
                "Account Info", "First Name", getFirstName(),
                "Last Name", getLastName(), "Balance", getBalance());
    }

}

The account class above declared all of its instance fields private thereby restricting access of these fields to the class alone.

    private String firstName, lastName;
    private double balance;

In this case, even objects of the class can’t access these private fields because they are encapsulated. They can only be accessed through the public get and set methods declared inside of the class. In a more robust system, the set methods usually have complex validations that external values must pass through before setting them but for the sake of this article and simplicity, we will be using an if-else statement to validate the balance entered by the user.
The setBalance method first checks if the balance is a positive number (as there are no negative balance in most cases), similar to the deposit method. But the deposit method adds the deposit amount to the previous balance only if it is valid (deposit amount is mostly a positive value).

public void setBalance(int balance) {
        // handles invalid balance
        if (balance >= 0.0)
            this.balance = balance;
        else 
            this.balance = 0.0;
    }

In a situation where the accountant mistakenly enters a negative amount for deposit, normally the program would have subtracted it from the previous balance left but because of encapsulation, this is not the case because an implementation that handles this kind of subtle error has been added to the program.
Another implementation in the Account class is the toString method that displays the string representation of an object of that class.

  @Override
    public String toString() {
        return String.format("%s%n%s: %s%n%s: %s%n%s: %,.2f%n", 
                "Account Info", "First Name", getFirstName(),
                "Last Name", getLastName(), "Balance", getBalance());
    }

This method overrides the default built-in toString method inherited from the Object class and adds implementation to it. The advantages of this will be seen later in this article.

The AccountTest Class

AccountTest class contains an object of the Account class and it is used to test the functionalities of the Account class.

package Encapsulation;

public class AccountTest {    
    public static void main(String[] args) {
        Account clerk = new Account();
        clerk.setFirstName("Clark");
        clerk.setLastName("Tom");
        clerk.setBalance(-200);

        // Before depositing
        System.out.println(clerk);

        // After depositing invalid amount
        clerk.deposit(-400);
        System.out.printf("AFter depositing invalid amount %nBalance: %,.2f%n",
                clerk.getBalance());

        // After depositing valid amount
        clerk.deposit(1500);
        System.out.printf("AFter depositing valid amount %nBalance: %,.2f%n",
                clerk.getBalance());
    }
}

The main method of the AccountTest class starts by creating an object of the Account class and then using the set methods to initialize the values of the object.
The image below shows all of the properties of the Account class. As it is seen from the image below; the first name, last name, and account balance are not visible to the user because they are declared private. They can only be accessed through the get methods declared public.

After setting the name, the object tries to set a negative amount as the account balance

clerk.setBalance(-200);

but recall that the Account class automatically sets the negative amount received to 0.0 in the account balance. Encapsulation is seen at work here because we have successfully added some implementation to the setBalance method which is not visible to the users.
Also, the clerk object is displayed on the console using its object variable alone.

System.out.println(clerk);

Notice we didn’t call any method to help us properly display the object but it's variable alone, this is because the implementation for that is already handled as well in the overridden toString method in the Account class. The user doesn’t have to go through the stress of trying to format the output because it has been handled already.
The next statement tries to deposit a negative amount to the user’s account and prints the new balance.

clerk.deposit(-400);

Same as the balance method, negative values are not allowed to be deposited and therefore the program skips adding this invalid deposit amount to the previous balance.
The next statement deposits a valid amount to the user’s account balance. In this case, the amount is added to the balance because it has been validated and passed the validation, and the new balance is then displayed.

clerk.deposit(1500);

The image below shows the output running the AccountTest class stored in AccountTest.java. It consists of the initial state of the account when the user tries to set an invalid balance, then when the user tries to deposit an invalid amount. And then to when the user enters the valid amount.

Conclusion

This article starts by introducing the concept of encapsulation using the medicine capsule as an example, another example that can be used here is the car instance. A car has at least a brake and accelerator, the driver uses these two to control the speed of the car but has no idea how the car does it. Their functionalities are hidden from the driver because most of the time the driver doesn't need to know how these things work before using the car. This is another good example of encapsulation.
We listed a few advantages of encapsulation, there are many other advantages out there but we chose only a few important ones for the sake of this article.
We then proceed to use the account class to explain the concept properly using some code examples.
Encapsulation is a broad concept in programming and the implementation slightly varies across different programming languages that support it. This article demonstrated a basic implementation of encapsulation using Java.

OOP Series: Inheritance in Java

Ibrahim Suleiman — Sun, 26 Sep 2021 16:47:29 +0000

INTRODUCTION

Object-oriented Programming (OOP) is a programming paradigm based on the concepts of Objects and Classes. It allows the group or collection of related objects in a class and creates functionalities for use by the class with the help of methods.
Object-oriented programming has four pillars or principles known as:

Inheritance
Polymorphism
Data Abstraction
Encapsulation

These four principles define an Object-oriented language. In this article, we will be looking at Inheritance.

CONTENT

Prerequisite knowledge
Inheritance
Direct and Indirect superclass
Composition vs. Inheritance
The Student class
Conclusion

PREREQUISITE KNOWLEDGE

This article explains the concept of inheritance using the Java programming language. Thus, you need the following knowledge of Java:

Basic understanding of OOP.
Methods.
Classes and objects. If you are new to Java or have a rusty knowledge of it, you can do well to check out Hello World Breakdown in Java where we walk through the building blocks of a simple Java program.

INHERITANCE

Inheritance is one of the four pillars of the Object-Oriented Programming paradigm. Inheritance is a concept that allows us to create new classes from an existing class by acquiring or inheriting the properties of that class. And also, adding more functionality to the new class. Take the family hierarchy, for example, the children exhibit some characteristics of either the mother or the father. Some of these characteristics might include:

skin color
height
size
...

Here, we can say that the child inherits those characteristics from the parent. Since those characteristics are present in the parent. Sometimes, the child might inherit not only the characteristics of the parent but the grandparents as well. In other cases, the child might inherit the characteristics of both the parent and grandparent and still display their characteristics, which make the child unique. This is the basic concept of inheritance in OOP. Inheritance allows us to derive a new class from an existing class. The existing class from which we can derive the new classes is called the superclass in Java. It is also known as the base class or parent class in some other languages like C++. While the new class that is derived is called the subclass in Java. It is also known as derived or child class in some other object-oriented languages as well.

Some advantages inheritance provides are:

Reusability: It allows the reuse of code written by us or other programmers. Hence, avoiding reinventing the wheel.
Flexibility: When we need to update some group of classes, inheritance allows us to update the superclass only. Instead of making the update on all the affected classes.
Redundancy: Inheritance allows us to write less code and build upon the previous ones. Thereby reducing redundancy and encouraging cleaner code.
Data hiding: The use of private instance variables, and setters and getters methods to access them. This allows restricted access to the variables of a class.

Direct and Indirect Superclass

We can categorize superclasses into two types, direct superclass, and indirect superclass. The direct superclass is the immediate class from which a new class inherits in the class hierarchy. It is the class immediately above the new class in the inheritance hierarchy tree. The indirect superclass is any class in the inheritance hierarchy above the direct superclass. The new class does not directly inherit any attribute from an indirect superclass but gets these attributes from the direct superclass.
All classes in Java directly or indirectly inherit from the Object class, which can be found in java.lang.Object. The Object class provides some functionalities such as equals() (which checks whether two objects are equal), getClass() (which returns the runtime class of a particular object), toString() (which returns a string comprising the name of the class of which the object is an instance and the unsigned hexadecimal representation of the hash code of the object), notify(), notifyAll() and many others which the Object’s subclasses can utilize.

Composition vs. Inheritance

Java only provides support for single inheritance. Unlike other programming languages like C++ that support both single and multiple inheritance. In single inheritance, we can derive a class from only one direct superclass, while in multiple inheritance, we can derive a class from more than one superclass.
The relationship that can exist between two classes can either be is-a relationship or has-a relationship. Is-a relationship implies inheritance, while has-a relationship implies composition.
In inheritance, we can treat an object of a subclass as an object of the superclass. For instance, if a Rectangle class extends the Shape class, then the Rectangle is-a Shape and thus, we can treat it as a Shape. In composition, a class can to have references to objects of other classes as its member. For example, each student has a course of study, so it is necessary to include a reference of the Course class as a member of the Student class. In this case, we can say that each Student has-a a Course.

The Student Class

In this article, we will consider the Student class to explain the concept of inheritance. Below is an image that shows some classes that can we can derive from the Student class and their hierarchical relationship.

Here, we can consider the Student class to be the base class of all classes. Undergraduate and Graduate inherit directly from the Student class. FirstYear and SecondYear inherit directly from the Undergraduate class. In this case, FirstYear and SecondYear have an indirect inheritance to the Student class and a direct inheritance to the Undergraduate class. Since FirstYear and SecondYear inherit directly from the Undergraduate but not directly from the Student class.

package Inheritance;

// Student.java
public class Student {

    private String firstName;
    private String lastName;
    private String studentId;

    public Student(String firstName, String lastName, String studentId) {
        // validate first name
        if (!(firstName.matches("[A-Z][a-zA-Z]+"))) 
            throw new IllegalArgumentException("Invalid first name.");

        // validate last name
        if (!(lastName.matches("[a-zA-Z]+(['-][a-zA-Z]+)*")))
            throw new IllegalArgumentException("Invalid last name");

        // validate student id
        if (studentId.length() == 0)
            throw new IllegalArgumentException("Invalid ID");

        this.firstName = firstName;
        this.lastName = lastName;
        this.studentId = studentId;
    }

    // set and get methods

    public void setFirstName(String firstName) {
        if (!(firstName.matches("[A-Z][a-zA-Z]+"))) 
            throw new IllegalArgumentException("Invalid first name.");

        this.firstName = firstName;        
    }

    public String getFirstName() {
        return firstName;
    }

    public void setLastName(String lastName) {
        if (!(lastName.matches("[a-zA-Z]+(['-][a-zA-Z]+)*")))
            throw new IllegalArgumentException("Invalid last name");

        this.lastName = lastName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setStudentID(String studentId) {
        if (studentId.length() == 0)
            throw new IllegalArgumentException("Invalid ID");

        this.studentId = studentId;
    }

    public String getStudentId() {
        return studentId;
    }

    @Override
    public String toString() {
        return String.format("%s: %s%n%s: %s%n%s: %s%n", 
                "Student ID", getStudentId(), "First Name", getFirstName(),
                "Last Name", getLastName());
    }
}

Student.java first starts by declaring and initializing its instance private instance fields. Recall that any field or member declared as private is only accessible to the class alone, so therefore the instance fields declared in the Student class can’t be accessed outside the class.
This is where the set and get methods come to help. In this case, the set methods first validate the values entered before making them available to the class for use and throw an error with a meaningful message to the user. It means that any class extending the Student class needs not to validate its first name, last name, and student id anymore because the Student class has already handled that. This is one of the advantages of inheritance provides. It prevents programmers from reinventing the wheel. This speeds up production and also reduces the complexity of a program since some implementations are done in the superclass.
The toString() method at the end also shows that the Student class is overriding one of its superclass methods using the @override annotation. Recall that every class in Java by default and directly or indirectly extends the Object superclass, so we don’t have to explicitly extend the Object class at the Student class declaration. This also shows that subclasses can modify or increase the capabilities of the superclass members by simply overriding them in the subclass.

The next program containing the Undergraduate class inherits the properties of the Student class.

package Inheritance;

// Undergraduate.java
public class Undergraduate extends Student{

    private int year;

    public Undergraduate(String firstName, String lastName, String studentId, int year) {
        super(firstName, lastName, studentId);

        this.year = year;
    }

    // set and get methods
    public void setYear(int year) {
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return String.format("%sYear: %s%n%s%n", super.toString(), getYear(), "Undergraduate Student");
    }
}

Undegraduate.java first starts at the class declaration by extending/inheriting from the Student class using the extends keyword. extends is a keyword in Java we use to implement inheritance and it can only extend one class since Java only supports single inheritance.
The program continued by declaring an instance field and then declaring the constructor with parameters. Then next to the initializing the superclass variable using the super keyword. A set of parentheses comprising the superclass constructor arguments immediately followed this. super is also a keyword in Java and subclasses use it to initialize the variables of the superclass constructor. Java requires that the first task of any subclass constructor is to call the constructor of its direct superclass.
We don’t need to validate firstName, lastName, and studentId anymore because the superclass has handled that already. And we can access them using the super. followed by their get methods. Similar to the Student class, the Undergraduate class also has its own toString() method which uses super.toString() String representation of the superclass. We can access members of the superclass using the super. followed by the member to access. For example,

super.toString();

The next program containing the Graduate class also inherits from the student class

package Inheritance;

// Graduate.java
public class Graduate extends Student{

    private String program;

    public Graduate(String firstName, String lastName, String studentId, String program) {
        super(firstName, lastName, studentId);

        this.program = program;
    }

    // set and get methods

    public void setProgram(String program) {
        this.program = program;
    }

    public String getProgram() {
        return program;
    }

    @Override
    public String toString() {
        return String.format("%sProgram: %s%n%s%n", 
                super.toString(), getProgram(), "Graduate Student");
    }
}

Similar to the Undergraduate class, the Graduate class also extends the Student class. And contains an instance variable and a constructor that takes in values to initialize the superclass variables. The implementation of the Graduate class is similar to the Undergraduate class. The main purpose of the Graduate class is to show how multiple subclasses can inherit from a single superclass—Student class.
The next program contains the StudentTest class that implements both the Undergraduate and Graduate classes.

package Inheritance;

// StudentTest.java
public class StudentTest {

    public static void main(String[] args) {

        // Declare and initialize objects
        Undergraduate undergraduate = new Undergraduate("Bush", "White", "1021", 3);
        Graduate graduate = new Graduate("Alexa", "Brown", "1102", "Masters");

        // print string representation of objects
        System.out.println(undergraduate);
        System.out.println(graduate);
    }
}

Class StudentTest creates objects of both the Undergraduate and Graduate classes. And then passes the constructor values as well. It then proceeds to print the values of the objects created. Notice that we did not explicitly use the toString() method to print the String representation of the objects. This is because we have already customized them from the Undergraduate and Graduate classes respectively.
Below is the output of executing StudentTest.java

The output first displays the details of the undergraduate student. Followed by the graduate student. Notice that among the undergraduate and graduate student details is an extra detail specifying the type of student. Which was not included in the constructor when created.
These details and the format of the output were all included in the toString() method of the respective subclasses.

Conclusion

Inheritance is a broad topic in Java and other object-oriented programming languages as well. This article implemented the concept of inheritance using the Student class. With Graduate and Undergraduate classes as subclasses. We learned about the concept of superclass and subclass and their usage in inheritance. And then used some keywords such as extends, super as well as using the @override annotation to add functionalities to the default toString method of every class. We then moved to use the setters and getters methods to access the private field of a superclass as well as validate the values before setting them.
In the next article, we will build upon the concept of inheritance by introducing Polymorphism. The ability of objects to exist in many forms. Which is also a core principle of object-oriented programming.

Access modifiers in Java

Ibrahim Suleiman — Sat, 14 Aug 2021 22:47:30 +0000

Introduction

Imagine downloading a software package into your project for integration then you decide to use it inside your program, on checking for the classes inside that package, boom! Before you are 1200 class and what you need is just 5 to 10 maximum, then you'll have to start searching for the few relevant ones. How frustrating? This is exactly what Object Oriented Programming languages like Java are here for. One of the motivations for access modifiers is a principle in computer science and information security known as The Principle of Least Privilege.

The principle of least privilege states that the code should be granted only the amount of privilege and access it needs to complete its designated task.

Access modifiers in Java are keywords used to determine the accessibility of classes, methods, and other members. Access modifiers implement one of the core Object-Oriented Programming concepts known as Encapsulation or Data hiding. The idea behind the concept was to give clients and users authorized access to controlled information. This will limit the chances of data compromise or data hijacking.

The access modifiers in Java are four with only three having keywords. They are

Public access modifier

Private access modifier

Protected access modifier

Default access modifier

Public

public static String firstName;

As the name suggests, public makes available the members (instance fields and methods) of a class to all other classes in the package and objects of that class as well, and even subclasses. The public access modifier is mostly used when we want to make an instance field or methods available to all the objects of the class, or available from other classes in the same package, or outside it (when imported).

One of the major trade-offs in declaring a member public is that subclasses can easily modify the variable thereby making the class fragile. And because that member is public, other classes or objects can have unauthorized access to the member thereby making it prone to malicious attack.

Tip: If a class must have public data, then make it final to avoid modification.

Private

private double salesAmount;

Contrary to public, private gives a variable or field restricted access to the fields or methods themselves. Declaring a field or method private signifies that that method or field is available to only the members of that particular class. This means that other classes in the same package or objects of the class, or even subclasses don’t have access to these methods.
The main reason for this is to prevent instance variable unauthorized access or modification. This is to fulfill one of OOPs important concepts known as Encapsulation or Data Hiding.
A solution to private instance variables is to make corresponding public get and set methods and control their access to these instance fields and validate data to be stored in the field as well. This is one of the major uses of the get and set methods.

Tip: It is advisable to always use private fields in your class and use get and set methods to access them because this is a good software engineering practice.

Protected

protected final static int age;

Protected bridges the gap between public and private members of a class.
It provides an intermediate level of protection between public and private access.
It allows a member to be accessed by the members of that class, by members of its subclass, and also members of other classes in the same package (protected has package access).
The main difference between protected and public members is that public members can be accessed from anywhere in the package or even other packages (when imported) but protected is not available to members of other packages outside its current package.

One of the drawbacks of using the protected access modifier is that members of the subclass can modify the variables easily without using the set methods, in which attackers can take advantage of this to alter the variables leading to inconsistent behavior in the class.
If the implementation of the class was to change next time, this means all other subclass inheriting from this class will have to be modified to fit this change, for instance, modifying an instance variable from lastName to surname, this means all other subclass using firstName will have to be modified to surname, which is not a good practice.
Another drawback is that the protected members are visible to all other classes in the same package which might not be desirable for some problems.

Usage: Just like public and private, protected is used in similar ways.

Default

static String dateOfBirth;

When a class's fields or methods are declared without an access modifier, then the default access modifier is assumed in this case. Java takes that field or method to be a default access modifier, therefore, making access to that field or method limited.
With the default access modifier, other members of the class and classes in the same package can have access to it. But classes from other packages don't have access to it.

Summary
Below is an image from Wikimedia summarizing the difference between the access modifiers in Java.
Conclusion
The use of access modifiers in an object-oriented language like Java is highly encouraged to prevent information leakage mostly in industry-standard software that is reusable. Sticking to this principle will go a long way in preventing malicious attacks on most of our software today.
Sticking to this principle will go a long way in preventing malicious attacks on most of our software today.

Hello World Breakdown In Java

Ibrahim Suleiman — Tue, 10 Aug 2021 22:16:55 +0000

Hello World 👋.
Today, we will be going through the famous Hello World! program in Java. Yes, the famous Hello World! program. It's more like a culture in the developer's circle to first write the Hello World program as their first line of code in a new language. Enjoy

Introduction

Java is a high-level, interpreted, and object-oriented programming language developed by James Gosling at Sun Microsystem (now acquired by Oracle) and released in the year 1995. It's a general programming language and platform-independent (It allows developers to write once and run anywhere - WORA). This implies that compiled Java code can run on any platform and operating system that supports Java without recompilation.
Java was designed to look similar in syntax with languages like C or C++ so that application programmers would find it familiar.

Definition of terms

Keyword: A keyword in Java is any word that is reserved for use by Java. Java has 52 of these words and this implies that these words can't be used as names for variables, methods, classes, or any other identifier. It is otherwise known as reserved keyword. It is always spelled in lowercase.
Access modifier: An access modifier is a keyword that determines the accessibility of a class, variable, method, and other members in a class to other subclasses or objects. It can either be public, private, protected, or default. Check here for more on access modifiers.
Variable: A variable is a location in the computer's memory that is used to store value for later use. Java is a statically typed language (variable types are explicitly declared and therefore determined as compile-time) so therefore variable types are declared before the variable.
Identifier: A series of characters made up of letters, digits, underscores (_), and a dollar sign ($). It does not contain spaces and does not begin with any digit.
Class: A class is a blueprint of an object. A class allows us to define the state, properties, and behaviors of our methods.
Method: A method in Java is a block of code delimited by curly brackets ({)that performs a particular function in our class.
Subclass: A subclass is a class that is derived from another class. The class it is derived from is called the super class or base class. All classes in Java are by default subclasses because they inherit from the Object superclass.
Object: An instance of a class. Classes can have multiple instances and these instances have their separate copy of the attributes of the class.
Data types: Data type in Java is a constraint that determines the value that a variable can take. It tells the Java compiler how to use the data.
Instance variable/method: An instance variable creates a separate copy of itself when used inside an object. Modifying an instance variable does not affect the class it was created from. The same also applies to methods.

Code

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world");
    }
}

Breakdown

Line 1

// HelloWorld.java - This signifies a single line of comment in Java. It is used to make our code easier to understand by other programmers and for future references. Java has 3 types of comments namely:

Single line comment: As we've seen above. They are mostly used to describe code functionality.
Double line comment: /* comment here */. It is used to comment on multiple lines of code.
Documentation/Javadoc comment: /** comment here */. Used when writing code for projects or software packages. Check here for more info about Javadoc comment.
Line 2

public class HelloWorld {

Now let's consider this step by step. Firstly,
public - a keyword in Java and hence can't be used as an identifier. It signifies that the class HelloWorld is public and therefore global in our program and project as a whole.
class - also a keyword in java that informs the Java compiler that a class is about to be created. A Java source file may only contain one public class but can contain multiple classes with non-public access modifiers.
HelloWorld - is an identifier that is used to name the class that is being created. Java has naming conventions for identifiers like variables, classes, methods, etc. The naming convention for a class in Java is the Pascal case - The first letter of every word is capitalized. Identifiers in Java also have their rules guiding them, one of which a class name must be in Pascal's case.
{ - open curly bracket, signifies the beginning of our class. Unlike other languages like Python, Java uses open curly brackets to mark the start of our classes or methods. This signifies the boundaries of our class or method and can also be referred to as the body of the class or method.

Line 3

public static void main(String[] args) {

public - also implies that the method has public access - other classes can use this method.
static - signifies that the method is only visible to this class and other classes that this particular class is offering services to e.g. subclasses. This means that objects of this class cannot access this method because it is declared static.

Note that the keyword static is omitted, then the method can be classified as an instance method.

void - is a return type in Java and it indicates that this method will perform a function and won't return any information. Other return types might be String, short, byte int, long, double, char. These are also data types in Java. Any method having a return type other than void must end with the keyword return followed by a value that is of the same type as the return type

public static int age() {
    int age = 19;
    return age;
}

main - is the name of the method and it is also an identifier. This is the starting point of every Java application. When we run any Java application, this is the first place it begins its execution, no matter its location in the program. The naming convention of a method is the Camel case - The first letter of every other word must be capitalized except the first word, which is in lower case. Java requires that every program must have the main method within which the program starts its execution.
(String[] args) - is called the parameter list in Java. The parameter list is used to receive data into our methods that can only be used within the method's body. Java demands that the main method's parameter list takes in an array of String objects and an identifier args which is the default name by convention, is used to store the data received. Methods that take in parameters in Java are called Parametric methods.

Example: the public static void main(String[] args) method takes in an array of Strings and stores it in variable args.

while methods that don't take parameters are called Non-parametric methods.

Example: public static String getName() - here, the parameter list is empty.

{ - The opening curly bracket here similar to the one in our class definition also performs the same function. It delimits the method and can also be called the method's body. Any statement, variables, or expressions within the opening curly bracket and the closing bracket belong to the method. They can't be used outside the method's scope.

The method's scope is defined by the opening and closing curly brackets.

Line 4

System.out.println("Hello world");

System.out - an object in Java already known as the standard output object that is already imported by default into all Java programs by java.lang package. It is used to display information on the command window from our Java programs.
println("Hello world"); - a System.out method that prints string literals within but not including the double quotation marks to the command window. Some other methods are printf(), print().

Most statements in Java ends with a semicolon to signify the end of that statement.

Line 5 and Line 6

}
}

`
are both closing curly brackets that close our method and class respectively. They signify the end and scope of the method, and the class as well.

Conclusion

Please note that the above is just a minimal breakdown of the popular Hello World! program and it is more complex and deeper than explained above. Some of the details are not included because they need some prerequisite knowledge before they can be understood. Please refer to the official Java documentation for more details.

Forem: Ibrahim Suleiman

Using React Higher-Order Components (HOC) in your React apps

Table of Contents

Prerequisites

Introduction to Higher-Order Components

Recap of Higher-Order Functions

Deep dive into Higher-Order Components

Using a Higher-Order Component

Other Use Cases

Conclusion

Making Decisions in Python

Table of Contents

Prerequisite

Making Decisions In Python

The "if" Statement

The "if … else" Statement

Nested "if" statement

The "if … elif … else" Statement

Conclusion

Data Types in Python

Table of Contents

Prerequisite

What is a Data Type

Basic Data Types in Python

Numeric Types

Integer

Float

Complex

Boolean Values

Sequence Types

Strings

List

Tuples

Conclusion

Variables in Python

Table of Contents

What are Variables?

Variables in Python

Variable Naming Convention

Variable Declaration and Usage

Reassigning Variables

Operation on Variables

Variable Scope: Local and Global Variables

Conclusion

Python Hello World

Table of Contents

Prerequisites

Brief History of Python

Introduction

Your First “Hello, World!” in Python

Breaking Down The “Hello, World!” Program

Ways You Can Write Your First “Hello, World!”

Adding Comments To The “Hello, World!” Program

Advantages Of Documenting Our Programs

Conclusion

OOP Series: Abstraction and Interface In Java

INTRODUCTION

CONTENT

PREREQUISITE

ABSTRACTION

Abstract class and Concrete class

Abstraction Vs Encapsulation

Code Example

The Phone Class

The Android Class

The IOS Class

The PhoneTest Class

INTERFACE

Properties of Interface

Code Example

The Camera Class

Modification to the Android Class

Conclusion

OOP Series: Encapsulation In Java

Introduction

Contents

Expectations

Background Knowledge

Advantages of Using Encapsulation

The Account Class