Download Review of Java Language and Object

Review of Java
• Basic Concepts
– Names and Reserved Words
– Expressions and Precedence of Operators
– Flow of Control – conditional statements
– Flow of Control – loops
– Arrays
• Reading: Your CS110 Text/Notes
1
Review of Java
• If you are not completely familiar with this
material, please see me. You should not
be taking this course!
• Don’t expect that you’ll catch up as we go
through the CS210 material. That is not
going to work!
2
Names and Reserved Words
• Names are used for classes and methods:
– Classes: Scanner, BingoBall
– Methods: next( ), hasNext( )
• Names are used for variables and constants
– Variables: i, j, current, currentValue, isOn
– Constants: SIZE, MAX_VALUE
• Reserved words are java language identifiers:
– Examples: class, return, public, static, int, boolean
3
Expressions and Precedence
There are three major groups of basic
operations in Java:
– Arithmetic (+, -, * , /, %, ++, --, ... )
– Comparison ( !=, ==, <=, => , < , ...)
– Logical ( ||, &&, !)
Arithmetic operators have the highest
precedence followed by comparison
operators. Logical operators have the least
precedence.
4
Expressions and Precedence
The precedence of operators determines the order
of evaluation for expressions. Here is the order
precedence of For arithmetic operations from
highest to lowest:
–
–
–
–
–
–
Highest: [ ], ( ), ++, -Next: +(unary), -(unary), ~, !
Next: new, (type)
Next: *, /, %
Next: +(binary), -(binary)
Etc.
5
Expressions and Precedence
An Expression is a construct made up of operators and
method invocations applied on variables and constants.
Each expression has a type.
Examples:
– x+y+3 (x and y are integer variables)
– z/3+y%2 (z is a double and y is an int)
– x<=z && ~(y > 2)
– obj.doIt()
6
Flow of Control - Selection
• If statements with optional else clauses:
if (boolean condition){
statement;
} else {
statement;
}
• Switch statements
switch (integer value) {
case FIRST_VALUE:
statements;
case SECOND_VALUE:
statements;
default:
statements;
7
Flow of Control - Repetition
• While
while (scan.hasNext()) {
statements; // repeated until false above
}
• For
for (int i = 0; i < MAX; i++) {
statements; // repeated until false above
}
• Do … while
do {
statements; // repeated until false below
8
} while (!done);
Arrays
• Arrays are a group of elements that can be
referenced via a name and an index value
• Declaring an array with or w/o initialization
int [] digits = new int [10];
OR
int [] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
• Setting the value of an element of an array
digits [0] = 0;
• Using the values of elements of an array
int sum = digits[2] + digits[4];
9
Review of Java
• Object Oriented Programming Concepts
– Objects and Classes
– Encapsulation, Constructors, and Methods
– References and Aliases
– Interfaces and Inheritance
– Class Hierarchies and Polymorphism
– Generic Types (ArrayList Class)
– Exceptions
• Reading: L&C Appendix B (3rd Ed.) or Chap.
2 (2nd ed.)
10
Data Types
• Java Primitive types: int, double, boolean,
char, byte, …
• Arrays (Array of ints, Array of boolean, …)
11
Data Types
• Java Primitive types: int, double, boolean,
char, byte, …
• Arrays (Array of ints, Array of boolean, …)
• To define more complex customized types,
we write our own classes which define the
type of the data objects (instances) of that
class.
• We define a class by using and combining
other types (primitive types, arrays and
12
other defined classes)
Objects and Classes
• Object and class relationship
• Class Definition
public class ClassName
{
// attributes <=== defines the state of
the objects of this type
(instances of the class)
// methods
}
<=== defines the behavior of the
objects
• Instantiating Objects using Classes
13
ClassName myClassName = new ClassName();
Class Definition
public class Car {
private int speed;
attributes or
private Engine engine;
variables
<== object
instance
public int getSpeed() {
return speed;
}
14
Encapsulation
• Encapsulation of Attributes
public class ClassName
{
// constants
public static final int MAX_SIZE = 20;
private static final int DEFAULT_SIZE = 10;
// class variables
private static int largestSizeOfAll;
// instance variables
private int mySize;
}
15
Constructors and Methods
• Constructor (ClassName with no return type)
public class ClassName
{
public ClassName (parameter list if any)
{
statements;
}
• Method (Method name with a return type)
public type methodName(parameter list if any)
{
statements;
}
}
16
Constructor
• A constructor is a special method that is
designed to create an object (initialize an
object).
• A constructor is different from a regular
method in three ways.
17
Using References
• Using a class constant
if (size <= ClassName.MAX_SIZE)
statement;
• Using a class method (static method)
type returnValue = ClassName.methodName(...);
• Using an instance method via a reference
type returnValue = myClassName.methodName(...);
18
Aliases and Garbage Collection
• Creating an alias of a reference
ClassName yourClassName = myClassName;
myClassName
Object of class
ClassName
yourClassName
• Making object eligible for garbage collection
myClassName = yourClassName = null;
myClassName
null
yourClassName
null
Object of class
ClassName
“Garbage”
19
Primitive/Non-primitive Types
int x;
x
x = 12;
x
String y;
0
12
y
null
String y = new String(“ABC”); y
y = null;
y
“ABC”
“ABC”
null
20
Method Overloading
public class Car {
....
public void drive() {
int temp = 12;
<------------- local attribute (scope?)
....
}
public void drive(int speed) {
....
}
}
------------------------------------------------------------------------------------Car ford = new Car(...);
21
ford.drive(110); this method call binds to ??? instance mthod
Static/non-static var
public class MyClass {
public class YourClass {
private int objAttr;
priavate static classAttr;
....
....
}
instance variable (object
attribute): one copy of attribute
for each Object of type
MyClass. Each object can
access and modify its own
copy. An object changing its
own attribute will not be seen
by other instances.
}
static variable (class variable):
there is only one copy of the
attribute
which is associated with the
class
itself. All Objects of type
YourClass
can access and modify this class
variable and changing
it in one
22
Static/non-static method
public class MyClass {
public class YourClass {
public static String yourMethod(int y) {
public String myMethod() {
....
....
}
}
instance method or object method
is associated with an object of
type MyCLass. To call the
method:
}
}
static method is associated with the class
itself. To call the method:
String y = YourClass.yourMethod(211);
MyClass mine= new MyClass(...);
String x = mine.myMethod();
23
Interface
• An interface is a collection of constants
and abstract methods.
• An abstract method has no code attached
to it. It is just composed of the method
header.
• A class implements an interface by
providing method implementation for each
of the abstract methods of the interface.
24
Interfaces
A class that implements an interface
public class ClassName implements InterfaceName
{
. . .
}
<<interface>>
InterfaceName
ClassName
Interface defines the
method signature for
all required methods
Class must define code
for all methods defined
in InterfaceName
25
Inheritance
• A class that extends another class
public class ClassName extends SuperClassName
{
. . .
}
SuperClassName
ClassName
SuperClass defines all the
methods for all SubClasses.
SubClass may define code
to override some or all of
the SuperClass methods
26
Inheritance
• All the public and protected methods of the
super-class are accessible by the
subclasses, but not the private ones.
• A subclass may have additional methods
and instance variables of its own.
• The super-class does not know anything
about its subclasses.
• A sub-class may override some or all of
the methods of the super-class. (Example)
27
class/interface/abstarct class
Difference between:
– class and abstract class?
– abstract class and interface?
28
Inheritance
• A class that extends an abstract class
public class ClassName extends SuperClassName
{
. . .
}
<<abstract>>
SuperClassName
ClassName
SuperClass defines some of the
methods for all SubClasses, but
only defines method signatures
for the rest of the methods
SubClass may define code to override
some or all of the SuperClass methods,
but must define code for the signatures
29
Class Hierarchies and Polymorphism
• An object reference variable may hold as a
reference to any compatible type of object
• Compatibility may be via implementing an
interface or inheritance from another class
ClassName a = new ClassName();
InterfaceName b = new ClassName();
SuperClassName c = new ClassName();
• Object behaves as class it was “born as”
(i.e. class used with the new operator)
30
Polymorphism via interface
interface Service
public int provide();
Class Service A
implements
Service
Class
public int
provide() {
Service
Clas A
…
}
Class Service B
implements Service
public int provide() {
…
}
Service[] services = new Service[2];
services[0] = new ServiceA(...);
services[1] = new ServiceB(...);
for(int i = 0; i < services.length; i++) {
services[i].provide();
}
31
Generic Types
• Collection classes like the ArrayList class
can be defined to hold a specific type of
object via a generic type designation <T>
ArrayList<String> myList = new ArrayList<String>();
• We will use generics often in CS210 with
many other types of “collection” classes
32
Exceptions
• When code encounters a situation that is
impossible for it to resolve at that point, it
may throw an Exception object, e.g.
NameOfException instead of executing its
normal return
• If a method may throw an exception, it
should indicate that in its method header
public void methodName() throws NameOfException
{
if (boolean condition of impossible situation)
33
throw new NameOfException();
Process the Exception
Three options to handle an Exception:
– Not handle it at all and let the program
terminate
– Handle the exception where it occurs
– Handle the exception at another point in the
program (for example the caller of the method
or caller of the caller of the method and ... )
34
Exception Handling
• Code that calls a method that may throw a checked
exception must use try-catch or indicate that it
throws that exception in its own method header
try
{
statements with call to methodName();
}
catch (NameOfException e) // may be multiple catch clauses
{
statements to recover from occurrence of exception
}
finally // optional finally clause
{
statements always performed, e.g. clean up actions
}
35
File Input: Example
import java.util.Scanner;
import java.io.*;
public class FileDisplay
{
public static void main (String [] args)
throws IOException
{
Scanner scan = new Scanner(System.in);
System.out.println("Enter name of file to display");
File file = new File(scan.nextLine());
Scanner fileScan = new Scanner (file);
while (fileScan.hasNext())
System.out.println(fileScan.nextLine());
}
}
36
File
Output:
Example
import java.util.Scanner;
import java.io.*;
public class FileWrite
{
public static void main (String [] args) throws IOException
{
// Get filename and instantiate File object as before
PrintStream out = new PrintStream(file);
while (scan.hasNext()) {
String line = scan.nextLine();
if (line.equals("END"))
// A sentinel String value
break;
else
out.println(line);
}
out.close();
}
}
37