Download Document

Big Java Chapter 4
Number types (chapter 4.1)
 So far, we have been using two types for numbers; int for integer
numbers, and double for decimal numbers
 These are two examples of so-called primitive types – types which
are not classes
 Variables of a primitive type are not references to objects, they are
represented “directly” in the variable
 In general, we have a total of eight primitive types in Java





Four primitive types for integer numbers:
byte: uses a single byte, range is -128 to 127 (28)
short: uses two bytes, range is -32768 to 32767 (216)
int: uses four bytes, range is (about) -2*109 to 2*109 (232)
long: uses eight bytes, range is (almost) -1019 to 1019 (264)
 Two types for decimal numbers:
 float: uses four bytes, range is 1038, 7 significant decimals
 double: uses eight bytes, range is 10308, 15 significant decimals
 char: For representing characters, uses 2 bytes
 boolean: Representing true or false, uses a single bit (in theory)
 Choice of correct type may matter in cases where very large – or
small – numbers are used for calculation
 In principle best to choose the smallest possible type, but unless we
use millions of numbers, hardly a problem (unless we work on a very
special platform)
Big Java Chapter 4
Number types (chapter 4.1)
 Overflow – when we try to put a value into a numeric variabke,
which is outside the range of the value.
 This is not reported!!
 Order of numeric operations may matter, watch out for successive
multiplications – divide when possible
 If we run into problems, we can switch to a long, or perhaps use
decimal numbers?
 Rounding errors may occur when using decimal types – it is
impossible to represent all fractional values precisely
 This is why we sometimes see results like 4.40000000001
 Printing of decimal numbers can be controlled by using formatting
strings, specifying the number of decimals
 Conversion between integer and decimal values is possible, by using
a cast operation
 Casting a decimal number to an integer will throw away some
information, namely the fractional part
 Cast syntax: (typeName)expression
 Example: int valueAsInt = (int)valueAsDouble;
 If this is not acceptable, use Math.round(value) instead
 For special purposes, we have two classes for handling big numbers
available: BigInteger and BigDecimal
 These types are classes, and we cannot apply normal arithmetic
operations to them
 Advantage: can handle almost infinitely large numbers with almost
infinite precision
 Drawback: Very slow, and cannot use standard arithmetic
Big Java Chapter 4
Constants (chapter 4.2)
 A constant is value which never changes!
 Why do we need constants in a Java program? To represent some
constant value once by a symbolic name, instead of writing that
value in various places in the code
 Easier to understand the code, and easier to change the value if
needed (only need to change the value one place)
 Avoid so-called “magic numbers” in your code!
 A constant is represented just like a variable, and can have the same
primitive types
 However, we use a slightly different syntax, in order to turn the
variable into a constant – the keyword final
 A variable declared as final cannot change its value. The compiler
will report an error if we try
 Very often, constanst are needed outside the classes in which they
are declared. Also, the constants should not belong to some specific
object. It seems a bit silly to create an object just to be able to use the
constants in the classs
 Both of these properties can be achieved by declaring the constants
to be public, and static
 The static keyword implies that this field is not an “instance field”,
it rather belongs to the class as such
 Note that non-constants can also be declared as static
 When we wish to refer to a (statically declared) constant, we use the
syntax ClassName.constantName
 A statically declared constant or variable will only occur once, no
matter how many objects we create! (“global variable”)
Big Java Chapter 4
Assignment, Increment and Decrement (chapter 4.3)
 Recall that in Java, the “=” symbol defines an action (assignment to a
variable), not a comparison.
 In an assignment, the expression on the right-hand side is evaluated
completely before assigning the resulting value to the variable on the
left-hand side
 The expression can be another variable, a method call, or some
expression involving the variable on the left-hand side
 It is perfectly legal to write count = count+ 5; This will just add
5 to the value in count, as we would expect
 For doing increment (increase the value by 1), and decrement
(decrease the value by 1), we have a special notation:
 Count++;
 Count--;
// Increment
// Decrement
 Why? These operations are so common, that a “shorthand” for these
operations is very useful, and even easier to read
 There is also a more general shorthand for updating the value of a
variable, which combines assignment and arithmetic
 balance += amount; means balance = balance + amount;
 balance -= amount; means balance = balance - amount;
 balance *= factor; means balance = balance * factor;
 balance /= factor; means balance = balance / factor;
 Some find this notation useful and easy to read, some find it
confusing. Choose the one you like best!
Big Java Chapter 4
Arithmetic Operation and Math Functions (chapter 4.4)
 We have already seen that division is symbolised by the “/” symbol.
 When we use decimal values, division behaves just as we would
expect, e.g. 7.0 / 4.0 = 1.75
 However, division of integer numbers may produce a surprising
result, e.g. 7 / 4 = 1 (??)
 If both numbers – or expressions – involved in the division are
integer, then the result becomes an integer, like above
 If just one of the numbers/expressions are a decimal number, the
result is a decimal number, e.g. 7 / 4.0 = 1.75
 To supplement integer division, the “%” symbol is used for
calculation of the remainder in a integer division, e.g. 7 % 4 = 3
 The “priority” of arithmetic operators is as usual, so multiplication
and division bind harder than addition and subtraction
 Example: 8 + 4 / 2 = 10 (not 6)
 Example: 8 – 4 * 2 = 0 (not 8)
 However, you are always allowed to use parentheses (brackets) in
order to make an expressions clearer
 The Java library also includes a Math class, which contains the most
common mathematical functions, such as rounding, trigonometry,
powers, exponentials and logarithm
 All functions in the Math class are static, so they are called using the
syntax Math.functionName(parameters);
 In general, any algebraic expression has to be “flattened” in order to
be transformed to Java code; this may be a bit complicated. Proper
use of parentheses may be a good help in this
 Using white space and parentheses does not make your code less
efficient, but probably more readable!
Big Java Chapter 4
Calling Static Methods (chapter 4.5)




So far, we have divided methods into accessors and mutators
Accessors return some value from the object on which it is called
Mutators may change some value in the object on which it is called
However, there are methods which are neither…
 Some methods simply perform an operation using the parameters to
the method, and return some value based on these parameters
 Example: Math.pow(3,3) = 27
 Such a method does not really need to be called on a specific object,
since they do not use or change the state of an object
 Still, we would like to give such methods a “home” to live in, like a
class definition
 The solution is to declare such methods as being static
 A static method is declared just a any other method in a class, but we
use the keyword static to indicate that we do not need to create an
object in order to call the method
 Syntax for call: ClassName.methodName(parameters);
 Since we do not create an object on which the method is called, it
follows that static methods can not use any instance fields or any
ordinary methods from that class
 How can we tell if a method is being called on a class or an object?
 Class names should always start with a capital letter
 Object – or rather, variables that are object references – should
always start with a small letter
 Following this convention makes it easy to see if a method is called
on a class or an object
Big Java Chapter 4
Strings (chapter 4.6)
 String is a very common, built-in type, but it is not a primitive
type! It is a class!
 Variables of type String are thus (references to) objects
 What are string actually? A sequence of characters
 Strings are enclosed in quatation marks, like “Hello”
 The length of a string is simply the number of characters in the
string, not counting the quotation marks
 Example: String myName = “Per Laursen”;
 myName.length(); will return 11
 We often need to put strings together (concatenation) – this is very
conveniently done using the “+” operator
 Also very useful, we can add for instance a string and a number
using “+”, this will convert the number to a string
 Example: “H” + 4 + “ck” + 3 + “r” will equal “H4ck3r”
 Very useful if you want to put together some result or user input with
some supplementary text, like “You typed “ + input;
 The return type of such an expression is a String, so we can use this
an input to a method call, like
 System.out.println(“Your balance is“ + balance);
 We often need to convert a string – e.g. from user input – to a
numeric type
 To integer: int value = Integer.parseInt(input);
 To double: double value = Double.parseDouble(input);
 Note that if the string does not match the expected format for the
numeric type, an error will occur
Big Java Chapter 4
Strings (chapter 4.6)







The substring method returns a subset of a given string
Example: myString.substring(2,5);
First parameter: starting character
Last parameter: one beyond end character
Note that the count of characters start at zero!
Example String myName = “Per Laursen”;
myName.substring(3,7); returns “r La”




What if we actually want to print out a quotation mark?
We cannot define a string like “””
Here we need to use a so-called escape sequence
We can print out a special character using the “\” to indicate, that this
character is to be printed, not used as a “control character”
 Example: System.out.println(“\”Hi!\””); prints “Hi!”
 So how do we print a “\”? Need to prefix this with a “\” as well!
 Example: System.out.println(“C:\\Temp\\Download”);
prints “C:\Temp\Download”




We can also use escape sequences for some formatting of output
“\n” define a newline
“\t” defines a tabulation
The lazy solution instead of writing multiple calls to
System.out.println();
Big Java Chapter 4
Reading Input (chapter 4.7)
 Instead of having to write and compile programs over and over, in
order to use and test them with different input data, it is much more
convenient to obtain data when the program is running.
 Since System.out is used for writing to the output window, it would
seem logical to use System.in for getting input; however, that is not
the case
 In order to read keyboard input, a class called Scanner must be used
 The Scanner class is created using System.in as input parameter,
and has a number of methods for reading data from the keyboard
 Example: Scanner in = new Scanner(System.in);





With a Scanner object, we can use the below methods:
nextInt(): Reads an integer from the keyboard
nextDouble(): Reads a double from the keyboard
nextLine(): Reads a string from the keyboard
next(): Reads an string from the keyboard, but only so far as the
first white space (space, new line or tab)
 Note that the method will not actually complete until you have hit the
Enter key, which indicates that you have finished your input
 The input for e.g a double must match the expected format, otherwise
an error will occur
 With regards to formatting output, the formatting of doubles may
often be a bit troublesome
 Unless we specify otherwise, doubles will usually have many
decimals like 450.000000001
 Using the printf method can help in producing a proper formatting
of doubles, with the format specifiers available
 Check the printf method, plus tables 3 and 4 on page 168
Big Java Chapter 4
Using Dialog Boxes for Input and Output (adv topic 4.7)
 In a real-life Java program, we would probably not communicate
with the user using an output window; we would use a graphical user
interface (GUI)
 Development of GUI applications is a large subject on its own – for
now, we just look at ways to easily get input and present output using
some simple dialogs
 The JOptionPane class contains methods for this purpose:
 Input: JOptionPane.showInputDialog(String prompt); (this
method returns a string)
 Output: JOptionPane.showMessageDialog(null, String
message);
 Since both of these methods use strings, we can use all of the string
formatting methods we have already learned
 Is generally more convenient to use dialogs for input and output
 A single line of code should be added to the main method in your
program: System.exit(0);
 This is needed for more technical reasons…
 If you want to know more about using dialogs, there are many more
ways to create JOptionPane dialogs, see the documentation!
Big Java Chapter 4
Exercises
Chapter 4.1
(15 min)
Self-Check:
Review:
Programming:
2
4.4, 4.6, 4.9
--
Chapter 4.2
(15 min)
Self-Check:
Review:
Programming:
4, 5
4.14, 4.15
--
Chapter 4.3
(5 min)
Self-Check:
Review:
Programming:
7
---
Chapter 4.4
(45 min)
Self-Check:
Review:
Programming:
-4.7, 4.8, 4.10
4.4, 4.10
Chapter 4.5
(5 min)
Self-Check:
Review:
Programming:
11, 12
---
Chapter 4.6
(25 min)
Self-Check:
Review:
Programming:
13, 14
-4.17
Chapter 4.7
(20 min)
Self-Check:
Review:
Programming:
16
-4.14
Adv Topic 4.7
(25 min)
Self-Check:
Review:
Programming:
--4.4, 4.8, 4.14 (but use dialogs!)