3.3 ScrambledWordLibrary

Juppies 2 by Dr Heinz M. Kabutz

We now want to make a new type of WordLibrary that also scrambles the individual letters of the words. We click on the WordLibrary interface and press ALT+Enter (our magic key in NetBeans and IntelliJ IDEA). We select "Implement Interface" and make the name "ScrambledWordLibrary".

Similarly to the ShuffledWordLibrary, this ScrambledWordLibrary will also delegate to another WordLibrary. We add the field private final WordLibrary other;

To generate code we click ALT+Insert or right-click + Insert Code... and select the code we want to create. I select "Constructor" and it then creates a constructor for me that takes as a parameter the other WordLibrary. Sweet!

More code generation coming up. If we delete all the methods in the class and again press ALT+Insert or right-click + Insert Code... we see a selection for "Delegate Method...". Select that and then select the methods getWord(), getScrambledWord() and getSize(). The code is generated to delegate all these methods to the "other" WordLibrary. getWord() and getSize() stay the way they are, but we will change getScrambledWord():

First we get the letters from inside the word as a character array (char[]). This is an array of the individual letters inside the word. We then add a call to the scramble(letters) method. This method does not exist yet; we will write it in a moment. We then return a new String with the scrambled letters.

Again, we use ALT+Enter to create the scramble() method inside the class. The benefit of coding like this is that you save time thinking about what the parameters need to be - your IDE figures that out for you.

At this point we do not want to decide how the characters are to be scrambled. We thus make the scramble() method abstract and remove the method body. Because the method is abstract, we need to also make the class abstract. It does not make much sense to have a private abstract method. Abstract has to be overridden by a subclass, but private cannot be overridden? It's a paradox, and Java does not allow us to define such methods. It would work to make it public, but that would mean that any other class could call this method. Instead, we make it protected, which means that only subclasses can call it. Technically, it is possible for other classes in the same package to also call this method, but we usually discourage that. The classes in the eu.javaspecialisdts.courses.juppies2.anagrams.ui package would not be able to call that method. Even though other classes in the same eu.javaspecialisdts.courses.juppies2.anagrams.lib package can call the method, we usually try form a mental picture that we cannot.

The explanation why this is, goes way back to before Java 1.0 was even released. The precursor to Java was called Oak. In that language, we did not have a private modifier. We only had public, protected and nothing. When we did not specify anything, this was considered as sort-of private. Only classes in the same package could access it. There was no way to make a member only accessible from within one class. When Java 1.0 was eventually released, they added the private modifier, and had a private protected combination that meant we could only access the member from a subclass, not from other classes in the same package. This was dropped in Java 1.1, which left us without the ability to specify that a member can only be seen by a subclass and not by other classes in the same package. See Newsletter 055.

Previous Chapter Previous Lesson Next Lesson

Previous Chapter Previous Lesson Next Lesson

Comments

Table of Contents

• 0.1: Programming is a team sport - source control
• 0.2: Creating an account on GitHub
• 0.3: Forking the Juppies2 repository from kabutz
• 0.4: Oracle JDK
• 0.5: Oracle OpenJDK
• 0.6: Azul's Zulu OpenJDK
• 0.7: Installing the Oracle OpenJDK
• 0.8: Integrated Development Environments (IDEs)
• 0.9: Downloading Apache NetBeans
• 0.10: Loading our Juppies2 Project in Apache NetBeans
• 0.11: Running the AnagramGame with Apache NetBeans
• 0.12: Downloading IntelliJ IDEA Community Edition
• 0.13: Installing IntelliJ IDEA Community Edition
• 0.14: Running the AnagramGame with IntelliJ IDEA Community Edition
• 0.15: Downloading and Installing Eclipse
• 0.16: Running the AnagramGame with Eclipse
• 1.1: AnagramGame Project Structure
• 1.2: WordLibrary
• 1.3: Swing User Interface (UI)
• 1.4: Buffer Overflows
• 1.5: Demo of New Word Button
• 1.6: Demo of Guess Button
• 1.7: StaticWordLibrary Structure
• 1.8: StaticWordLibrary Details
• 1.9: Changing the Size of Our StaticWordLibrary
• 1.10: How my Buffer Overflow Wiped my Colleague's Hard Disk
• 1.11: Adding Our Own Words to the StaticWordLibrary
• 1.12: WordLibraryTest With JUnit
• 1.13: Java's For Loop
• 1.14: Testing That Words Are Anagrams
• 1.15: Running JUnit
• 1.16: isAnagram() Method
• 1.17: Fixing StaticWordLibrary
• 1.18: WordLibraries Facade
• 1.19: Find Usages
• 1.20: Exercise
• 1.21: Commiting Changes
• 1.22: GitHub Repository
• 1.23: Pushing Commits to Remote Repository on GitHub
• 1.24: Until Next Time
• 2.1: Welcome back
• 2.2: Setting up NetBeans Git Toolbar
• 2.3: Creating a Git Branch for Today's Session
• 2.4: Typical Directory Structure Under Maven
• 2.5: NetBeans Magic Shortcuts
• 2.6: Avoid Copy & Paste Programming
• 2.7: Creating a ShuffledWordLibrary
• 2.8: Integer Array for Shuffled Indexes
• 2.9: Finishing the methods to delegate to the other WordLibrary
• 2.10: Trying out the "ShuffledWordLibrary" That Does Not Really Shuffle
• 2.11: Committing Our Changes to Git
• 2.12: Shuffling the Integer Array
• 2.13: Trying Out the Shuffled Anagram List
• 2.14: Committing our "shuffle" method
• 2.15: ArrayShuffler
• 2.16: Creating an ArrayShufflerTest
• 2.17: Printing the indexes array
• 2.18: Fixing Random to be more random
• 2.19: Extending the Tests
• 2.20: The Goat, The Wolf and The Cabbage (Swapping Integer Values)
• 2.21: Testing the Integer Swapping Code
• 2.22: Testing Before Running Application
• 2.23: Fixing the Integer Swapping Code
• 2.24: Integer Swapping With XOR
• 2.25: Value of Source Control Systems
• 2.26: Changed WordLibrary from an Abstract Class to an Interface
• 2.27: Commit and Push
• 2.28: Until Next Time
• 3.1: Welcome back
• 3.2: Create a new Git Branch
• 3.3: ScrambledWordLibrary
• 3.4: SortedScrambledWordLibrary
• 3.5: Committing Entire Project At Once
• 3.6: Creating a RandomScrambledWordLibrary
• 3.7: Adding a shuffle(char[]) method
• 3.8: Testing the shuffle() method
• 3.9: Scrambler Strategy Extracted
• 3.10: Rot13Scrambler
• 3.11: OriginalScrambler
• 3.12: Moving Scrambler Interface Into ScrambledWordLibary Using IntelliJ IDEA
• 3.13: Moving Shuffler Implementations Into ScrambledWordLibrary
• 3.14: Danger of Overusing Inner Classer
• 3.15: Testing Refactoring
• 3.16: Beauty of IDE Interoperability
• 3.17: Anonymous Inner Classes
• 3.18: Converting Anonymous Inner Class to Lambda
• 3.19: Expression Lambdas
• 3.20: Font Ligatures
• 3.21: Testing and Commiting Lambdas
• 3.22: Turning Rot13Scrambler into a Lambda
• 3.23: Method References
• 3.24: Making ArrayShuffler.shuffle() Methods static
• 3.25: Forcing Everyone To Use Static Methods
• 3.26: DecoratedWordLibrary
• 3.27: ScrambledWordLibrary as a Decorator
• 3.28: ShuffledWordLibrary as a Decorator
• 3.29: Cleaning Up the Concrete Decorators
• 3.30: Updated Copyright Notices
• 3.31: Make Classes Final Where Possible
• 3.32: Commit and Push
• 3.33: Conclusion

We hope you enjoyed this tutorial. If you did, you will also enjoy our courses. We suggest you start with Extreme Java - Advanced Java, followed by Extreme Java - Concurrency Performance for Java 8.