/*******************************************************************************
* Companion code for the book "Introduction to Software Design with Java",
* 2nd edition by Martin P. Robillard.
*
* Copyright (C) 2022 by Martin P. Robillard
*
* This code is licensed under a Creative Commons
* Attribution-NonCommercial-NoDerivatives 4.0 International License.
*
* See http://creativecommons.org/licenses/by-nc-nd/4.0/
*
*******************************************************************************/
package e2.chapter8;
/**
* Visitor that prints a representation of the hierarchical structure
* of a card source.
*/
public class StructurePrinterVisitor extends AbstractCardSourceVisitor
{
private int aTab = 0;
private String tab()
{
StringBuilder result = new StringBuilder();
for( int i = 0; i < aTab; i++ )
{
result.append(" ");
}
return result.toString();
}
@Override
public void visitCompositeCardSource(CompositeCardSource pCompositeCardSource)
{
System.out.println(tab() + "Composite");
aTab++;
super.visitCompositeCardSource(pCompositeCardSource);
aTab--;
}
@Override
public void visitDeck(Deck pDeck)
{
System.out.println(tab() + "Deck");
}
@Override
public void visitCardSequence(CardSequence pCardSequence)
{
System.out.println(tab() + "CardSequence");
}
}
print(String)
and then
println()
.print(String)
and then
println()
.x
- The String
to be printed.Console.charset()
if the Console
exists,
stdout.encoding otherwise.
Console.charset()
if the Console
exists,
stdout.encoding otherwise.
For simple stand-alone Java applications, a typical way to write a line of output data is:
System.out.println(data)
See the println
methods in class PrintStream
.
StringBuffer
, but with no guarantee of synchronization.
This class is designed for use as a drop-in replacement for
StringBuffer
in places where the string buffer was being
used by a single thread (as is generally the case). Where possible,
it is recommended that this class be used in preference to
StringBuffer
as it will be faster under most implementations.
StringBuffer
, but with no guarantee of synchronization.
This class is designed for use as a drop-in replacement for
StringBuffer
in places where the string buffer was being
used by a single thread (as is generally the case). Where possible,
it is recommended that this class be used in preference to
StringBuffer
as it will be faster under most implementations.
The principal operations on a StringBuilder
are the
append
and insert
methods, which are
overloaded so as to accept data of any type. Each effectively
converts a given datum to a string and then appends or inserts the
characters of that string to the string builder. The
append
method always adds these characters at the end
of the builder; the insert
method adds the characters at
a specified point.
For example, if z
refers to a string builder object
whose current contents are "start
", then
the method call z.append("le")
would cause the string
builder to contain "startle
", whereas
z.insert(4, "le")
would alter the string builder to
contain "starlet
".
In general, if sb refers to an instance of a StringBuilder
,
then sb.append(x)
has the same effect as
sb.insert(sb.length(), x)
.
Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.
Instances of StringBuilder
are not safe for
use by multiple threads. If such synchronization is required then it is
recommended that StringBuffer
be used.
Unless otherwise noted, passing a null
argument to a constructor
or method in this class will cause a NullPointerException
to be
thrown.
StringBuilder
implements Comparable
but does not override
equals
. Thus, the natural ordering of StringBuilder
is inconsistent with equals. Care should be exercised if StringBuilder
objects are used as keys in a SortedMap
or elements in a SortedSet
.
See Comparable
, SortedMap
, or
SortedSet
for more information.System
class contains several useful class fields
and methods. It cannot be instantiated.
Among the facilities provided by the System
class
are standard input, standard output, and error output streams;
access to externally defined properties and environment
variables; a means of loading files and libraries; and a utility
method for quickly copying a portion of an array.System
class contains several useful class fields
and methods. It cannot be instantiated.
Among the facilities provided by the System
class
are standard input, standard output, and error output streams;
access to externally defined properties and environment
variables; a means of loading files and libraries; and a utility
method for quickly copying a portion of an array.String
object is allocated and initialized to
contain the character sequence currently represented by this
object. This String
is then returned. Subsequent
changes to this sequence do not affect the contents of the
String
.String
object is allocated and initialized to
contain the character sequence currently represented by this
object. This String
is then returned. Subsequent
changes to this sequence do not affect the contents of the
String
.toString
in interface CharSequence
The characters of the String
argument are appended, in
order, increasing the length of this sequence by the length of the
argument. If str
is null
, then the four
characters "null"
are appended.
Let n be the length of this character sequence just prior to
execution of the append
method. Then the character at
index k in the new character sequence is equal to the character
at index k in the old character sequence, if k is less
than n; otherwise, it is equal to the character at index
k-n in the argument str
.
str
- a string.StringBuffer
, but with no guarantee of synchronization.
This class is designed for use as a drop-in replacement for
StringBuffer
in places where the string buffer was being
used by a single thread (as is generally the case). Where possible,
it is recommended that this class be used in preference to
StringBuffer
as it will be faster under most implementations.
StringBuffer
, but with no guarantee of synchronization.
This class is designed for use as a drop-in replacement for
StringBuffer
in places where the string buffer was being
used by a single thread (as is generally the case). Where possible,
it is recommended that this class be used in preference to
StringBuffer
as it will be faster under most implementations.
The principal operations on a StringBuilder
are the
append
and insert
methods, which are
overloaded so as to accept data of any type. Each effectively
converts a given datum to a string and then appends or inserts the
characters of that string to the string builder. The
append
method always adds these characters at the end
of the builder; the insert
method adds the characters at
a specified point.
For example, if z
refers to a string builder object
whose current contents are "start
", then
the method call z.append("le")
would cause the string
builder to contain "startle
", whereas
z.insert(4, "le")
would alter the string builder to
contain "starlet
".
In general, if sb refers to an instance of a StringBuilder
,
then sb.append(x)
has the same effect as
sb.insert(sb.length(), x)
.
Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.
Instances of StringBuilder
are not safe for
use by multiple threads. If such synchronization is required then it is
recommended that StringBuffer
be used.
Unless otherwise noted, passing a null
argument to a constructor
or method in this class will cause a NullPointerException
to be
thrown.
StringBuilder
implements Comparable
but does not override
equals
. Thus, the natural ordering of StringBuilder
is inconsistent with equals. Care should be exercised if StringBuilder
objects are used as keys in a SortedMap
or elements in a SortedSet
.
See Comparable
, SortedMap
, or
SortedSet
for more information.String
class represents character strings. All
string literals in Java programs, such as "abc"
, are
implemented as instances of this class.
String
class represents character strings. All
string literals in Java programs, such as "abc"
, are
implemented as instances of this class.
Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared. For example:
String str = "abc";
is equivalent to:
char data[] = {'a', 'b', 'c'}; String str = new String(data);
Here are some more examples of how strings can be used:
System.out.println("abc"); String cde = "cde"; System.out.println("abc" + cde); String c = "abc".substring(2, 3); String d = cde.substring(1, 2);
The class String
includes methods for examining
individual characters of the sequence, for comparing strings, for
searching strings, for extracting substrings, and for creating a
copy of a string with all characters translated to uppercase or to
lowercase. Case mapping is based on the Unicode Standard version
specified by the Character
class.
The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. For additional information on string concatenation and conversion, see The Java Language Specification.
Unless otherwise noted, passing a null
argument to a constructor
or method in this class will cause a NullPointerException
to be
thrown.
A String
represents a string in the UTF-16 format
in which supplementary characters are represented by surrogate
pairs (see the section Unicode
Character Representations in the Character
class for
more information).
Index values refer to char
code units, so a supplementary
character uses two positions in a String
.
The String
class provides methods for dealing with
Unicode code points (i.e., characters), in addition to those for
dealing with Unicode code units (i.e., char
values).
Unless otherwise noted, methods for comparing Strings do not take locale
into account. The Collator
class provides methods for
finer-grain, locale-sensitive String comparison.
javac
compiler
may implement the operator with StringBuffer
, StringBuilder
,
or java.lang.invoke.StringConcatFactory
depending on the JDK version. The
implementation of string conversion is typically through the method toString
,
defined by Object
and inherited by all classes in Java.