Description
Probably Just a Value but Maybe Nothing? In this lab, you are given our own generic wrapper class, a Probably . This is a wrapper class that can be used to store a value of any reference type. For now, our Probably is not going to be a very useful abstraction. Not to worry. we will slowly add more functionalities to it. Please read the following explanation on what the class Probably is. The Basics The class Probably stores either (1) none1 or (2) just a value of type T 2 . So, it is probably just some value of type T or it maybe nothing. It: • contains a private final �eld of type T to store the value of reference type T . • provides a private constructor. • provides a class method called none() that returns nothing1 . • provides a class method called just(T value) that returns something that contains just the value2 . • Since there is a possibility that value is equal to null , in such case, we also return nothing. • overrides the equals method from Object to compare if the two values inside are the same. • Two values are the same according to their respective equals method. • overrides the toString method so it returns the string representation of its values, between < and > . The method none and just are called a factory method. A factory method is a method provided by a class for the creation of an instance of the class. Probably is also made to be immutable. Once created, the value of the �eld value cannot be modi�ed! This is achieved by: • making the �eld final . • provide no getter and setter. Relevant part of the code: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 class Probably { private final T value; private static final Probably<?> NONE = new Probably<>(null); private Probably(T value) { this.value = value; } public static Probably none() { @SuppressWarnings(“unchecked”) Probably res = (Probably) NONE; return res; } public static Probably just(T value) { if (value == null) { return none(); } return (Probably) new Probably<>(value); } @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj instanceof Probably<?>) { Probably<?> some = (Probably<?>) obj; if (this.value == some.value) { return true; } if (this.value == null || some.value == null) { return false; } return this.value.equals(some.value); } return false; } Shared Object Using a public constructor to create an instance necessitates calling new and allocating a new object on the heap every time. A factory method, on the other hand, allows the �exibility of reusing the same instance. With the availability of the factory methods, Probably should keep the constructor private. Additionally, the factory method as well as having Probably immutable allows us to share a common object safely. The most common object here is the concept of nothing1 . The factory methods return nothing when: • the input argument to just(T value) is null , or • the factory method none() is invoked In both cases, we return a static instance called NONE . The sequence below shows how we can use a Probably using the methods above. Testing Probably The following sample run shows the current capability of Probably . You should also test using your own test cases to further understand Probably . 38 39 40 41 42 43 44 45 46 @Override public String toString() { if (this.value == null) { return “<>”; } else { return “<” + this.value.toString() + “>”; } } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 jshell> Probably.just(4) $.. ==> <4> jshell> Probably.just(Probably.just(0)) $.. ==> <<0>> jshell> Probably.just(Probably.just(Probably.just(“null”))) $.. ==> <<>> jshell> Probably.just(Probably.just(Probably.none())) $.. ==> <<<>>> jshell> Probably.just(Probably.just(null)) $.. ==> <<>> jshell> Probably.just(4).equals(Probably.just(4)) $.. ==> true jshell> Probably.just(4).equals(4) $.. ==> false jshell> Probably.just(Probably.just(0)).equals(Probably.just(0)) $.. ==> false You can check that our Probably is correct by running: There shouldn’t be any compilation warning or error when you compile TestProbably.java and all tests should prints ok . Acting on the Value Because Probably is immutable, it is not useful for us. Once created, we cannot modify the value and we cannot even get the value back. To make the class more useful, we want to be able to act on the object. A simple act can be just printing using System.out.println . One way for us to print the content of the value is to simply add a method called print . However, this is not useful as we have to add a new method for each action that we want Probably to allow. One way to do this is to abstract a computation. Think of higherorder function. Action Interface One way to abstract a computation is to imagine having a class with a single method called call that perform an action that we want. If we receive an instance of this class, we can invoke the method call to perform the action. Thus, we can say that a collection of all classes with a single method called call is an abstraction of an action. You have 2 tasks in this section: 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 jshell> Probably.just(Probably.just(0)).equals(Probably.just(Probably.just(0))) $.. ==> true jshell> Probably.just(“string”) $.. ==> jshell> Probably.just(“string”).equals(Probably.just(4)) $.. ==> false jshell> Probably.just(“string”).equals(Probably.just(“null”)) $.. ==> false jshell> Probably.just(null) $.. ==> <> jshell> Probably.none() $.. ==> <> jshell> Probably.none().equals(Probably.just(null)) $.. ==> true jshell> Probably.none() == Probably.just(null) $.. ==> true 1 2 javac -Xlint:rawtypes TestProbably.java java TestProbably ���Create an interface Action with a single abstract method called call inside the �le Action.java . • The method takes in a single parameter of generic type parameter T 3. • The method does not return any type. ���Create a non-generic class Print that implements Action with the method call that prints the string representation of the input argument into the standard output (i.e., System.out.println ) in the �le Print.java . Testing Action We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. You can test the additions to Probably above more comprehensively by running: There shouldn’t be any compilation warning or error when you compile Test1.java and all tests should prints ok . Actionable Interface With the Action interface, we can now perform a custome action. We can do this by adding in the Probably class, a method that can accept an Action . Since this is a good behaviour to have, we want to create an interface representing all classes that can accept an Action . Let’s call this interface as Actionable . You have 2 tasks in this section: ���Create an interface Actionable with a single abstract method called act inside the �le Actionable.java . • The method takes in a single parameter of type Action . This Action should accept a type T . 1 2 3 4 jshell> new Print().call(17) $.. ==> 17 jshell> new Print().call(“string”) $.. ==> string 1 2 javac -Xlint:rawtypes Test1.java java Test1 • The method does not return any type. ���Modify Probably to implement the interface Actionable . You need to implement the method act appropriately: • if the value in Probably is not null , we invoke call with the value. • otherwise, do nothing. Testing Actionable We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. You can test the additions to Probably above more comprehensively by running: There shouldn’t be any compilation warning or error when you compile Test2.java and all tests should prints ok . Immutating the Value So now we can create a container called Probably and we can print the content (with appropriate classes implementing Action we may also write the string representation of the value into a �le, etc). This is still not very useful since we cannot mutate the value. In the �rst place, we can not mutate the value because there is no mutator and the �eld value is declared with final . Instead, what we want to do is whenever there is a mutation, we want to create a new instance of this class. This is the essence of an immutable class. Immutator Interface How can we do this. Again, the simplest way is to simply add a method to return a new instance with some changes. However, due to type erasure, type T is treated as if it is of 1 2 3 4 5 6 jshell> Probably.just(4).act(new Print()) $.. ==> 4 jshell> Probably.just(“string”).act(new Print()) $.. ==> string jshell> Probably.none().act(new Print()) $.. ==> 1 2 javac -Xlint:rawtypes Test2.java java Test2 type Object . There is not much we can do with Object . Similar to how we manage to add a custom action to Probably , we want to add a custom mutator to the class. But since the class is immutable, let us calls this concept as immutation instead with the relevant interface called Immutator and Immutatorable . An Immutator is similar to the Action . However, unlike Action that does not return anything, we want Immutator to return something. Consider any method with single parameter. We can write this method signature as: where R is the return type and P is the type of the parameter. By invoking this method, we can change a reference type of some value of type P into another value of type R . This is the basis of our Immutator . Such a powerful concept, not only can we change the value, we can also change the type! You have 2 tasks in this section: ���Create an interface Immutator<R,P> with a single abstract method called invoke inside the �le Immutator.java . • The method takes in a single parameter of generic type parameter P . • The method returns a single value of generic type R . • In other words, Immutator<R,P> is an abstraction of the method R method(P param) . ���Create a generic class Improbable that implements Immutator in the �le Immutator.java with the method invoke that: • takes in a single parameter of type T . • returns a value of type Probably . • the method simply creates a Probably from T regardless of what the type T is (including even when type T is already Probably , but in this case what will be the actual return type?). Testing Immutator We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. 1 R method(P param) { .. } You can test your additions to Probably more comprehensively by running: There shouldn’t be any compilation warning or error when you compile Test3.java and all tests should prints ok . Immutatorable Interface Similar to before, we want to add a new method to Probably but we also want to create an interface to represent all classes that can accept an Immutator . Let’s call this method as transform . Remember that Immutator<R,P> has a method called invoke that can produce a value of type R when given a value of type P . Our �nal aim in the end is to transform Probably to Probably . For that, we want an immutator that transform T to R . Note that in this case, T corresponds to P in Immutator<R,P> . You have 2 tasks in this section: ���Create an interface Immutatorable with a single abstract method called transform 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 jshell> class Incr implements Immutator<Integer,Integer> { …> public Integer invoke(Integer t1) { …> return t1 + 1; …> } …> } jshell> class Length implements Immutator<Integer,String> { …> public Integer invoke(String t1) { …> return t1.length(); …> } …> } jshell> new Incr().invoke(4) $.. ==> 5 jshell> new Incr().invoke(new Incr().invoke(4)) $.. ==> 6 jshell> new Length().invoke(“string”) $.. ==> 6 jshell> new Incr().invoke(new Length().invoke(“string”)) $.. ==> 7 jshell> new Improbable<>().invoke(1) $.. ==> <1> jshell> new Improbable().invoke(null) $.. ==> <> jshell> new Improbable().invoke(1).transform(new Incr()) $.. ==> <2> jshell> new Improbable<>().invoke(new Improbable<>().invoke(1)) $.. ==> <<1>> 1 2 javac -Xlint:rawtypes Test3.java java Test3 inside the �le Immutatorable.java . • The method takes in a single parameter of type Immutator . This Immutator should accept a type T and return a type R . • The method returns a single value of type Immutatorable . ���Modify Probably to implement the interface Immutatorable . You need to implement the method transform appropriately: local • if the value in Probably is not null , we invoke invoke with the value and return Probably . • otherwise, return NONE . Testing Immutatorable We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. You can test your additions to Probably more comprehensively by running: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 jshell> class Incr implements Immutator<Integer,Integer> { …> public Integer invoke(Integer t1) { …> return t1 + 1; …> } …> } jshell> class Length implements Immutator<Integer,String> { …> public Integer invoke(String t1) { …> return t1.length(); …> } …> } jshell> Probably.just(4).transform(new Incr()) $.. ==> <5> jshell> Probably.just(4).transform(new Incr()).transform(new Incr()) $.. ==> <6> jshell> Probably.just(“string”).transform(new Length()) $.. ==> <6> jshell> Probably.just(“string”).transform(new Length()).transform(new Incr()) $.. ==> <7> jshell> Probably.none().transform(new Incr()) $.. ==> <> jshell> Probably.none().transform(new Length()) $.. ==> <> jshell> Probably.just(null).transform(new Length()).transform(new Incr()) $.. ==> <> 1 javac -Xlint:rawtypes Test4.java There shouldn’t be any compilation warning or error when you compile Test4.java and all tests should prints ok . Question First, recap what we can do. We can create Probably such that we can perform an action on it and mutate the value by creating a new instance each time the value changes. The next step is to ask questions regarding the value. The kind of questions we want to ask is a simple yes/no question. Since at this point we have already created so many interfaces: • Action • Actionable • Immutator • Immutatorable we do not want to create more interface. Instead, note that this is a special case of Immutator . This is simply an Immutator that returns a boolean. Special Immutator You have 2 tasks in this section: ���Create a non-generic class IsModEq that implements this special Immutator that returns boolean values in the �le IsModEq.java . • The class has a public constructor that takes in two positive integer parameters div and check . • The class implements the invoke inherited from Immutator . • The method accepts a single integer parameter val . • The method returns true if the remainder when val is divided by div is equal to check . ���Add the method check in Probably . • The method takes in a single parameter of type of the special Immutator introduced in this section. 2 java Test4 • The method returns a single value of type Probably . • The behaviour of the method can be captured by the table below: value in PPrroobbaabbllyy<> yes/no result null yes ( true ) nothing null no ( false ) nothing non- null yes ( true ) this non- null no ( false ) nothing Testing Question We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. You can test your additions to Probably more comprehensively by running: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 jshell> class Incr implements Immutator<Integer,Integer> { ...> public Integer invoke(Integer t1) { ...> return t1 + 1; ...> } ...> } jshell> class Length implements Immutator<Integer,String> { ...> public Integer invoke(String t1) { ...> return t1.length(); ...> } ...> } jshell> Probably.just(17).check(new IsModEq(3,2)) ∕∕ 17 % 3 is equal to 2 $.. ==> <17> jshell> Probably.just(18).check(new IsModEq(3,2)) ∕∕ 18 % 3 is not equal to 2 $.. ==> <> jshell> Probably.just(16).transform(new Incr()).check(new IsModEq(3,2)) ∕∕ 17 % 3 is not equal to 2 $.. ==> <17> jshell> Probably.just("string").transform(new Length()).check(new IsModEq(3,2)) $.. ==> <8> jshell> Probably.just(null).check(new IsModEq(0,2)) $.. ==> <> There shouldn't be any compilation warning or error when you compile Test5.java and all tests should prints ok . It is also good to check that the following code should throw ArithmeticException due to divide by zero. However, note that this is the similar to the last line above. The difference is that in above we have null so the instance of IsModEq is not even used. Applicable In this last section, we want to show some of the power of Probably given our changes to it. Recap that we have at least 4 interfaces. • Action • Actionable • Immutator • Immutatorable It's Probably an Immutator Since Probably can store any reference type T and Immutator is a reference type, we can store Immutator inside Probably . What can we do with this Immutator inside Probably ? We have two cases here: • if there is indeed an Immutator (i.e., it just2 some immutator), then we can use the immutator to mutate the value and the result of this really depends on the value. • if there is no Immutator (i.e., it is nothing1 ), then we simply return nothing. Basically: nothing in, nothing out. You have 2 tasks in this section: 1 2 javac -Xlint:rawtypes Test5.java java Test5 1 Probably.<>just(2030).check(new IsModEq(0,2)) ���Create an interface Applicable with a single abstract method apply inside the �le Applicable.java . • The method takes in a single parameter of type Immutator inside Probably . This Immutator should accept a generic type T and return a generic type R . • The method returns a single value of type Probably . • The method performs the operation described above. ���Modify Probably to implement the interface Applicable . You need to implement the method apply appropriately: • if the value in Probably is not null and the value inside the Probably parameter is not null, we invoke the Immutator with the value and return Probably`. • otherwise, return NONE . Testing Applicable We recommend to �rst design your solution, �gure out the type needed which may or may not involve wildcards. Afterwards, you can test your solution with the following code. You should also test with your own test cases as the given test case may not be complete. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 jshell> class Incr implements Immutator<Integer,Integer> { ...> public Integer invoke(Integer t1) { ...> return t1 + 1; ...> } jshell> class Length implements Immutator<Integer,String> { ...> public Integer invoke(String t1) { ...> return t1.length(); ...> } jshell> Probably<Immutator<Integer,Integer>> justIncr = Probably.just(new Incr()); jshell> Probably<Immutator<Integer,String>> justLength = Probably.just(new Length()); jshell> Probably<Immutator<Integer,Integer>> noIncr = Probably.none(); jshell> Probably<Immutator<Integer,String>> noLength = Probably.none(); jshell> Probably.just(17).apply(justIncr) $.. ==> <18> jshell> Probably.none().apply(justIncr) $.. ==> <> jshell> Probably.just(17).apply(noIncr) $.. ==> <> jshell> Probably.none().apply(noIncr) $.. ==> <> jshell> Probably.just("string").apply(justLength) $.. ==> <6> jshell> Probably.none().apply(justLength) $.. ==> <> You can test your additions to Probably more comprehensively by running: There shouldn't be any compilation warning or error when you compile Test6.java and all tests should prints ok . Hints • This lab is more about the type rather than the code. • You should think about the types that are required by each class and methods. In particular, you should think carefully about the generic type and wildcards if needed. Files A set of empty �les have been given to you. You should only edit these �les. You must not add any additional �les. The �les Test1.java , Test2.java , etc., as well as CS2030STest.java , are provided for testing and they are not to be submitted. You can edit them to add your own test cases. Lastly, the �le Lab4.java is given for you and it should not be modi�ed except for correcting any style problems detected by our style checker. This �le will be the main entry point for our testing on CodeCrunch. Following CS2030S Style Guide You should make sure that your code follows the given Java style guide Grading This lab is worth 16 marks and contributes 4% to your �nal grade. The marking scheme is as follows: • Style: 2 marks 27 28 jshell> Probably.just("string").apply(noLength) $.. ==> <> jshell> Probably.none().apply(noLength) $.. ==> <> 1 2 javac -Xlint:rawtypes Test6.java java Test6 • Correctness: 14 marks We will deduct 1 mark for each abuse or unnecessary use of @SuppressWarnings and for each raw type. Note that the style marks are conditioned on the evidence of efforts in solving Lab 4. ���We will refer to this as none, nothing, or NONE . ���We will refer to this as just, some, or something. ���Here, a single type T includes the possibility that it uses wildcards involving T .
