Advance Topics

Advanced Programming

SUT • Spring 2019

Contents

  • Enumerations

  • Static Import

  • Annotation

Enumerations

Enumerations

  • Suppose you have a class with a few instances

  • Example:

    • Student Type : <BS, MS, PhD>

    • SMS Status : <Sent, Delivered, Not Delivered, Not Sent>

    • Color : <Blue, Green, Black, Red>

  • How do you implement it?

    • The class should not be inherited

    • The instances are limited: no further instances

Example

final class Color{
    public static final Color Black = new Color(1);
    public static final Color Blue = new Color(2);
    public static final Color Green = new Color(3);
    public static final Color Red = new Color(4);

    private int color;
    private Color(int i) {
    	this.color = i;
    }
}

Java enum

  • Java introduces enumerations for this purpose

  • Enumerated Data Type

  • A simple class

  • enum keyword instead of class or interface

  • Comma seperated enum instances

  • enum instances are constant

  • enum Color {

  •         Black, Blue, Green, Red

  • }

Enum

enum Color {
    Black, Blue, Green, Red
}

final class Color{
  public static final Color Black = new Color();
  public static final Color Blue = new Color();
  public static final Color Green = new Color();
  public static final Color Red = new Color();
}

Enum Sample

enum Shape {
    Rectangle, Circle, Square
}

enum StudentType{
    BS, MS, PhD
}

Using Enums

Color color = Color.Black;
Shape shape = Shape.Circle;
show(shape, color);
...

private static void show (Shape shape, Color color) {
    //show a shape with this color
    ...
}

Enum Characteristics

  • enum types are implicitly final

    • Can not be a super-class

    • Because they declare constants that should not be modified

  • Instances are constants

    • enum constants are implicitly public, static and final

  • No new instances can be created

    • object  instantiation of enum types with operator new results in a compilation error.

Enum

  • Enum can be a more complex class

  • With many constructors

  • And fields

  • And methods

Example

enum Shape {
    Rectangle(1), Circle(2), Square(3);

    private int number;
    
    Shape(int i){
        number = i;
    }
    
    public int getNumber(){
        return number;
    }
}

Example

Shape shape = Shape.Circle;
print (shape.getNumber());

shape = Shape.valueOf("Rectangle");
print(shape.getNumber());

Shape[] shapesArray = Shape.values();
for (Shape s : shapesArray) {
    print(s.name());
}

try{
    shape = Shape.valueOf("Pyramid");
}catch(Exception exp){
    print("Pyramid is not included in Shape");
}

Static Import

  • In order to access static members

  • Qualify references with the class they came from.

  • For example:

    • double r = Math.sin(Math.PI * theta);

  • static import allows unqualified access to static members

  • without inheriting from the type containing the static members

    • import static java.lang.Math.PI;

  • or

    • import static java.lang.Math.*;

    • double r = sin(PI * theta);

Annotation

  • An annotation is a special form of metadata

  • Added to Java source code

  • Classes, methods, variables, parameters and packages may be annotated

  • Unlike Javadoc tags, Java annotations can be reflective

  • They can be embedded in class files (byte code)

  • May be retained by the Java VM at run-time

  • Example

    • @Override,   @Deprecated,   @ SuppressWarnings, …

Functional Programming

What is Functional Programming?

  • A style of programming that treats computation as the evaluation of mathematical functions

  • Eliminates side effects

  • Treats data as being immutable

  • Functions can take functions as arguments and return functions as results

  • Prefers recursion over explicit for-loops

Why do Functional Programming?

  • Allows us to write easier-to-understand, more declarative, more concise programs than imperative programming

  • Allows us to focus on the problem rather than the code

  • Facilitates parallelism

Java 8

  • Java 8 is the biggest change to Java since the inception of the language

  • Lambdas are the most important new addition

  • Java is playing catch-up: most major programming languages already have support for lambda expressions

  • A big challenge was to introduce lambdas without requiring recompilation of existing binaries

Benefits of Lambdas in Java 8

  • Enabling functional programming

  • Writing leaner more compact code

  • Facilitating parallel programming

  • Developing more generic, flexible and reusable APIs

  • Being able to pass behaviors as well as data to functions

Java 8 Lambdas

  • Syntax of Java 8 lambda expressions

  • Functional interfaces

  • Method references

  • Default methods

Example 1:

List<Integer> intSeq = Arrays.asList(1,2,3);

intSeq.forEach(x -> System.out.println(x));

Example 2:

List<Integer> intSeq = Arrays.asList(1,2,3);

intSeq.forEach(x -> {
   x += 2;
   System.out.println(x);
});

Example 3:

List<Integer> intSeq = Arrays.asList(1,2,3);

intSeq.forEach(x -> {
   int y = x * 2;
   System.out.println(y);
});

Example 4:

List<Integer> intSeq = Arrays.asList(1,2,3);

intSeq.forEach((Integer x -> {
   x += 2;
   System.out.println(x);
});

Implementation of Java 8 Lambdas

  • The Java 8 compiler first converts a lambda expression into a function

  • It then calls the generated function

  • For example, x -> System.out.println(x) could be converted into a generated static function

  •  

  •  

  •  

  • But what type should be generated for this function? How should it be called? What class should it go in?

public static void genName(Integer x) {
   System.out.println(x);
}

Functional Interfaces

  • Design decision: Java 8 lambdas are assigned to functional interfaces.

  • A functional interface is a Java interface with exactly one non-default method.  E.g.,

  •  
  •  

  •  

  • The package java.util.function defines many new useful functional interfaces.

public interface Consumer<T> {
   void accept(T t);
}

Assigning a Lambda to a Local Variable

public interface Consumer<T> {
  void accept(T t);
}

void forEach(Consumer<Integer> action {
  for (Integer i:items) {
    action.accept(t);
  }
}

List<Integer> intSeq = Arrrays.asList(1,2,3);

Consumer<Integer> cnsmr = x -> System.out.println(x);
intSeq.forEach(cnsmr);

Properties of the Generated Method

  • The method generated from a Java 8 lambda expression has the same signature as the method in the functional interface

  • The type is the same as that of the functional interface to which the lambda expression is assigned

  • The lambda expression becomes the body of the method in the interface

Method References

  • Method references can be used to pass an existing function in places where a lambda is expected

  • The signature of the referenced method needs to match the signature of the functional interface method

Summary of Method References

Method Reference Type Syntax Example
static ClassName::StaticMethodName String::valueOf
constructor ClassName::new ArrayList::new
specific object instance objectReference::MethodName x::toString
arbitrary object of a given type ClassName::InstanceMethodName Object::toString

Conciseness with Method References

  • We can rewrite the statement

  • intSeq.forEach(x -> System.out.println(x));

  •  

  • more concisely using a method reference

  • intSeq.forEach(System.out::println);

Stream API

  • The new java.util.stream package provides utilities to support functional-style operations on streams of values.

  • A common way to obtain a stream is from a collection:

  •         Stream<T> stream = collection.stream();

  • Streams can be sequential or parallel.

  • Streams are useful for selecting values and performing actions on the results.

Stream Operations

  • An intermediate operation keeps a stream open for further operations. Intermediate operations are lazy.

  • A terminal operation must be the final operation on a stream. Once a terminal operation is invoked, the stream is consumed and is no longer usable.

Example Intermediate Operations

  • filter excludes all elements that don’t match a Predicate.

  • map performs a one-to-one transformation of elements using a Function.

Cont.

  • A stream pipeline has three components:

    • A source such as a Collection, an array, a generator function, or an IO channel;

    • Zero or more intermediate operations; and

    • A terminal operation

Stream Example

int sum = widgets.stream()
	.filter(w -> w.getColor() == RED)
	.mapToInt(w -> w.getWeight())
	.sum();

Example

List<Integer> list = Arrays.asList(1,2,3);
int sum = list.stream().map(x -> x*x).reduce((x,y) -> x + y).get();
System.out.println(sum);

Title Text

Made with Slides.com