DEV Community: Shahed Abdulwahab

Java abstract classes and interfaces

Shahed Abdulwahab — Sat, 25 Dec 2021 10:18:06 +0000

It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced.

Abraham Lincoln.

Abstract class: Class that has some methods without complete definition and has the modifier abstract.

You can not create an object using an abstract class constructor.
You can use an abstract class as a base class to define a derived class.
The abstract class has at least one abstract method.
Abstract method: has heading just like an ordinary method, but without body, and it requires the modifier abstract and a semicolon.
An abstract method can not be private.
An abstract class can be a type. Ex:

public abstract class Example{
  private String data1;
  private double data2;

public abstract double getPay();
}

Interface: specifies a set of methods that any class implements that interface must have.

An interface is a type.
It contains method headings without definition, and no instance variables:

public interface Interface1{
public void method1();
public int method2();
}

To implement an interface, the class must do two things:
1. Include implements InterfaceName.
2. The class must implements all the method headings listed in the interface.

public class Implementer implements Interface1 {

    @Override
    public void method1() {
    //definition   
    }

    @Override
    public int method2() {
    //definition   
    }

}

The method headings declared to be public
An abstract class can implement an interface as well, this class gives definitions for some of the method headings in the interface.
Java interfaces can holds constants as well, ex:

public interface Constant {

    public static final int JANUARY = 1, FEBRUARY = 2, MARCH = 3;
}

Any class that implements the Constant interface will automatically have these constants, ex:

public class Constants implements Constant {

    public static void main(String[] args) {
        System.out.println(JANUARY);
    }

}

You can mix the uses of interfaces by including both constants and method headings in a single interface.
Multiple inheritance is not supported in Java, so that a class can extends only one base class. however, using interfaces, a class can implements several interfaces:

public class Implementer implements Interface1, Interface2, .. InterfaceN{

}

The reason that a Java class can extends only one base class is if Java allowed two base classes, the two classes may have the same method heading with different definition and that will cause inconsistency.
Rare phenomena, two interface can be inconsistent by defining two constants with the same name and different values:

public interface Interface1{
public static final int ANSWEAR = 0;
}

public interface Interface1{
public static final int ANSWEAR = 3;
}

File I/O in Java

Shahed Abdulwahab — Tue, 13 Jul 2021 18:33:42 +0000

Content:

a. Reading/Writing to a text file

b. The `file` class

What are Streams?
Stream is an object that allows flow of data between your program and I/O devices or some files.

Two kinds of streams:

inputStream: if the flow is into the program from (keyboard or file), and the operation is called "Reading from".
outputStream: if the flow is out of the program to (screen or file), and the operation is called "Writing to".

Two kinds of files to deal with:

Text files: Files contain sequence of characters when viewed in text editors or read by a program, ex: files contain java program.
- They also called ASCII files.
- Can be read by human.
- Can move from one computer to other.
- Can read or write to them using text editors.
Binary files: Files contain sequence of binary digits.
- Can be read only by programs.
- In java, binary files can move from one type of computer to another.
- Must read or write to them using only by a program.

A. Reading From A text file:

Lord Polonius: What do you read, my lord?

Hamlet: Words, words, words.

The two main stream classes for reading from a text file:

Scanner
BufferedReader

a. Using Scanner
Ex:

//Opening an inputStream and convert the file name to FileInputStream object
Scanner inputStream = new Scanner(new FileInputStream("marks.txt"));

        int counter = 0;
        while (inputStream.hasNextInt()) { //Returns true if there is next int in the file
            int number = inputStream.nextInt();  //Scans the next token of the input as an int.
            System.out.println(number);
        }
        inputStream.close();

Output:

1
2
3

The class Scanner does not care if the stream comes from the the keyboard or from a file.
The Scanner class has no constructor takes a file name as it's argument (We need to convert the file name to object).
A richer class to read the files.

b. Using BufferedReader
Ex:

//The program opens the text file
BufferedReader inputStream = new BufferedReader(new FileReader("quots.txt")); //FileReader to convert the file name to object
        String i= inputStream.readLine();
        while (i!=null){
             System.out.println(i);
        i= inputStream.readLine();

        }

Output:

123 hello
1 23d I am on console!

The BufferedReader class has no constructor takes a file name as it's argument (We need to convert the file name to object).
There are only two methods to read from the text file: readLine and read.
The read method reads a single character, and returns an int that corresponds to the character you read.(You need to cast that int to get the character), ex:

char next = (char)inputStram.read();

To signal the end of the file, the readLine method returns null and read method returns -1.
Unlike class Scanner, the class BufferedReader has no
constructor to deal with numbers. You have to read the numbers as a string then convert the string to a numeric type, ex:
Integer.parseInt(); Double.pareDouble();
If there are multiple numbers in a single line:

a. Read the line using readLine()
b. Use StringTokenizer to decompose the string into tokens.

B. Writing to a text file:
The class PrintWriter is the preferred class to write to a text file.
Ex:

        //Opening the file
     PrintWriter outputStream = new PrintWriter(new FileOutputStream("shahed.txt")); //use FileOutputStream to convert the file name to object

        //writing to the file 
        outputStream.print("this line written from a java program");
        //close the connection
        outputStream.close();

Output:

this line written from a java program

The program start with empty file and if the file shahed.txt already exist, the old content will be lost.
To test if the file is already exist, we can use the File class.
The PrintWriter class has no constructor takes a file name as it's argument (We need to convert the file name to object).
When the program finish writing, it should close the the stream connected to that file.
To flush the content of the buffer (temporary location for the data to be written) use the method flush()
The method close() include an invocation of flush().
To append new text to old text, then you have to open the file with the following manner:

PrintWriter outputStreamToAppend = new PrintWriter(new FileOutputStream("shahed.txt", true));

In this way the old content will remain and the new content will place after the old content.

PrintWriter class throw FileNotFoundException and it indicates that file can't be created.

The File class

The File class constructor takes a string name (Abstract name) and checks the properties if that name, ex exists methods checks if name is exists, and isDirectory() tests if the name the name of a directory. ex:

File file = new File ("Fruits.txt");
if (!file.canRead()){
System.out.println("The file can not be read!")
}

Some methods in File class:
- setReadOnly()
- canWrite()
- delete()
- getName()
- getPath()
- length()

Generics in java

Shahed Abdulwahab — Tue, 15 Jun 2021 19:33:19 +0000

You can have this dish prepared with any type of meat or fish.

-Entry on a restaurant menu.

Classes and methods can have Type parameter T, and the type parameter may then have any reference type or class type plugged in for the type parameter.

The class with type parameter is called Generic class or Parameterized class, example:

public class Sample<T> {
    private T data;  //T is a parameter for a type

    public Sample(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

}

A generic constructor name has no type parameter with angular brackets with it's name, But it can use the type parameter T with it's parameters.
You can not plug in a primitive type for a type parameter, for example: if we want instantiate the generic class Sample with integer type, we would say:

Sample<Integer> sample = new Sample<>(55);

A type parameter cannot be used everywhere a type name can be used. you can not use the type parameter T with new operator to create an object. example:

T object = new T (); //the first T is legal while the  second is illegal

A generic class definition can have any number of type parameter, example:

public class Sample2<T1, T2> {

    private T1 data1;
    private T2 data2;
     .
     .
}

A generic class can not be a an exception class, for example the following exception class will generate a compiler error:

public class Sample<T> extends Exception{} //illegal

-To use compareTo method in your generic class, you need to ensure that the class implements comparable interface and begin with the following definition:

public class Sample <T extends Comparable>

and the part extends Comparable is called bound on the type parameter T, and a bound may be a class name, for example the following says that only descendent classes of Employee may be plugged in for T:

public class Sample <T extends Employee>

Generic Methods

the generic method can be member of a generic class or nongeneric class. ex:

public static <T> T getMidPoint(T[] a){
return a[a.length/2];
}

Collections in java

Shahed Abdulwahab — Sun, 28 Mar 2021 18:48:33 +0000

Collections:

Put all your eggs in one basket and watch that basket.

-Mark Twain

Collection: is a data structure for holding elements.
Collection<T>: is the highest level of the java's framework for collection.

-Two main interfaces that extend Collection<T> interface:
1.Set<T> interface:

Does not allow duplication
Does not impose an order on the elements

2.List<T> interface: (Allow duplication)

Allow duplication
Impose an order on the elements

-Two Abstract classes used (for convenience) to implement Set<T> and List<T> interface:
1.AbstractSet<T>
2.AbstractList<T>

-Another Abstract class implements Collection<T> interface which is AbstractCollection<T>, and it is a skeleton class for the Collection<T> interface

-If you want a class that implement The Set<t> interface, use the class HashSet<T>
HashSet<T>: is the concrete class implements the Set interface.
It can be used as a base class if you want to implement the Set interface.
-It is implemented using a hash table.

-If you want a concrete class that implement The List<t> interface, use
either the class ArrayList<T> or Vector<T>
They can be used as a base class if you want to implement the Set interface using your own class.

DEV Community: Shahed Abdulwahab

Java abstract classes and interfaces

It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced.

Abraham Lincoln.

File I/O in Java

Content:

a. Reading/Writing to a text file

b. The file class

Lord Polonius: What do you read, my lord?

Hamlet: Words, words, words.

Generics in java

You can have this dish prepared with any type of meat or fish.

-Entry on a restaurant menu.

Collections in java

Collections:

Put all your eggs in one basket and watch that basket.

-Mark Twain

b. The `file` class