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
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
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
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 :
Rules, Parameters, Arguments - 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!"
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
- It should take a String and produce a String
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
Classes and Instances All Capitalizers use the same rule - We say that these Capitalizers are all instances of the Capitalizer class
- in that it uses the particular transform rule (method) that is stated
Write the class Pedant for a Pedantic Transformer
Classes and Instances 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)?
Creating Instances To create a new instance of a class, we use the new operator:
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"
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
Consider the transform rule for NameDropper: 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
In Java, the transform method for NameDropper is: In Java, the transform method for NameDropper is: - this.myName means this instance’s myName field
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:
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; } }
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; } }
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!!!
Dostları ilə paylaş: |