Recap: The design of Word Games Fundamentals of Software Development 1 4/17/2018 Recap: The design of Word Games We have answered the “four questions” (at least partially): System behavior? Allows a user to play various word games Members of the community? (one) User interface & User , (many) Transformers, (many) Connections How do they interact? User operates user interface, which creates Transformers and Connections. Transformers communicate through Connections. What goes inside a Transformer? ConnectionAcceptors, Connections, etc plus an instruction-follower with rules, such as for Capitalizer: 1. Read input 2. Produce capitalized version of it 3. Write output Fundamentals of Software Development 1 Rose-Hulman Institute of Technology

How to implement rules: Outline An instruction-follower has a rule, e.g. for Capitalizer: 1. Read input 2. Produce capitalized version of it 3. Write output Now let’s see how to implement such rules, as follows! What is a String? What can you do with them? Rules, Parameters, Arguments – Methods Classes and instances – Creating instances (new) Fields and constructors Fundamentals of Software Development 1

Strings Java has a special kind of object called a String: "Hello" "What is this?" "x&% _()^*!" Double quotes are not part of the string, they simply indicate where the string begins and ends Our Transformers are StringTransformers. Each takes String(s) and produces a transformed String String concatenation: "Turkeys are" + "bzzz what?!" yields "Turkeys arebzzz what?!" The Java + operator takes two Strings and produces a String Fundamentals of Software Development 1

What Can You Do with Strings? Use concatenation operator (per previous slide) Invoke a String method toUpperCase : "Hello".toUpperCase() yields "HELLO" Invoke a String method substring : String method dot arguments, in parentheses Numbering starts at zero "Hello".substring(3) yields "Hello".substring(1, 3) yields "Hello".substring(0) yields "lo" "el" "Hello" (start at , end before) Fundamentals of Software Development 1

Rules, Parameters, Arguments Now that we know about Strings, we can look inside our Transformers Here is the transform rule for a Capitalizer: The parameter: The temporary name thePhrase that refers to the actual argument supplied to the Capitalizer. What is the transform rule for a Pedantic Transformer that seems to know everything? E.g., given "you stink!" it outputs "Obviously you stink!" to transform a String (say, thePhrase), return thePhrase.toUpperCase(); Answer on next slide Fundamentals of Software Development 1

Rules, Parameters, Arguments Here is the transform rule for a Pedantic: What do we call whatToSay? Answer: the parameter If the parameter whatToSay is given the actual value "you stink", it is called an argument Could we have used thePhrase instead of whatToSay? Yes, we could use any legal Java name where we used whatToSay We must, of course, use the same name throughout the rule Why is Obviously inside quotes while whatToSay is not? The phrase Obviously is literally what we want, while whatToSay is only a name that lets us refer to some actual value Think of another Transformer and write its transform rule It should take a String and produce a String to transform a String (say, whatToSay), return "Obviously " + whatToSay; Questions? Fundamentals of Software Development 1

Methods (Rules in Java) In Java, such rules are called methods Here is the transform method for a Capitalizer: The syntax (notation) for a method definition looks like this: Our example begins with String indicating that the method returns a String Exercise: Write the transform method for a Pedantic Transformer String transform(String thePhrase) { return thePhrase.toUpperCase(); } ReturnType methodName( Type parameter, ...) { Information on what to do } String transform(String whatToSay) { return "Obviously " + whatToSay; } Answer: Fundamentals of Software Development 1 Questions?

Classes and Instances All Capitalizers use the same rule We say that these Capitalizers are all instances of the Capitalizer class Capitalizer differs from a generic StringTransformer in that it uses the particular transform rule (method) that is stated Write the class Pedant for a Pedantic Transformer class Capitalizer extends StringTransformer { String transform(String thePhrase) { return thePhrase.toUpperCase(); } } Answer on next slide Fundamentals of Software Development 1

Classes and Instances This class describes what a Pedant can do class Pedant extends StringTransformer { String transform(String whatToSay) { return "Obviously " + whatToSay; } } This class describes what a Pedant can do The class is like a recipe from which to make a particular Pedant The class is not a Pedant itself! Can you guess what word would we use to create a new Pedant (more precisely, a new instance of a Pedant)? Answer on next slide Fundamentals of Software Development 1

Creating Instances To create a new instance of a class, we use the new operator: To create a Pedant in Java, we use new Pedant() Saying it again cooks up another Pedant: Fundamentals of Software Development 1

Many Instances Creating multiple instances of Transformers makes life interesting. For example: What does sending "I’m here!" to a Pedant, and sending that Pedant’s output to another Pedant yield? Answer: "Obviously Obviously I’m here!" What does sending "not much" to a Pedant, and sending that Pedant’s output to a Capitalizer yield? Answer: "OBVIOUSLY NOT MUCH" What does sending "not much" to a Capitalizer, and sending that Capitalizer’s output to a Pedant yield? Answer: "Obviously NOT MUCH" Fundamentals of Software Development 1

Classes, Instances and Fields One class can describe many different instances Now let’s see multiple distinct instances of a class, with local state associated with each instance Two NameDroppers, each with their own myName field Rumi Maria Hello Rumi says Hello Maria says Hello Fundamentals of Software Development 1

Consider the transform rule for NameDropper: Rumi Maria Hello Rumi says Hello Consider the transform rule for NameDropper: myName is NOT a parameter here (do you see why not?) a persistent part of the particular NameDropper So we need a local storage spot, with a name that lives with the NameDropper instance Such a name is called a field Maria says Hello to transform a String (say, thePhrase), return myName + " says " + thePhrase; Fundamentals of Software Development 1

In Java, the transform method for NameDropper is: Maria Hello Rumi Rumi says Hello Maria says Hello In Java, the transform method for NameDropper is: this.myName means this instance’s myName field String transform(String thePhrase) { return this.myName + " says " + thePhrase; } Fundamentals of Software Development 1

Fields and Constructors A NameDropper must know its name from the very beginning We use a constructor to set the field called myName: Then, when we invoke NameDropper’s constructor, we give it an argument: NameDropper(String whatMyNameIs) { this.myName = whatMyNameIs; } new NameDropper("Rumi"); new NameDropper("Maria"); Fundamentals of Software Development 1

Class: Fields, Constructors, Methods Fundamentals of Software Development 1 4/17/2018 Class: Fields, Constructors, Methods public class NameDropper extends StringTransformer implements StringTransformable { private String name; // field: persistent storage, a permanent part // of each NameDropper public NameDropper(String whatMyNameIs) { // Constructor this.name = whatMyNameIs; } public String transform(String whatToSay) { // Method return this.name + " says " + whatToSay; Questions? Private means private to the class. The standard is that fields are generally private and all else is public (for now) – more on this later. Fundamentals of Software Development 1 Rose-Hulman Institute of Technology

Summary: Java syntax of a class Yellow font on this slide indicates Java syntax. Questions? public class NameDropper extends StringTransformer { private String myName; // field: persistent storage, a permanent part of each object public NameDropper(String whatMyNameIs) { // Creation rule this.myName = whatMyNameIs; } public String transform(String whatToSay) { // Transform rule return this.myName + " says " + whatToSay; Fundamentals of Software Development 1

Summary All Transformers obey the same general rules and interface Each defines a transform method (rule) that takes a String and returns a String This enables us to use the same Connection interaction for all of them Differences among Transformer behaviors are hidden inside the transform method that each of them implements Today we saw most of the basic pieces of Java None was shown in sufficient detail to permit mastery We’ll revisit all these pieces over the next few weeks!!! Fundamentals of Software Development 1