OOP in Java - Discipline of Musichughm/oop/slides/JavaOOP_1_Starting.pdf · 2017-02-09 · OOP in...
Transcript of OOP in Java - Discipline of Musichughm/oop/slides/JavaOOP_1_Starting.pdf · 2017-02-09 · OOP in...
1
OOP in Java
2
Outline
1. Getting started, primitive data types and control structures 2. Classes and objects 3. Extending classes 4. Using some standard packages 5. OOP revisited
Parts 1 to 3 introduce and sketch out the ideas of OOP.
Part 5 deals with these ideas in closer detail.
3
Recommended text
⇒The Java Programming Language Third Edition by Arnold, Gosling and Holmes – Addison Wesley
⇒Gosling created the Java language ⇒In the spirit of C and C++ Programming Languages
4
What you need to know already
⇒What compiling and interpreting mean ⇒Some knowledge of C or Python
5
Getting started at home
⇒Just follow these steps – explanations later ⇒Look at java.sun.com for what is available ⇒Download and install the JDK – currently version 8 ⇒This will install software needed ⇒Create a directory where you will save your Java
programs – call the folder JavaProgs
6
Keeping Going
⇒Start vim or NotePad and enter the program on the next slide.
⇒Save it with the filename “First.java” – must be this name. Put quotes around it to make sure Notepad does not put .txt on the end.
⇒Note CAPITAL F. ⇒Save it in your JavaProgs folder:
7
The first program
public class First { public static void main(String[] args) { System.out.println(“Hugh Murrell”); System.out.println(“73156286554"); }
}
8
Then..
⇒In a terminal window, ⇒navigate to your JavaProgs folder ⇒Use cd to change directory.
9
Compile it
⇒The compiler is called javac, so type in: javac First.java
⇒Then run it like this:
⇒ java First
10
Explanations..
⇒All Java source code files are called Something.java
⇒You give this to the javac compiler ⇒This produces a file called Something.class ⇒This is in bytecode ⇒This can be interpreted by the java interpreter
11
More explanations
⇒Each source code file defines a class ⇒The name of the class it defines (First in our case)
must match the filename – hence First.java ⇒This is compiled to a bytecode file named First.class ⇒Java is case-sensitive (like C) ⇒Classes should start with a capital letter. ⇒So the file must be called First.java and not
first.java
12
Practical Exercise⇒In your prac session on Friday you will have to, ⇒type in, compile and run a HelloWorld.java program that prints
your name and student number. ⇒and then adapt your program to solve the Whiskey problem.
⇒see website for details.
13
Features of Java ⇒Java is a general purpose high level language ⇒Core Java is well-defined and stable ⇒Versions are useful in many situations – desktop, server,
embedded, mobile etc ⇒Java is a trademark of Sun Microsystems ⇒Java is cross -platform
14
More features
⇒Java is a pure object-oriented language. ⇒No functions, no global variables ⇒Unlike C++, which is C with objects ⇒Java is designed to make it hard to write programs
which will crash ⇒No pointers ⇒Strongly typed, Compiler will not compile doubtful code ⇒Programmer must write code that ‘catches exceptions’ ⇒Run-time checks eg array bounds exceptions ⇒Slower than C or C++ (not much), but less chance of
crash
15
Types
⇒Recall data type from C – int, char double etc ⇒Java has 2 kinds of types:
Primitive types Reference types
16
Primitive types
⇒These are simple types like char, double, int ⇒Similar to C ⇒Main difference – the sizes of these types are
defined eg an int is 4 bytes ⇒Each hardware platform has its own 'virtual machine' ⇒Which all look the same ⇒So primitive types can all have the same data sizes ⇒All chars use UNICODE character set - so
characters are 2 bytes long
17
Reference types
⇒Reference type variables are objects ⇒Objects belong to classes ⇒Objects made by a constructor
18
Primitive types first
⇒We will look at primitive types first ⇒and control structures (loops and ifs) ⇒Then look at classes and objects
19
Program format
public class Testing { public static void main(String[] args) { // find the area of a circle.. double radius = 5.0; double area; area = 3.1416 * radius * radius; System.out.println("Area = " + area); } }
Use this format to start with In file Testing.java Code goes here Explain rest later
20
Variables - declaring and assigning
⇒// starts a line comment ⇒double area declares a variable called area of type double ⇒double radius = 5.0; declares and initializes a variable ⇒variables can be declared anywhere in a block { } ⇒statements end in ; like C and C++
public class Testing { public static void main(String[] args) { // find the area of a circle.. double radius = 5.0; double area; area = 3.1416 * radius * radius; System.out.println("Area = " + area); } }
21
Console output
⇒System.out.println("Area = " + area); ⇒This takes a single string argument – but.. ⇒The + causes area to be converted to the
equivalent string, and ⇒concatenated with the left hand operand ⇒so we get ⇒ "Area = 5.72" or whatever ⇒System.out.print stays on same line
22
Primitive data types - numericName Range Sizebyte -27 to 27-1 (-128 to +127) 8 bits
short -215 to 215-1 ( ± 32 000 ) 16 bits
int -231 to 231-1 ( ± 2 500 million ) 32 bits
long -263 to 263-1 (very big!!) 64 bits
float about ±1038, 6/7 sig digits 32 bits
double ±10308, 14/15 sig digits 64 bits
Java data type sizes are platform independent
All are signed
Top four are integer, bottom two are floating point
Variables of these types declared like
short a,b,c; or initialised when declared
double x = 1.502;
23
Numeric data types⇒Can get overflow eg
– int i = 64000; – int n = i * i ;
⇒Specify type of constant like – x = 1000L; // defaults to integer – f = 1.0F; // force float - defaults to double – x = 0x1FF; // hex
⇒Operators + - * / ⇒% is mod = remainder eg 13 % 4 is 1 ⇒Short cut – same as C
+= x+=8; same as x = x + 8; -= x-=8; same as x = x - 8; *= x*=8; same as x = x * 8; /= x/=8; same as x = x / 8; %= x%=8; same as x = x % 8;
24
Overflow Exercise
⇒Use code to produce overflow as in the previous slide
⇒Find out what happens when you compile/run it.
25
Two types of division
⇒float f = 1.0 / 2.0; // floating point ⇒ int i = 1 / 2; // i is 0 ⇒ if both operands are integer, / is integer version - it
gives the quotient and discards the remainder ⇒So / is overloaded – different versions, same name
26
Increment and decrement
⇒x++; is the same as x = x + 1; ⇒y--; is the same as y = y - 1; ⇒post-increment is like a = b++;
which first assigns b to athen increments b
⇒pre-increment isa = ++b;which first increments b then assigns the new value to a
27
Type casts⇒Assigning a small type to a larger type is no problem eg ⇒ int i; long x; i = 32; x = i; OK because x more bits than i ⇒But reverse gives ‘possible loss of precision’ eg ⇒ int i; long x; x = 32; i = x; // gives compile error ⇒Problem solved by a type cast ie i = (int) x;
28
Type cast exercise
⇒Try out ⇒ int i; long x; x = 32; i = x; In a program. ⇒Fix it as in the previous slide
29
Char type
⇒ char is for a single character, like ⇒ char c = ‘A’; note single quotes ⇒ c++; makes c = ‘B’ ⇒ Strings are different - see later ⇒ Java uses Unicode not ASCII - 16 bits per character.
30
boolean type
⇒If a variable is declared to be boolean, it is restricted to 2 values - true and false
⇒boolean result; result = true; ⇒result = ( x > y );
result is true if x is greater than y ⇒also < <= >= == != == not the same as = ⇒&& and || or ! not ⇒result = ( x > y ) && ( y < 5 );
result is true if x is greater than y and y is less than 5 ⇒&& and || are short-cut operators
31
bitwise operators
⇒& is bitwise AND (like both) | is bitwise OR (like either ) ^ is XOR (like not equal) ~ is NOT ⇒eg if x = 9 1001 ⇒and y = 10 1010 ⇒x & y is 8 1000 ⇒x | y is 11 1011 ⇒x ^ y is 3 0011 ⇒~ 0xFFFFFFFE is 1 inverting 11111111110
32
bit shift operators
⇒ >> is shift right eg if x = 7 or in binary 0000 0111x >> 1 is 0000 0011
⇒ << is shift left so x << 1 is 0000 1110 = 14
33
Bit shift exercise
⇒Try out this code: int i = 6; System.out.println(i&1); i>>=1; System.out.println(i&1); i>>=1; System.out.println(i&1); ⇒Explain what you get
34
precedence⇒2 * 3 + 4 is 10 not 14 ⇒2*(3+4) is 14 ⇒Highest ++ -- * / % + - < <= > >= == != && || ⇒Lowest = += -= *= /= %= ⇒Use brackets when in doubt
35
Control - if⇒ for example
if ( x== 5 ) { y = 2; a++; } else c++;
⇒ round brackets around boolean expression ⇒ indentation ⇒ no then as in Visual Basic ⇒ block { } around several steps to do ⇒ no block if just one step -
if (x<4) a=4;
⇒ else can be omitted if not needed
36
if example - validation
⇒for exampleif ( ( age>0 ) && ( age < 130 ) ) System.out.println(‘age is valid’);else { System.out.println(‘age is invalid’); .. code to deal with error .. }
⇒beware ofif ( x==5 ); y = 2;
37
switch - I⇒ used where many alternative actions are possible ⇒ example -
switch (y) { case 5: a = 7; case 9: b = 3; case 4: a = 8; default: z = 2; }
⇒ y can be expression (like x + 4) but must be integral ⇒ the 5, 9, 4 etc must be constants ⇒ default is optional
38
switch - II⇒ the action ‘falls through’ - when one case is triggered, all the
following options execute to the end of the switch ⇒ so often combine with break - example -
switch (y) { case 5: a = 7; break; case 9: b = 3; break; case 4: a = 8; break; }
⇒ include final break - not essential but good practice, since if add further option do not need to go back and add break to previous
39
Conditional operator ? ;⇒example
x = ( y > 4 ) ? 7 : 3;if y is greater than 4, x becomes 7, and otherwise, it becomes 3
⇒ in general a ? b : c b is evaluated if a is true, c if it is not
⇒exampleint x =9, y = 10 , a;
a = (x > 9) ? x++ : y++ ; ⇒after this a = 10, y is 11, x is still 9
40
loops - while⇒ loops repeat blocks of code - called iteration ⇒ example - output the numbers 3, 6, 9, ... 99
x = 3; while ( x<102 ) { System.out.println( x ); x += 3; } ⇒ in general,
while (boolean expression) statement or block to repeat
⇒ need to initialise variables ⇒ may loop zero times if false first time ⇒ use indentation
41
loops - do while⇒ example - output the numbers 3, 6, 9, ... 99
x = 3; do { System.out.println( x ); x += 3; } while ( x<102 )
⇒ in general, do statement or block to repeat while (boolean expression)
⇒ unlike a while, it will execute the loop at least once
42
loops - for⇒ example - output the numbers 3, 6, 9, ... 99
for ( x = 3; x<102; x+=3 ) System.out.println(x); ⇒ in general
for ( <initialisation> ; <loop while true>; <change every time> ) < statement or block to repeat >
⇒ may loop zero times ⇒ add up the integers 1 + 2 + 3 + ...100
int t = 0; int x; for ( x = 1; x<101; x++) t += x; System.out.println( t );
43
loops - for - II
⇒ can use statement list, like int t; int x; for ( x = 1, t = 0; x<101; x++) t+=x; System.out.println(t); ⇒ can omit any part, (retain separating ; ) like int t = 0; int x = 1; for ( ; x<101; x++) t+=x; System.out.println(t); ⇒ for (; ; ) loops forever
44
⇒ can declare variable in for, like int t = 0; for ( int x = 1; x<101; x++) t+=x; System.out.println(t); in this case the scope of the variable is limited to the for
statement
loops - for - III
do not do this -
for ( int x = 1; x<101; x++); t+=x;
45
Arrays - I
⇒An array is a set of boxes (elements) each labelled with a number (index)
⇒Arrays are declared and created as int [ ] numbers = new int [ 100 ];which makes an array of 100 integers called numbers
⇒or do it in 2 stepsint [ ] numbers; //declare it numbers = new int [ 100 ]; // create it
⇒or initialise it int [ ] numbers = { 4, 2, 1, 3, 5 };
⇒can have arrays of anything
46
Arrays - II
⇒Array elements referred to likenumbers [4] = 18;
⇒Multi-dimensional arrays created and used likeint [ ] [ ] table = new int [5] [10];
table[3][4]=7; ⇒Array element numbering starts at 0 ⇒so
int [ ] numbers = new int [ 100 ];creates 100 elements, from numbers[0] to numbers[99]
⇒array bounds are checked at compile time and run time
47
Arra
ys -
sorti
ng int [ ] numbers = new int [5]; //.. put some numbers in the array, then...sort them
// a bubble sort.. for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 4-i; j++ ) if ( numbers[ j ] > numbers[ j+1] ) { // swap them int temp; temp = numbers[ j ]; numbers[ j ] = numbers[ j+1 ]; numbers[ j+1 ] = temp; };
48
Array exercise
⇒Declare an array of 10 doubles ⇒Fill the array with random numbers (use
Math.random(); ) ⇒Print them out ⇒Sort them ⇒Print them out