Title: CS441 CURRENT TOPICS IN PROGRAMMING LANGUAGES
1CS441CURRENT TOPICS IN PROGRAMMING LANGUAGES
- LECTURE 1
- GEORGE KOUTSOGIANNAKIS
- George Koutsogiannakis / Summer 2011
2Course Objective
- Practice building reliable GUI (Graphical User
Interface) using Java. - Create Client Server architectures
- Networking protocols.
- Design of Internet Client Server enterprises
(applications). - Java will be used to build Client/Server
architectures. Other platforms follow similar
approaches to Java.
3Course Material
- THE PRESENTATIONS PROVIDE A LIST OF TOPICS
DISCUSSED IN CLASS ON THE DAY OF THE LECTURE. - A SORT DISCUSSION IS PRESENTED IN THE POWER POINT
PRESENTATION. - YOU MUST EITHER KEEP NOTES IN THE LIVE CLASS OR,
IF YOU ARE A REMOTE STUDENT, WATCH THE TAPE FOR
THE COMPLETE COVERAGE OF THE TOPICS. - IN ADDITION YOU CAN DOWNLOAD THE POWER POINT
PRESENTATIONS FROM THE COURSE S WEB SITE - http//www.cs.iit.edu/cs441/schedule.html
4Course Material
- THIS SUMMARY DOES NOT NECESSARILLY LIMIT THE
TOPICS DISCUSSED IN CLASS. TOPICS NOT LISTED HERE
CAN BE DISCUSSED (FOR INSTANCE SAMPLE COD
EWRITTEN ON THE WHITE BOARD). IT ONLY SERVES AS
A GUIDELINE!. - PROGRAMMING EXAMPLES ARE GIVEN FOR SOME TOPICS IN
- http//www.cs.iit.edu/cs441/handoutsnew.htm
l - SUPPLEMENT YOUR UNDERSTANDING OF THE MATERIAL BY
ALSO READING THE RECOMMENDED CHAPTERS FROM THE
ASSIGNED TEXTS, NOTED ON THE SCHEDULE PAGE OF THE
COURSES WEB SITE.
5COURSE ADMINISTRATION
- TOPICS DISCUSSED
- COURSE WEB SITE
http//www.cs.iit.edu/cs441 - USAGE OF BLACKBOARD
- TOOLS NEEDED FOR THE COURSE http//www.cs.iit.edu
/cs441/tools.html - OFFICE HOURS
- ASSIGNMENTS / PROJECT.
- COURSE SYLLABUS
- THIS IS AN INTERMEDIATE TO ADVANCE LEVEL COURSE
IN JAVA. BASIC KNOWLEDGE OF JAVA IS ASSUMED. MUST
KNOW HOW TO COMPILE AND INTERPRET. MUST KNOW HOW
TO USE NUMEROUS FILES TOGETHER.
6COURSE ADMINISTRATION
- REVIEW OF COURSE S WEB SITE
- COURSE GRADING
- COURSE ASSIGNMENTS
- DOWNLOADING OF ASSIGNMENTS
- DEADLINES FOR ASSIGNMENT
- TOOLS REQUIRED
- OTHER
- METHOD OF ASSIGNMENTS SUBMISSION.
- BLACKBOARD S INDIVIDUAL ASSIGNMENT FOLDERS- DO
NOT SUBMIT TO DIGITAL DROP BOX!!!! - ETHICS
7JAVA FRAMEWORKS AND ACCEPTABLE PLATFORMS
- DISCUSSION OF VARIOUS JAVA FRAMEWORKS AVAILABLE
AND THEIR FUNCTIONALITY - JDK1.6 STANDARD EDITION UPDATE 23 or latest
update. RECOMMEND THAT YOU DOWNLOAD AND INSTALL
ON YOUR COMPUTER. EARLIER VERSIONS ARE
ACCEPTABLE. - JAVA ENTERPRISE EDITION 6 (EE 6) . INCLUDES A
JDK PLUS OTHER APIs. - WINDOWS ENVIRONMENT IS THE PREFERRED ENVIRONMENT
FOR ASSIGNMENTS AND PROJECTS. I WILL BE CHECKING
YOUR WORK USING WINDOWS. - If another environment is used you can demo your
assignment to me on your laptop.
8JAVA FRAMEWORKS AND ACCEPTABLE PLATFORMS
- DURING THE FIRST PART OF THE COURSE EDIT PLUS IS
THE PREFERRED IDE FOR WRITNG PROGRAMS. DO NOT USE
NetBeans IN THE FIRST HAL F OF THE COURS
EASSIGNMENTS UNLESS THE ASSIGNMENT SPECIFICALLY
SAYS SO. - YOU CAN USE OTHER JAVA FRIENDLY IDEs AS LONG AS
THEY DONT USE THEIR OWN JDK. - YOU MUST INSTALL A VERSION OF THE JDK AND LINK
YOUR IDE TO THAT INSTALLATION. - DO NOT USE ECLIPSE AS IT USES ITS OWN JDK. IF
YORU PROGRAM DOES NOT WORK BECAUSE YOU USED
ECLIPSE TIME WILL BE WAISTED DEBUGGING IT (IT
WILL BE RETURNE DTO YOU). - PREFERRED DATABASES MySQL / ACCESS/DERBY
- WEB SERVER TOMCAT VERSION 6.0 AND UP
- NET BEANS 6.5 AND UP (LATEST VERSION IS 6.9) .
NOTE THAT EACH VERSION HA SITS OWN ISSUES AND
PROBLEMS.
9JAVA PROGRAMS
- DIVISION OF JAVA PROGRAMS
- APPLICATIONS.
- APPLETS.
- SERVER SIDE JAVA- SERVLETS, JAVA SERVER PAGES,
JAVA SERVER FACES. - ENTERPRISE JAVA BEANS
- WEB SERVICES
- DISTRIBUTED SERVICES USING RMI OR RMI OVER IIOP
(OR JAVA IDL). - SOME PROGRAMS REQUIRE SPECIAL TOOLS NOT AVAILABLE
IN THE STANDARD EDITION JDK (AVAILABLE IN
ENTERPRISE EDITION) - SERVLETS AND JAVA SERVER PAGES
- WEB SERVICES
- ENTERPRISE JAVA BEANS
10APPLETS AND BROWSERS
- BROWSERS AND WEB SERVERS (SERVER / CLIENT )
- APPLETS AND THE BROWSER.
- APPLETS AND SECURITY.
- BROWSER ACTS AS A SANDBOX.
- WEB SERVER AND APPLETS.
- WEB SERVER AND SERVLETS.
- WEB SERVER AND JAVA SERVER PAGES.
11Applets
SERVER SIDE
CLIENT SIDE
Internet
1
myApplet.html
1
1
Web Server
Browser
myApplet.class
2
2
2
- 1 Http request/response for html file//file is
sent to Browser - Browser interprets the html script
- 2 Http request/response for file
myApplet.class// file is sent to Browser - Browser interprets java bytecodes
- File is destroyed when Browser is closed.
12Servelts
Java Client Application
Servlet executes on the server side
Internet
1
myServelt.class
1
1
Web Server
myJavaApplication.class
4
3
2
3
- 1 Http request sent to Web Server for servelt
file execution - 2 Servelet executes on the Server side and
returns response to Web Server - 3 Http response formed by the Web Server based
on the response from Servlet - Http response is sent to Client
Application - 4 Http response passes contents to input
stream of the client application
(myJavaApplication.class)
13Java Server Pages
- 1 Http request sent to Web Server for jsp file
execution - 2 java code of jsp executes on the Server
side initially - 3 Http response formed by the Web Server based
on the response from jsp. The java part of jsp
is converted to a Servlet - Http response is sent to Client
Application - 4 Http response passes contents to input
stream of the client application
(myJavaApplication.class). The browser interprets
the particular format sent (html, XML etc.).
14Other communication forms
- html -gt applet -gt servlet
- Client (Browser or some Java application
program) interprets html which calls an applet
from the server. - Applet bytecodes are interpreted by the browser
(or java application program). Applet calls back
to the server for the execution of a servlet. - Server executes the servlet.
- The response of the servlet is sent back to the
browser 9or java application program) in some
format (like html). - Browser (or java application program) interprets
response.
15Other communication forms
- html-gt servlet-gt applet
- In this example of different modules
communicating with each other, first the html
code interpreted by the client (Browser or a Java
application program) calls for a servlet to be
executed by the server. - The server executes the servlet and sends the
http response to the client. - The client interprets the response and as a
result a call to an applet is made (to the
server). - The server sends the applet to the client.
- The client interprets the applet code.
16Other communication forms
- In this course we will examine some of the
previous communication architectures as well as
more complicated architectures on the server side
i.e. - The servlet could be calling another server
called a RMI server which in turn queries a data
base. - Or, the servlet calls a session Enterprise Java
Bean which in turn calls an Entity bean which in
turn queries a database.
17INHERITANCE REVIEW
- JAVA DOES NOT SUPPORT MULTIPLE INHERITANCE
- SINGLE INHERITANCE IS APPLIED IN JAVA VIA KEYWORD
extends - MULTIPLE INHERITANCE CAN BE SIMULATED BY USING
INTERFACES
18A Sample Vehicle Hierarchy
- This hierarchy is depicted using a Unified
Modeling Language (UML) diagram. - In UML diagrams, arrows point from the subclass
to the superclass.
19Superclasses and Subclasses
- A big advantage of inheritance is that we can
write code that is common to multiple classes
once and reuse it in subclasses - A subclass can define new methods and instance
variables, some of which may override (hide)
those of a superclass
20Inheritance Rules
Superclass Members Inherited by subclass? Directly Accessible by Subclass? Directly Accessible by Client of Subclass?
public fields yes yes, by using field name yes
public methods yes yes, by calling method from subclass methods yes
protected fields yes yes, by using field name no, must call accessors and mutators
protected methods yes yes, by calling method from subclass methods no
private fields no no, must call accessors and mutators no, must call accessors and mutators
private methods no no no
21Inheritance Rules for Constructors
Superclass Members Inherited by subclass? Directly Accessible by Subclass? Directly Accessible by Client of Subclass Using a Subclass Reference?
constructors no yes, using super( arg list ) in a subclass constructor no
22Subclass Constructors
- Constructors are not inherited.
- However, the subclass can call the constructors
of the super class to initialize inherited
fields. - Implicit invocation
- The default constructor of the subclass
automatically calls the default constructor of
the superclass. - For explicit invocation, use this syntax
- super( argument list )
- If used, this statement must be the first
statement in the subclass constructor.
23Multiple Inheritance
- The concept of multiple inheritance is shown
below (even though Java does not allow it).
Class A
Class B
Class C
Class D
24abstract Classes and Methods
- An abstract class is a class that is not
completely implemented. - Usually, the abstract class contains at least one
abstract method. - An abstract method specifies an API but does not
provide an implementation. - The abstract method is used as a pattern for a
method the subclasses should implement.
25More on abstract Classes
- An object reference to an abstract class can be
declared. - We use this capability in polymorphism, which
will be discussed later. - An abstract class cannot be used to instantiate
objects (because the class is not complete). - An abstract class can be extended.
- subclasses can complete the implementation and
objects of those subclasses can be instantiated
26Defining an abstract class
- To declare a class as abstract, include the
abstract keyword in the class header - accessModifier abstract class ClassName
-
- // class body
-
27Example Hierarchy
- We can define a Figurehierarchy.
- The superclass is Figure,which is abstract. (In
theUML diagram, Figure is set in italics to
indicate that it is abstract.) - We will derive two subclasses Circle andSquare.
28Subclasses of abstract Classes
- A subclass of an abstract class can implement
all, some, or none of the abstract methods. - If the subclass does not implement all of the
abstract methods, it must also be declared as
abstract. - Our Circle subclass adds a radius instance
variable and implements the draw method. - Our Square subclass adds a length instance
variable and implements the draw method.
29Restrictions for Defining abstract Classes
- Classes must be declared abstract if the class
contains any abstract methods - abstract classes can be extended
- An object reference to an abstract class can be
declared - abstract classes cannot be used to instantiate
objects
30Restrictions for Defining abstract Methods
- abstract methods can be declared only within an
abstract class - An abstract method must consist of a method
header followed by a semicolon - abstract methods cannot be called
- abstract methods cannot be declared as private or
static - A constructor cannot be declared abstract
31The Figure Class
- public abstract class Figure
-
- private int x
- private int y
- private Color color
- // usual constructors, accessors,
- // and mutators
-
- // abstract draw method
- public abstract void draw( Graphics g )
-
- All classes in the hierarchy will have an (x, y)
coordinate and color. Subclasses will implement
the draw method.
32Polymorphism
- An important concept in inheritance is that an
object of a subclass is also an object of any of
its super classes. - That concept is the basis for an important OOP
feature, called polymorphism. - Polymorphism simplifies the processing of various
objects in the same class hierarchy because we
can use the same method call for any object in
the hierarchy using a super class object
reference.
33Polymorphism Conditions
- conditions for polymorphism
- The Figure, Circle, and Square classes are in the
same hierarchy. - The non-abstract Circle and Square classes
implement the draw method. - We assigned the Circle and Square objects to
Figure references. - We called the draw method using Figure references.
34Example
- Suppose we have a class FigureClient.
- This class uses the previous classes to actually
draw figures. - i.e. (assuming that all classes are in the same
folder) - public class FigureClient
-
- public static void main ( String rags)
-
- Circle circlenew Circle()
- Square squarenew Square()
- Figure figure //just declaration, no
instantiation is allowed - figurecircle
- figure.draw() // a circle will be drawn
- figuresquare
- figure.draw() // a square will be drawn
now. -
35Superclasses and Subclasses
- A big advantage of inheritance is that we can
write code that is common to multiple classes
once and reuse it in subclasses - A subclass can define new methods and instance
variables, some of which may override (hide)
those of a superclass
36Interfaces
- A class can inherit directly from only one class,
that is, a class can extend only one class. - To allow a class to inherit behavior from
multiple sources, Java provides the interface. - An interface typically specifies behavior that a
class will implement. Interface members can be
any of the following - classes
- constants
- abstract methods
- other interfaces
37Interface Syntax
- To define an interface, use the following
syntax - accessModifier interface InterfaceName
-
- // body of interface
-
- All interfaces are abstract thus, they cannot be
instantiated. The abstract keyword, however, can
be omitted in the interface definition.
38Finer Points of Interfaces
- An interface's fields are public, static, and
final. These keywords can be specified or
omitted. - When you define a field in an interface, you must
assign a value to the field. - All methods within an interface must be abstract,
so the method definition must consist of only a
method header and a semicolon. The abstract
keyword also can be omitted from the method
definition.
39Inheriting from an Interface
- To inherit from an interface, a class declares
that it implements the interface in the class
definition, using the following syntax -
- accessModifier class ClassName extends
SuperclassName - implements Interface1, Interface2,
- The extends clause is optional.
- A class can implement 0, 1, or more interfaces.
- When a class implements an interface, the class
must provide an implementation for each method in
the interface.
40Example
- We define an abstract class Animal with one
abstract method - public abstract void draw( Graphics g )
- We define a Moveable interface with one abstract
method - public interface Moveable
-
- int FAST 5 // static constant
- int SLOW 1 // static constant
-
- void move( ) // abstract method
-
41Derived Classes
- TortoiseRacer class
- extends Animal class
- implements Moveable interface
- implements draw and move methods
- TortoiseNonRacer class
- extends Animal class
- (does not implement Moveable interface)
- implements draw method only
42Multiple Inheritance
- Suppose we have abstract class Student (template
class). - This class has abstract method getGPA which
returns the gpa. - Suppose we also have abstract class Employee
(template class) - This class has abstract method getSalary which
returns the salary. - Class StudentEmployee wants to inherit both
classes and implement both the gpa and the
salary. - It can not do that because multiple inheritance
is not allowed - public class StudentEmployee extends
Student extends Employee - ABOVE IS NOT LEGAL!!!!!!!
43Multiple Inheritance
- Let us leave Employee intact and instead remove
the abstract method getGPA from the Student
class. - Thus there is no need for Student to be abstract
any more. - Let us create an interface
- public interface StudentInterface
- defines the method getGPA
- Let us create a class StudentImpl which inherits
Student and implements interface
StudentInterface. It implements the method getGPA
which calculates the gpa.
44Multiple Inheritance
- Now class StudentEmployee extends Employee and it
also implements the interface StudentInterface.
Therefore it implements the method getGPA but
kind of indirectly (via the implementation of the
method in the StudentImpl class) - StudentImpl stnew StudentImpl()
- public float getGPA()
-
- return st.getGPA()
-
- StudentEmployee object can invoke other
methods of class Student since StudentImpl also
inherits student. - It also can use the class Employee since it
inherited that class directly.
45Multiple Inheritance
Abstract Employee class
Interface StudentInterface
Class StudentEmployee Uses StudentImpl
StudentImpl
46Example of Multiple Inheritance
- Example of a Multiple Inheritance Implementation
is posted on the Web Site Examples page. - In the example our goal it create a class called
Expenses that inherits from both classes Employee
and OperatingExpenses. - Class CorporationTest tests the multiple
inheritance.
47Example of Multiple Inheritance
- Class Employee is abstract because method
compensation is abstract. - Classes Engineer, Management, AdministartivePerson
el inherit Employee and implement compensation
according to their requirements. - Interface ExpenseInterface defines method
getOperatingExpenses - Class Expense extends Employee and implements
interface ExpenseInterface - Class OperatingExpenses has methods that
calculates different operating expenses for the
corporation. - Class ExpenseImpl extends OperatingExpenses and
implements the interface ExpenseInterface
48Engineer
Administrative Personel
Management
ExpensesInterface
Abstract class Employee
OperatingExpenses
OperatingExpensesImpl
Expenses Uses OperatingExpensesImpl
49Example of Multiple Inheritance
- Study program Multiple Inheritance Example
available in the Examples (page) of the course s
web site.