CS计算机代考程序代写 ocaml Lambda Calculus chain compiler Java c++ c# Haskell junit COMP 348 Principles of Programming Languages

COMP 348 Principles of Programming Languages

COMP 348
PRINCIPLES OF
PROGRAMMING
LANGUAGES

LECTURE 12 –ADVANCED TOPICS IN JAVA

Fall 2021Dept. of Computer Science and Software Engineering, Concordia University

Advanced Object-Oriented Programming

with Java

Variance, Covariance, and Contravariance

2

Variance refers to how subtyping between more complex types

relates to subtyping between their components.

For instance, given Cat is a subtype of Animal, variance is

referred to how a list of Cats relate to a list of Animals, Or how

should a function that returns Cat relate to a function that returns

Animal.

3

Variance, Covariance, and Contravariance

Within the type system of a programming language, a typing rule

or a type constructor is:

• covariant if it preserves the ordering of types (≤), which orders types from more

specific to more generic; also known as sub-typing

• contravariant if it reverses this ordering;

• bivariant if both of above apply

• variant if covariant, contravariant or bivariant;

• invariant or nonvariant if not variant.

Example:

• covariant: a Cat[] is an Animal[];

• contravariant: an Animal[] is a Cat[];

• invariant: an Animal[] is not a Cat[] and a Cat[] is not an Animal[].

4

Variance, Covariance, and Contravariance

5

Variance, Covariance, and Contravariance

https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)

In Java, Arrays are said to be covariant which basically means

that, given the subtyping rules of Java, an array of type T[] may

contain elements of type T or any subtype of T. For instance:

Additionally, the subtyping rules of Java also state that an array

S[] is a subtype of the array T[] if S is a subtype of T.

Now, what if one does the following?

6

Java Arrays are covariant

Number[] numbers = new Number[3];

numbers[0] = new Integer(10);

numbers[1] = new Double(3.14);

Integer[] ia = {1, 2, 3};

Number[] na = ia;

na[0] = 3.14;

What if we try the following?

The Above complies but it causes ArrayStoreException during

runtime. The issue is referred to as the heap pollution.

In the Java programming language, heap pollution is a situation

that arises when a variable of a parameterized type refers to an

object that is not of that parameterized type.

7

Heap Pollution

Integer[] ia = {1, 2, 3};

Number[] na = ia;

na[0] = 3.14;

Consider the following function

The above function may be used to calculate the sum of arrays

of numbers, integers, longs, etc.

8

Covariance and functions

static long sum(Number[] numbers) {

long s = 0;

for(Number number : numbers) {

s += number.longValue();

}

return s;

}

Integer[] myInts = {1,2,3,4,5};

Long[] myLongs = {1L, 2L, 3L, 4L, 5L};

Double[] myDoubles = {1.0, 2.0, 3.0, 4.0, 5.0};

System.out.println(sum(myInts));

System.out.println(sum(myLongs));

System.out.println(sum(myDoubles));

Advanced Object-Oriented Programming

with Java

Wildcards and Generics

9

Java generics use type erasure. Therefore the type information

is not only discarded by the compiler and therefore not available

at run time.

Consider the following example:

Unlike arrays, Java Generics are invariant. For instance, the

following is illegal“:

10

Wildcards and Generics

List myInts = new ArrayList();

myInts.add(1);

myInts.add(2);

List nums = myInts; //compiler error

Consider the following example:

The above function may NOT be used, because generics are not

covariant.

11

Wildcards and Generics

static long sum(List numbers) {

long s = 0;

for(Number number : numbers) {

s += number.longValue();

}

return s;

}

List myInts = Arrays.asList(1,2,3,4,5);

List myLongs = Arrays.asList(1L, 2L, 3L, 4L);

List myDoubles = Arrays.asList(1.0, 2.0, 3.0);

System.out.println(sum(myInts)); // compiler error

System.out.println(sum(myLongs)); // compiler error

System.out.println(sum(myDoubles)); // compiler error

Java wildcards provide a solution to this. Instead of using a type

T as the type argument of a given generic type, we can use a

wildcard declared as ? extends T, where T is a known base type.

The above function may now be used, because of using the

wildcard.

12

Wildcards and Generics

static long sum(List numbers) {

long s = 0;

for(Number number : numbers) {

s += number.longValue();

}

return s;

}

List myInts = Arrays.asList(1,2,3,4,5);

List myLongs = Arrays.asList(1L, 2L, 3L, 4L);

System.out.println(sum(myInts)); // OK

System.out.println(sum(myLongs)); // OK

Using static import, one may rewrite the code as:

This sometimes is very useful if a common static method is

extensively used in a class file.

Note: static imports may not be compared to “include” feature in

other programming languages. In java, it is purely used as a

short cut for coding, and the imported methods are purely called

and are not added to the class at all. Static imports are used to

translate function calls during the compile time. 13

Side Note: Static Imports

import static java.util.Arrays.asList;

.

.

.

List myInts = asList(1,2,3,4,5); // calls Arrays.asList() method

.

.

.

Static import is a feature introduced in the Java 5 that allows

members (fields and methods) which have been scoped within

their container class as public static, to be used in Java code

without specifying the class in which the field has been defined.

When defined in the class

Question: Can we apply this on System.out.println as well?

14

Side Note: Static Imports

import static java.lang.Math.PI;

import static java.lang.Math.pow;

public class HelloWorld {

public static void main(String[] args) {

System.out.println(“Considering a circle with a diameter of 5 cm, it has”);

System.out.println(“a circumference of ” + (PI * 5) + ” cm”);

System.out.println(“and an area of ” + (PI * pow(2.5, 2)) + ” sq. cm”);

}

}

Static imports are heavily used in JUnit.

The @Test above is an annotation class which is discussed at

the end of this chapter.

15

Side Note: Static Imports

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

public class MyTests {

@Test

public void myTestProc() {

MyClass tester = new MyClass(); // MyClass is being tested

// assert statement

assertEquals(0, tester.multiply(10, 0), “10 x 0 must be 0”);

}

}

Java supports three types of wildcards:

• The unbounded wildcard type is specified using the wildcard

character (?)

• The upper bounded wildcard type restricts the unknown type

to be a specific type or a subtype of that type and is

represented using the extends keyword:

• A lower bounded wildcard is expressed using the super

keyword, followed by its lower bound:

16

Types of Wildcards

Collection

List

Comparator

With covariance we can read items from a structure, but we

cannot write anything into it.

17

Wildcards and Covariance

List na = new ArrayList();

// List na = new ArrayList();

// List na = new ArrayList();

Number n = na.get(0); // OK

na.add(45L); //compiler error

For contravariance we use a different wildcard called ? super T,

where T is our base type. With contravariance we can do the

opposite. We can put things into a generic structure, but we

cannot read anything out of it.

Contravariance may be used as output parameters.

18

Wildcards and Contravariance

// List na;

Number n = na.get(0); //compiler error

Reading and Writing to generics may be illustrated using the

following example:

19

Covariance and Contravariance in parameters

static void copy(List src,

List dest) {

for(Number n : src) {

dest.add(n);

}

}

List ia = Arrays.asList(1, 2, 3, 4);

List da = Arrays.asList(3.14, 6.28);

List