Programming in Java CSCI2220 Object Oriented Programming OOP

Programming in Java CSCI-2220 Object Oriented Programming

OOP Model • Organization is centered around objects rather than actions • Central design of programs is based on how data is defined and how it can be manipulated rather than the sequential logic of the program • Java embraces this model as the core of its design

Classes • Everything in Java is a class (basically) • A class defines a new data type and all of the properties that an object of that type contains – Fields (data members, instance variables, …) – Methods (procedures to possibly manipulate the fields or provide some other functionality) • Each instance of a class has a copy of all non-static fields and methods defined for that class – Actually the method code is shared among all instances but conceptually this is not important • Only one copy of static fields and methods exists for each class

Revisiting static • static class members – can be accessed from outside of its class through the use of the class name – can be accessed from inside any member class method with or without the class name • static methods – Do not have access to non-static methods or fields (you will get a compiler error if you try this) – Makes sense since static members are not associated with any particular object and exist even before any object of the class is instantiated

Initializing data • Three ways to initialize class member variables – Right in the class body during variable declaration class My. Class { String my. Variable = “foo”; int a = 10; } – Initialization blocks (can also be static) class My. Class { int my. Array[]; { my. Array = new int[10]; for(int i = 0; my. Array. length < i++) my. Array[i] = i; } } – Constructors

Constructors • A constructor is a special method used to initialize class members with custom specified data during instantiation • Declared with no return type and a name which is the same as the class name class My. Class { My. Class(. . parameters. . ) { //initialize data here } } • If you do not create a constructor, Java automatically provides one that takes no arguments and does nothing • If you create any constructor at all (including one with arguments), the default constructor will not be created for you

Method Overloading • Methods with the same name in one class can be created as long as they have different parameters • You can overload constructors just as you can other methods • You can call one constructor from another constructor using the this keyword

Destructors • No such thing! • Java has a garbage collector that automatically cleans up objects that are no longer referenced in your program • Each class also has a finalize() method that is called when the object is garbage collected • You probably don’t want to do anything with it

Packages • Java has an additional level of support for organizing your classes called packages • You can put a class in a package by declaring the package at the type of the file package my. Package; class My. Class { My. Class(. . parameters. . ) { //initialize data here } } • Note: Java is strict with its file and directory naming conventions and organization. All classes that you put into a package must reside in a directory with that package name

Modifiers • Java has access attributes similar to C++ – No modifier • Can be accessed by any class in the same package – public • Accessible by anyone – private • Can be accessed by any methods within the class. Note that this includes a separate instantiation of the same class – protected • Can be accessed by any class in the same package and any subclass in any package

Inheritance • Sometimes when designing classes we run into the following relationship – Class 1 is a more specialized form of Class 2 • In this situation we do not want to duplicate all of the functionality and attributes in Class 1 • Instead we create Class 2 as a subclass of Class 1 • Class 2 inherits all of the fields and methods provided in Class 1 and can also define additional functionality for its specialized features

Inheritance • We declare a class as a subclass of another through the use of the extends keyword class Sub. Class extends Base. Class{ … } • A class can be a subclass of only one other class • All fields and methods of the base class are inherited by the subclass – Private data members of the base class do exist in the subclass but they are not accessible directly by any method of the subclass – Static data members of the base class are also inherited meaning that the sub class and base class share one copy of the static members

Subclass Constructors • Constructors of a subclass should always call one of the constructors of the base class first • This can be done with the super keyword class Sub. Class extends Base. Class{ Sub. Class() { super(. . arguments. . ); } } • If you do not call a constructor of the base class, Java will automatically call the default constructor of the base class at the beginning of your constructor • If the base class does not have a default constructor, this will generate an error

Method Overriding • You can override any method of the base class by declaring the method in your subclass with the same signature (same return type, method name, and parameter list) • If you have overridden a base class method and wish to access the base class version of it, you can again use the super keyword class Sub. Class extends Base. Class{ … public String base. Method() { return super. base. Method() + “n”; } }

The Object class • Every class in Java extends one and only one class (except for one) • If you don’t specify a base class, your class automatically extends the Object class – Every class in Java contains the basic functionality methods defined in the Object class – Refer to the Java API for a complete spec on the Object class • The net result of this design is that Java classes make up one giant hierarchy with the Object class at the top

Polymorphism • The power of OOP programming is realized through polymorphism • Say we wish to work with a list of user accounts in the RPI CS department • We have defined a class called User. Account with two subclasses – Student. User. Account – Professor. User. Account • Polymorphism allows us work with a list of User. Accounts without knowing or caring what type of accounts they are

Polymorphism • In Java we can assign a variable of a certain class type an instance of that particular class or an instance of any subclass of that class User. Account my. Account = new Student. User. Account(); • Now the my. Account variable looks like a User. Account object and can be treated exactly like one but under the hood it is actually a Student. User. Account object • We can typecast it back to a Student. User. Account type if we ever need the specialized functionality of the Student. User. Account class Student. User. Account my. Student. Account = (Student. User. Account)my. Account;

Dynamic Type Checking! • Java has support for dynamic type checking which is the true power of polymorphism • Example: – User. Account has a method named privileges() which returns a list of privileges associated with that account – Student. User. Account and Professor. User. Account each have overridden the privileges() method with their own specialized functionality – A User. Account variable instantiated with a Student. User. Account object calls the privileges() method – At run-time, Java checks the type of this object and sees that it is a Student. User. Account and therefore calls the Student. User. Account version of the privileges() method instead of the User. Account version

Abstract classes • You can declare a class abstract with the abstract keyword public abstract class Animal { public abstract void sound(); public Animal(String type) { this. type = type; } public String to. String() { return “This is a “ + type; } private String type; } • Abstract classes provide a prototype but not an implementation for some of its methods because the context of the implementation is only important in subclasses

Abstract classes • Are intended to be base classes • Cannot be instantiated • You can declare variables of an abstract class type but they can only be assigned instantiations of a subclass of the abstract class

Interfaces • Takes the abstraction one step further • Only defines a set of methods that represent the class interface but does not provide an implementation • Can also define constants public interface Shape { double PI = 3. 14; int Area(); String name(); } • All methods of an interface are automatically public and abstract so you do not need to explicitly specify this

Interfaces • Java provides support for pseudo-multiple-inheritance through the use of interfaces – Classes can extend one and only one class – However, classes can implement any number of interfaces public class Circle implements Shape { … } • A class that implements an interface must provide an implementation for each method defined in the interface • If a class implements more than one interface that have identical methods, one implementation of the method is sufficient as long as the return type is the same in both interfaces

Interfaces • Polymorphism can be used with interfaces too! • Example – From the previous slide we can create a variable of type Shape – We can then assign this variable an instantiation of the Circle class • Interfaces cannot be instantiated (clearly)

Factory Creation Pattern • Problem: – You want to write an application that supports the native look and feel of multiple GUI systems such as Windows and Mac – You don’t want to rewrite your code for each system • Solution: – Define a common interface for using either interfaces or abstract classes for each GUI element that you wish to use – Define a concrete subclass of each GUI element for each windowing system that you wish to support – Your application works directly with the abstract class interface and does not know or care what type of object it is using

Factory Creation Pattern Button Mac. Button Windows. Button Menu Mac. Menu Application works directly with the abstract classes Objects are instantiated using the concrete subclasses. Windows. Menu Question: How can we work only with the abstract classes if we must instantiate them using one of the concrete subclasses?

Answer: Factories public interface Widget. Factory { Button new. Button. Instance(); Menu new. Menu. Instance(); } public class Windows. Widget. Factory implements Widget. Factory { public Button new. Button. Instance() { return new Windows. Button(); } public Menu new. Menu. Instance() { return new Windows. Menu(); } } public class Mac. Widget. Factory implements Widget. Factory { public Button new. Button. Instance() { return new Mac. Button(); } public Menu new. Menu. Instance() { return new Mac. Menu(); } }

Factory Creation Pattern • Using the factories, you can instantiate your objects without even knowing which subclass of the abstract class you’re instantiating! public class Factory. Test { public static void main(String[] args) { Widget. Factory factory = new Windows. Widget. Factory(); //Widget. Factory factory = new Mac. Widget. Factory(); Button my. Button = factory. new. Button. Instance(); Menu my. Menu = factory. new. Menu. Instance(); } }

Homework 2 • Homework 2 is out and posted online • Due February 9 11: 55 PM • Don’t forget to submit HW 1 by tonight!