Overview of Java (continue)
Announcements
You should have access to your repositories and HW0 If you have problems getting HW0, let me know
If you’ve added this class on or after Jan 26, you need to contact me so that I set up your repository
Always check the Announcements page! 2Spring 15 CSCI 2600, A Milanova
Outline
Overview of Java, continued Last time we covered
Model for variables Type safety Compilation vs. interpretation
This lecture A bit more on type safety Reflection Subtype polymorphism; classes and interfaces
Spring 15 CSCI 2600, A Milanova 3
A Bit More on Type Safety
Type safety: no operation is ever applied on an object that does not support the operation E.g., a+b where a and b are 2DPoints will be
rejected as + cannot be applied on 2DPoints E.g., a.substring(0,10) cannot be applied if
a is an int Type safety prevents runtime errors --- if an
operation is applied on an object of the wrong type, this almost certainly leads to errors!
Spring 15 CSCI 2600, A Milanova 4
Type Safety
Java ensures type safety with a combination of compile-time (static) and runtime checks Compiler checks and rejects a large number of
programs. E.g., String s = 1 is rejected, String s = new Integer(1) is rejected
Some checks are left for runtime. Can you think of a reason why? E.g., at B b = (B) x; the Java runtime checks if x refers to a B, and throws an Exception if it doesn’t
Spring 15 CSCI 2600, A Milanova 5
Type Safety and Exceptions
Exceptions are good! They prevent application of operations on the wrong type
Object x = new A();B q = (B) x; // ClassCastException // because A is not a Bint case2 = q.foo(1);
The exception prevents execution from reaching q.foo(1) and applying foo(1) on an object (A) that does not have a foo(int)
6
Type Safety
Java is type safe while C++ is type unsafe Java forbids a larger set of errors
E.g., in Java, a[i] will throw an Exception if i is out of the bounds of array a . In C++, a[i] can access arbitrary memory, which can lead to insidious errors!
Thus, it is easier to write correct programs in Java, because the language itself prevent so many errors
7
Reflection
Roughly, the ability of the program to execute code synthesized at runtime. Also, the ability to query metadata about classes
E.g., in JavaScript: eval(string) executes string. string can be arbitrary code synthesized at runtime
Java supports reflection. C++ does not 8
Reflective Object Creation
Standard way to instantiate an object: new Another way: reflective object creation:// First, translate the String argument (the first command-line
// argument in this case) into a Class object:
Class cl = Class.forName(args[0]);
// Next, instantiate the class:
Set s = (Set) cl.newInstance(); The class of the object created here is not known until
runtime! We can specify a java.util.HashSet or a java.util.TreeSet or other at the command line
9
Reflection
Reflection is a very powerful technique Sometimes, we do need to use classes unknown
at compile time Important design patterns use reflection. More on
this later in our class Disadvantages
Awkward code Slows program Prevents optimizations
Spring 15 CSCI 2600, A Milanova 10
Reflection
Avoid using reflection If you have to use, use only object creation, and
access the object through an interface, as shown here:// Translate the string into a Class object:
Class cl = Class.forName(str);
// Instantiate the class:
Set s = (Set) cl.newInstance();
// Access the Set through its interface methods
s.add(something)
// Set is an Interface defined in the Java library
11
Classes and Inheritance
Base class and derived class E.g., in C++: class queue : public list queue is the derived class, list is the base class
In Java: class queue extends list
In Java we say superclass and subclass Other terms are parent class and child class By deriving new classes programmer forms class
hierarchies
12
13
Subtype Polymorphism
Subtyping and subtype polymorphism – the ability to use a subclass where a superclass is expected Thus, dynamic method binding Advantages? Disadvantages?
In C++ static binding is default, dynamic binding is specified with keyword virtual
In Java dynamic binding is default, static binding is specified with final
14
Example: Application Draws Shapes on Screen
abstract class Shape { public void draw(); }
class Circle extends Shape { … }
class Square extends Shape { … }
void DrawAll(Shape[] list) {
for (int i=0; i < list.length; i++) {
Shape s = list[i];
s.draw();
}
}
Dynamic dispatch:Call s.draw() resolves at runtime.It can resolve to Circle.draw() or toSquare.draw() depending on what object s refers to. In the static context, we only know of Shape.
Dynamic Method Binding
Dynamic method binding (dynamic dispatch) is the ability to invoke a new, refined method, in a context, where an earlier version is expected
Example on previous slide: s.draw() binds dynamically (i.e., at runtime) to one of Circle.draw() or Square.draw()
Spring 15 CSCI 2600, A Milanova 15
Subtype Polymorphism
Polymorphism is an important concept in programming languages and software Polymorphism means “many forms”
Example on slide 14. DrawAll is polymorphic because it works with many concrete types, Circle, Square, Triangle It’s subtype polymorphism because these
concrete types are related: they are all “subtypes” of Shape
16
Benefits of Subtype Polymorphism
Enables extensibility and reuse! In our example, we can extend the Shape hierarchy
without modifying DrawAll We can reuse Shape and DrawAll Subtype polymorphism enables the
Open/closed principle (credited to Bertrand Meyer)
Software entities (classes, modules) should be open for extension but closed for modification
In other words, it’s easy to extend the code with additional functionality
17Spring 15 CSCI 2600, A Milanova
18
Benefits of Subtype Polymorphism
abstract class Shape { public void draw(); }
class Circle extends Shape { … }
class Square extends Shape { … }
class Triangle extends Shape { … }
Makes it very easy to extend with a Triangle!
The Java code requires no changes in DrawAll!
It would have been very hard to extend analogous C code!Spring 15 CSCI 2600, A Milanova
“Science” of software design teaches Design Patterns. A lot on Design patterns later in our class
Design patterns promote design for extensibility and reuse. Maintainable software
Nearly all design patterns make use of subtype polymorphism!
Spring 15 CSCI 2600, A Milanova 19
Benefits of Subtype Polymorphism
20
Some Differences C++ vs. Java
Access control modifiers – public, private, and others What portion of the class is visible to users ? Public, protected or private visibility Java: Has package is default; protected is slightly different from C++ C++: Has friend classes and functions
Visibility of superclass members C++: a subclass can restrict visibility of superclass members Java: a subclass can neither increase nor restrict visibility of
superclass members Inheritance
C++ allows for multiple inheritance Java allows single class inheritance & multiple interface “inheritance”
E.g., class B extends A implements I, J, K…
Spring 15 CSCI 2600, A Milanova
Subclassing in Java
Subtype polymorphism is achieved by subclassing There is a subtle difference between subtyping and
subclassing. More on this later! Typical subclassing in good Java code:
Subclass an abstract class In our example, Shape is abstract, Circle and Square are
concrete subclasses Implement an interface
Shape is an interface and Circle and Square implement the interface (next slide)
21
22
An Interface
interface Shape { public void draw(); }
class Circle implements Shape {
// must implement void draw()
public void draw() { … }
… // other methods
}
class Square implements Shape {
public void draw() { … }
… // other methods
}Spring 15 CSCI 2600, A Milanova
Subclassing in Java
Rarely we subclass a concrete class. Subtle issues arise
In homework 0, we had the choice to inherit BallContainer (reuse through inheritance), or to include BallContainer (reuse through composition)
Composition is almost always the better choice!
Spring 15 CSCI 2600, A Milanova 23
Abstract Classes vs. Interfaces in Java
Two mechanisms to define abstract supertypes Abstract classes and Interfaces
Abstract class Can contain implementation for some methods Has at least one empty method A good choice when the concrete subclasses
share implementation
24Spring 15 CSCI 2600, A Milanova
Abstract Classes vs. Interfaces in Java
Interface Cannot contain any implementation, just signatures! E.g., MapEntry from the Java library:
interface MapEntry<K,V> {
boolean equals(Object o);
K getKey();
V getValue();
int hashCode();
V setValue(V value);
}
25Spring 15 CSCI 2600, A Milanova
This is a generic interface, K and V aretype parameters. (Like C++ templates)There is no implementation, all methods are just signatures.
Abstract Classes vs. Interfaces
public abstract class AbstractMapEntry<K,V>
implements Map.Entry<K,V> {
public abstract K getKey();
public abstract V getValue();
// Implements Map.Entry.equals
@Override
public boolean equals(Object o) {
if (o == this) // much more here…
}
…26
On Tuesday
Reasoning about code and Hoare Logic
Spring 15 CSCI 2600, A Milanova 27