® It Takes Two to Tango – Java and Eclipse John Kidd – Kiddcorp, L.P. Paul T. Calhoun –...
-
Upload
phoebe-sharp -
Category
Documents
-
view
216 -
download
0
Transcript of ® It Takes Two to Tango – Java and Eclipse John Kidd – Kiddcorp, L.P. Paul T. Calhoun –...
®
It Takes Two to Tango – Java and Eclipse
John Kidd – Kiddcorp, L.P.
Paul T. Calhoun – NetNotes Solutions Unlimited, Inc
JMP207
Your Presenters – This Is Us!
John KiddPresidentKiddcorp, L.P.
John Kidd is a recognized strategist, as well as a frequent speaker and author in the area of Java and J2EE technologies. John has more than 16 years experience in leading teams to deliver line of business applications for companies such as Belo, IBM/Lotus, Texas Instruments, and Advanced PCS.
John has been an early adopter in delivering key technologies and delivery methods. He is a frequent speaker on IT strategies and a consultant for organizations developing open source strategies.
Your Presenters – This Is Us!
Paul T. CalhounChief Technology OfficerNetNotes Solutions Unlimited
Paul Calhoun, ND 6,7 and 8 PCLI and PCLP,is a highly rated speaker who provides customer-focused knowledge transfer and consulting to Fortune 100 and 500 companies, as well as many SMBs. Paul currently builds Domino, Web, Java, and XML applications for his customers using Domino, Portlet Factory and WebSphere.
He co-authored the IBM Redbook “XML Powered by Domino,” and has developed several online XML and Java programming courses. He has written articles for both “The View” and “The Sphere” technical publications.
The Great Book Give Away
Compliments of O’Reilly Publishing Please thank them by buying their books !!!!
If you want to participate in the book drawings Place your Business card (or first and last name) in the container being
passed around We WILL NOT harvest contact information for ANY marketing
purposes
We will draw the names during the Session
Agenda
Roadmap
Eclipse, The Tool
Java language Fundamentals
Developing Java code In Eclipse
Develop and Deploy Lotus Domino Java code using the Eclipse development platform
Wrap Up
Roadmap
I’ve said it before, so I’ll say it again !!
Learning Java™ is a lot like eating an Elephant !!
It’s a big job and there’s no clear place where to start !!
Roadmap
Start Here! J2SE
Servlets, JSPs & JSFs
J2EE, XML
Roadmap
Start with J2SE (Java 2 STANDARD Edition) This covers core Java functionality
Syntax Data Types Constructs Core Classes
– java.lang
– java.io
– java.net
– etc. Allow 3-6 Months
http://java.sun.com/javase/index.jsp
Roadmap
Learn XML (not part of Sun Certification) XML Syntax DTD/XML Schema XSL
XSLT XSL:FO
Finally jump on the J2EE bandwagon (In this order) Servlets JSPs JSFs Allow another 3-6 months
Then the rest of the J2EE specification Allow another 3-6 months
Roadmap
Start small Java Agents in Domino
Graduate to Servlets Agent Code transitioned to Servlets running on Domino
Incorporate an external Servlet/JSP engine Apache w/Tomcat add-in (DSAPI Filters available) JBOSS (DSAPI Filters available) WebSphere Application Server (DSAPI Filters available)
Write JSP/JSF applications that access Domino data Using Domino Custom JSP tags (Available since ND 6)
Roadblocks
Road Blocks on your Journey to Learning Java “Linear” thinking instead of thinking in “Objects” Starting to learn Java with J2EE applications (Servlets, JSPs) Trying to start with the Java Enterprise Technologies Try to learn Java in conjunction with a HUGE Mission critical project Not applying what you learn EVERYDAY !!
Agenda
Roadmap
Eclipse, The Tool
Java language Fundamentals
Developing Java code In Eclipse
Develop and Deploy Lotus Domino Java code using the Eclipse development platform
Wrap Up
Eclipse, The Tool
Installing Eclipse
Updating Eclipse
Configuring Eclipse
Navigating Eclipse
Creating Projects
Ok, let’s get this out of the way
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
We Don’t Hate LotusScript !!!!!!!!!!!
Very Wise Saying
If the only tool you have is a hammer, you tend to see every problem as a nail
Abraham Maslow
Your Domino Development Toolbox
Formula Language
LotusScript
Java JavaScript
Installing Eclipse
Steps to Install Eclipse Download a Java SDK FIRST
Level 1.4.2 or higher
– Java 5 is recommended Install Java SDK
Download Eclipse 3.3.x (Europa Build) http://www.eclipse.org/downloads/ Supported Platforms
– Windows
– Linux
– Solaris 8
– AIX
– HP-UX
– Max OS X
Installing Eclipse
You must have at least one Java SDK installed on your machine BEFORE installing the Eclipse workbench Must be version 1.4.2 or above (J2SE 5 or 6)
Java 5 is the recommended !!
If supporting multiple installed SDKs Install oldest to newest
Installing Java 5 or 6 will allow you to write code that conforms to older JRE
http://java.sun.com/javase/downloads/index.jsp
Tip
Installing Eclipse
Download Eclipse 3.3.x This is the Europa build It will be .zip file Unzip the contents to a directory on the hard drive
That’s it. You just installed Eclipse !!!
Start Eclipse Eclipse.exe (Windows) ./Eclipse (Linux) First time Eclipse starts it will search for an installed SDK and add it to the
workbench configuration Only the currently configured JRE will be added to the workbench
configuration Others can be added (See configuration slides)
Installing Eclipse
Eclipse start up screen
Installing Eclipse
The Eclipse Workbench with the default Java Perspective
Updating Eclipse
The first task to complete after the Eclipse workbench is started is to check for software updates From the “Help” menu choose “Software Updates > Find and Install…”
Updating Eclipse
In the Feature Updates Dialog box there are two options Search for updates of the currently installed features
Allows you to update all currently installed feature functionality Search for new features to install
Allows you to add additional functionality to the Eclipse Workbench
– Like the Web Tools Plug-in
Updating Eclipse
Search for updates to the currently installed features FIRST This will ensure that you have the most up to date “Core” install
If you have just downloaded Eclipse, there may be not updates to install
After the installed feature update is complete, then search for new features to install This will allow you to add additional functionality to your installation of
Eclipse
Updating Eclipse
If “Search for new features to install” is selected you will see the following dialog box
Updating Eclipse
The Europa Discovery Site is a combination of Eclipse projects in one installation site Check the values for the functionality you want to install and click the
Next button If there are errors after you make your selections, click the “Select
Required” button to resolve any dependency issues
Updating Eclipse
When first starting out I recommend including the following Graphical Editors and Frameworks Java Development Web and JEE Development
You will need to run Software update After every newly installed feature At least once a Quarter Preferably once a month
Tip
Configuring Eclipse
Configuration changes that affect the entire workbench are done via the “Preferences” dialog box From the “Window” menu choose “Preferences”
Tip
Configuring Eclipse
Expand the preferences in the column on the left to access the preferences for that category
Configuring Eclipse
Common preference changes Change Font for editors and dialogs
General > Appearance > Colors and Fonts
– Expand “Basic” select “Text Font” Prompt for workspace on startup
General > Startup and Shutdown Default Web Browser to use
General > Web Browser Enable HTTP Proxy Connection
General > Network Connections
Configuring Eclipse
Common preference changes (Cont) Configure additional JREs
Java > Installed JREs
– Click the Add button and navigate to install directory
– You can add the Domino 6.x, 7.x and 8.x JVM to the Installed JREs in Eclipse to use on Domino only projects
Configuring Eclipse
Common preference changes (Cont) Some changes are specific to the current workspace (Like the JVM’s we
just added) Preferences can be exported from one workspace and then imported
into another Once you have configured your preferences the way you want them
Export the Preferences
– File > Export…
– Expand General and choose “Preferences”
Tip
Configuring Eclipse
Common preference changes (Cont) You can choose to export all or just the specific changes Provide a file name that has an .epf extension
This is just an XML file
Configuring Eclipse
Common preference changes (Cont) Preferences can be imported into a new workspace from the import
menu File > Import…
– Expand General and choose “Preferences”
Configuring Eclipse
Common preference changes (Cont) Choose the .epf file to be imported
You can import all of the preferences or choose a sub-set
Configuring Eclipse
Common preference changes (Cont) In order to test Web Applications (Servlets, JSP’s) you will need an
installed Web Application Server Add Runtime Test Server
– Server > Installed Runtimes
– Click “Add” and browse to installation of runtime test server
– IBM WebSphere Application Server
– Apache w/Tomcat add-in
– JBOSS
– Oracle
Navigating Eclipse
Eclipse is made up of Perspectives
Allows developer to focus on particular development type
– Java
– J2EE
– Debug
– Plug-in
– Resource Views
Displays functionality with-in a perspective
– Package Explorer
– Problems Editors
Allows for development of a particular code type
– Java
– HTML, CSS, JavaScript, XML, etc.
Navigating Eclipse
Switch between perspectives using the Perspective bar in the upper right hand corner of the workbench
Views in Perspectives can be dragged/dropped to any area of the perspective
Additional views can be added via the menu “Window > Show View”
Navigating Eclipse
Views can be removed from a perspective by click on the “X” in the upper right corner of a view
Any View (Including Editor Windows) can be Maximized/Restored by double clicking on the tab that displays the view/editor title
If you totally FUBAR a perspective you can always restore the view to the original layout via the menu “Window > Reset Perspective”
Tip
Navigating Eclipse
The default Java PerspectivePerspective
Bar
Editor
Views
Creating Projects
The type of Project that can be created in Eclipse is based upon the features that have been added
“Out of the Box” Eclipse can only create the following project types Java Plug-in Resource CVS (Concurrent Versioning System – Code Sharing)
With Additional Features from the Eudora or other Eclipse/Third Party add ins Web
Static Web Project Dynamic Web Project
J2EE Enterprise Application Project Application Client Project
Creating Projects
All projects are created via the New Project Wizard File > New Project
Eclipse Workbench - Demonstration
Agenda
Roadmap
Eclipse, The Tool
Java language Fundamentals
Developing Java code In Eclipse
Develop and Deploy Lotus Domino Java code using the Eclipse development platform
Wrap Up
Java History
Originally was called the “Oak”
Was intended to be used in consumer electronics Platform independence was one of the requirements Based on C++, with influences from other OO languages (Smalltalk,
Eiffel …)
Started gaining popularity in 1995 Renamed to “Java” Was a good fit for the Internet applications
Portability
Java is a platform independent language Java code can run on any platform Promotes the idea of writing the code on one platform and running it on any
other
Java source code is stored in .java files
Compiler compiles code into .class files The compiled code is the bytecode that can run on any platform Bytecode is what makes Java platform independent
Bytecode is not machine code
Java Virtual Machine (JVM) Platform specific - Processes bytecode at runtime by translating bytecode into
machine code
Memory Management
Automatic garbage collection is built into the language No explicit memory management is required Occurs whenever memory is required Can be forced programmatically Garbage collector frees memory from objects that are
no longer in use
Distributed Systems
Java provides low level networking TCP/IP support, HTTP, and sockets
Java also provides higher level networking Remote Method Invocation (RMI) is Java’s distributed protocol
Used for communication between objects that reside in different Virtual Machines
Commonly used in J2EE (Java 2 Enterprise Edition) Application Server
CORBA could also be used with Java
Identifiers
Used for naming classes, interfaces, methods, variables, fields, and parameters
Can contain letters, digits, underscores, or dollar-signs
There are some rules that apply: First character in the identifier cannot be a digit
Can be a letter, underscore, or dollar sign Literals true, false, and null cannot be used Reserved words cannot be used
And it is Case Sensitive!
Expressions
Statements are the basic Java expressions Semicolon (;) indicates the end of a statement
HomePolicy homePolicy;double premium; premium = 100.00;homePolicy = new HomePolicy();homePolicy.setAnnualPremium(premium);
variable declaration
variable assignment
object creation
message sending
Comments
/** Javadoc example comment. * Used for generation of the documentation. */
/* Multiple line comment. * */
// Single line comment.
Literals
Represent hardcoded values that do not change
Typical example are string literals When used, compiler creates an instance of String class
String one = "One";String two = "Two";
String one = new String("One");String two = new String("Two");
Java and Types
There are two different types in Java Primitive data type Reference type
It is said that Java is a strongly typed language Fields, variables, method parameters, and returns must
have a type
double premium; HomePolicy homePolicy;
variable type
variable name
Primitives
Primitives represent simple data in Java
Primitives are not objects in Java Messages cannot be sent to primitives Messages can be sent to other Java objects that
represent primitives These are known as wrapper objects in Java (such as Double,
Integer, and Boolean)
Primitive Types
Keyword Size Min value Max value
boolean true/false
byte 8-bit -128 127
short 16-bit -32768 32767
char 16-bit Unicode
int 32-bit -2147483648 2147483647
float 32-bit
double 64-bit
long 64-bit - 9223372036854775808 9223372036854775807
Manipulating Numeric Types
A lesser type is promoted to greater type and then the operation is performed
A greater type cannot be promoted to lesser type Assigning double value to int type variable would result in a compile
error
12 + 24.56 //int + double = double
int i = 12;double d = 23.4;i = d; Type mismatch
Type Casting
Values of greater precision cannot be assigned to variables declared as lower precision types
Type casting makes primitives change their type Used to assign values of greater precision to variables declared as
lower precision e.g., It’s possible to type cast double to int type
int i = 34.5; //compiler error - type mismatchint i = (int)34.5; //explicit type casting
Reference Types
Reference types in Java are class or interface They are also known as object types
If a variable is declared as a type of class An instance of that class can be assigned to it An instance of any subclass of that class can be assigned to it
If a variable is declared as a type of interface An instance of any class that implements the interface can be
assigned to it
Reference Types (cont.)
Reference type names are uniquely identified by: Name of the package where type is defined (class or interface) Type name
This is full qualifier for the type and it is full qualifier for class or interface
java.lang.Objectcom.kiddcorp.demo.models.Policy
Object Operators
Keyword Description
instanceof object type
!= not identical
== identical
= assignment
Creating Objects in Java
In Java, objects are created by using constructors
Constructors are methods that have the same name asthe class They may accept arguments mainly used for fields initialization If constructor is not defined, the default constructor is used
Use “new” before class name to create an instanceof a class
HomePolicy firstPolicy = new HomePolicy();HomePolicy secondPolicy = new HomePolicy(1200);
Assignment
Assigning an object to a variable binds the variable to the object
HomePolicy firstPolicy = new HomePolicy(1200);
HomePolicy firstPolicy = new HomePolicy(1200);
HomePolicy secondPolicy = new HomePolicy(1200);
firstPolicy = secondPolicy;
1200
aHomePolicy
1200
aHomePolicy
1200
aHomePolicy
1200
aHomePolicy
Identical Objects
Operand == is used for checking if two objectsare identical Objects are identical if they occupy the same memory space
int x = 3;int y = 3;x == y; //true
HomePolicy firstPolicy = new HomePolicy(1200);
HomePolicy secondPolicy = new HomePolicy(1200);
firstPolicy == secondPolicy; //false
3
1200
aHomePolicy
1200
aHomePolicy
Identical Objects (cont.)
Variables that reference objects are compared by value Objects are identical if their memory addresses are the same
Variables are identical if they refer to the exact same instance of the class
HomePolicy firstPolicy = new HomePolicy(1200);HomePolicy secondPolicy = firstPolicy;firstPolicy == secondPolicy; //true
1200
aHomePolicy
Equal Objects
Determined by implementation of the equals() method Default implementation is in the Object class and
uses == (identity) Usually overridden in subclasses to provide criteria
for equality
HomePolicy firstPolicy = new HomePolicy(1200,1);
HomePolicy secondPolicy = new HomePolicy(1200,1);
firstPolicy.equals(secondPolicy); //false
Null
Used to un-assign object from a variable Object is automatically garbage collected if it does not
have references
When a variable of object type is declared, it is assigned “null” as a value
String one = "One";one = null;one = "1";
HomePolicy policy;policy = new HomePolicy(1200);…if (policy != null)
System.out.println(policy.toString());
Arrays
Arrays store objects of specific type One array cannot store objects of different types – String and int, for
example
When creating an array explicitly, its size mustbe specified This indicates the desired number of elements in the array Elements in the array are initialized to default values
Creating and initializing arrays at declaration
int arrayOfIntegers[];arrayOfIntegers = new int[5];
int[] arrayOfIntegers = {1,2,3,4,5};
The first element in the array is at the zero index
Arrays (cont:)
If not using initializer, an array can be initialized by storing elements at the proper index
An element of the array is accessed by accessing the index where the element is stored
int[] arrayOfIntegers;arrayOfIntegers = new int[3];arrayOfIntegers[0] = 1;arrayOfIntegers[1] = 2;arrayOfIntegers[2] = 3;
int[] arrayOfIntegers = {1,2,3,4,5};System.out.println(arrayOfIntegers[2]);
3Console
The length property will return the number of elements in the array
Conditional Statements
x ? y : z x must be type boolean, y and z can be of any type Evaluates to y if x is true, otherwise evaluates to z
if, if-else Can be nested Can omit braces if only one statment
(1 == 1) ? 7 : 4 //evaluates to 7
if(condition){statement1;
}else{ statement2;}
Conditional Statements (cont:)
Switch Statement Break Allows you to stop after executing an expression
switch(expression){ case value1: expression1; case value2: expression2;
expression3; default: expression4;}
switch(expression){ case value1: expression1;
break; case value2: expression2;
break; default: expression3;}
Looping
for loop
while() and doWhile()
for(int i=1; i<5; i++){System.out.println("Index is equal to " + i);}
Index is equal to 1Index is equal to 2Index is equal to 3Index is equal to 4
Console
int i=1;while(i < 5){
System.out.println(i);i++;}
int i=1;do{
System.out.println(i);i++;
}while(i < 5);
Java Fundamentals
How to Define a Java Class?
Java class is defined by using the “class” keyword Class name follows the keyword, and by convention starts with capital
letter For example Policy, Client, House, etc.
Class access level must be specified before theclass keyword Public
Identifies that any other class can reference defined class Not specified
Identifies that only classes defined in the same package can reference defined class
It is the default access level modifierpublic class Policy{
…}
.java Files
Java classes are contained in .java files One file can contain one public class One file can contain more than one non-public class
The file name is the same as the class name contained in the file
package com.kiddcorp.demo.models;
public class Policy{…
} Policy.java
Package Package groups related classes
Classes are usually related by their functionality, for example, domain classes, testing classes, etc.
Package is identified using “package” keyword
Package is a unique identifier for a class Two classes with a same name cannot be in the same package Different packages can contain the same class names
Compiled Java classes from the same package are compiled into the same directory The directory name matched the package name
package com.kiddcorp.demo.models;
Referencing Classes
A class must be fully referenced every time when used outside of its package
Full qualifier for a class is used package name + class name
package com.kiddcorp.demo.tests;
public class PolicyTester{com.kiddcorp.demo.models.Policy policy;…policy = new com.kiddcorp.demo.models.Policy();
}
Import Statement
Used to identify which classes can be referenced without fully identifying them Specified with “import” keyword Can specify a class, or all classes from a package
package com.kiddcorp.demo.tests;import com.kiddcorp.demo.models.Policy;
public class PolicyTester{Policy policy;…policy = new Policy();
}
Classpath and .jar Files
Classpath allows Java Virtual Machine to find the code CLASSPATH environment variable is used to indicate the root of where
packages are Packages are subdirectories under the root
Compiled Java classes can be packaged and distributed in Java Archive (.jar) files Packages in the .jar file are replaced with directories Essentially a zip file with a different extension
Defining Fields
A field definition consists of: Access modifier Field type Field name
package com.kiddcorp.demo.models;
public class Policy {private Client client;private String policyNumber;private double premium;
}
Initializing Fields
Fields are initialized when a new instance of a classis created
Primitive type fields get a default value Numeric primitives are initialized to 0 or 0.0 Boolean primitives are initialized to false Reference type fields are initialized to null, as they do not yet
reference any object
Fields can also be explicitly initialized when declared
Initializing Fields Explicitly
Possible when declaring fields
Not commonly used Constructors are generally used for initializing fields
package com.kiddcorp.demo.models;
public class Policy {private Client client = new Client();private String policyNumber = "PN123";private double premium = 1200.00;
}
Field Access Modifier
There are four different modifiers: Public
Allows direct access to fields from outside the package where the class is defined
Protected Allows direct access to fields from within the package where the
class is defined Default
Allows direct access to fields from within the package where class the is defined and all subclasses of the class
Private Allows direct access to fields from the class only
Defining Methods
Methods are defined with: Access modifier – same as for fields Return type Method name Parameters – identified with type and name
To allow access to private fields, getter and setter methods are commonly used
package com.kiddcorp.demo.models;
public class Policy {…public void setClient(Client aClient){…}
}
Constructors
Special methods used for creating instances of a class: Access modifier Same name as the class Manipulate new instance
package com.kiddcorp.demo.models;
public class Policy {…public Policy(){
setClient(new Client());setPolicyNumber("PN123");setPremium(1200.00);
}}
What Are Static Fields?
Static fields represent data shared across all instances of a class There is only one copy of the field for the class
Static fields are also known as class variables
Java constants are declared as static final fields Modifier final indicates that field value cannot be changed
public class Count{public static String INFO = "Sample Count Class";public final static int ONE = 1;public final static int TWO = 2;
}
System.out.println(Count.ONE);1
Console
Static Methods
Define behavior related to the class, not individual instances Defined by using the “static” keyword Commonly utilitarian in nature (See the Wrapper Classes)public class Count{
private static String INFO = "Sample Count Class";public final static int ONE = 1;public final static int TWO = 2;public final static int THREE = 3;public static String getInfo(){
return INFO;}
}
System.out.println(Count.getInfo());Sample Count
Class
Console
Defining Inheritance In Java, inheritance is supported by using
keyword “extends” It is said that subclass extends superclass If class definition does not specify explicit superclass,
its superclass is Object class
Multiple inheritance is not supported in java
public class Policy{…public class HomePolicy extends Policy{…public class AutoPolicy extends Policy{…public class LifePolicy extends Policy{…
public class Policy{… public class Policy extends Object{…
Specialization and Generalization
ItemTextDateTimeValue
parseXMLcontainsValue…
RichTextItemEmbeddedObjects
embedObjectendSection…
Gen
era
lizati
on
Sp
ecia
lizatio
n
What Is Inherited?
In general, all subclasses inherit from superclass: Data Behavior
When we map these to Java, it means that subclasses inherit: Fields (instance variables) Methods
Method Overriding
If a class defines the same method as its superclass, it is said that the method is overridden Method signatures must match
Consider Animal class: Dog and Cat as subclasses
All Animal objects should know how to talk
Animal aCat;aCat.talk();
Animal aDog;aDog.talk();
meows
barks
Animal
talk()
Dog
talk()
Cattalk()
Interfaces
Interfaces define a type and protocol, but do not provide implementation of that protocol Classes that implement interfaces must provide implementation for
defined protocol Interfaces capture common behavior of the classes that implement
them
Commonly used to: Impose protocol on set of classes that implement interface Indicate certain Java type (marker interfaces)
Interfaces are also stored in .java filespublic interface Animal{
public void speak();}
public interface Mammal{}
Interface Rules
Interfaces can contain Only method signatures Only final static fields
Interfaces cannot contain Any fields other than final static fields Any static methods Any method implementation Any constructors
It is possible that one interface extends other interfaces Multiple inheritance is allowed with interfaces
Inheritance works the same as with classes
Implementing Interfaces
Classes implement interfaces Keyword “implements” is used They must define all methods that the interface they implement
declares
public class House extends Building implements Policyable{public Policy createPolicy(){
HomePolicy policy = new HomePolicy(this);return policy;
}}
What Are Collections?
Collections are Java objects used to store, retrieve, and manipulate other Java objects Any Java object may be part of a collection, so collection can contain
other collections
Unlike arrays, collections do not store primitives
Unlike arrays, collections can store different objects Not all objects in a collection must be the same Java type
Most Commonly Used Collections
The most commonly used collections include: Collection framework collections:
ArrayList HashMap HashSet
Legacy collections re-implemented with the collection framework: Vector Hashtable
What Is an Exception?
Exceptions are unexpected conditions in a program Like Opening a file that does not exist Or Sending a message to an object that object does
not understand
In Java, there are two different types of exceptions Unchecked exceptions
Runtime exceptions and errors Checked exceptions
All others exceptions
Exceptions are objects in Java, and they are all of the Throwable type
Generics
New Java 1.5 is the concept of the Generic
In the old days, anything put into a collection was stored as a generic Object
Thus when you retrieved it from the collection you had to cast it to the appropriate type
ArrayList al= new ArrayList();al.add(new Document());
/*Later in the code we retrieve the value */Object obj=al.get(0); //Value is retrieved as an objectDocument doc=(Document)obj; //Cast to the appropriate type
Generics Save the Day
No longer is it necessary to cast the value retrieved from a collection to it’s real type
This provides significant improvements in code style and type safety
ArrayList<Document> al= new ArrayList<Document>();al.add(new Document());
/*Later in the code we retrieve the value */Document doc=al.get(0); //No need to cast
Try – Catch and Finally Blocks
Exceptions are handled in a try-catch block
Finally Always executes at the end after the last catch block Commonly used for cleaning up resources (closing files, streams, etc.)
public void myMethod(){try{
//code that throws exception e1//code that throws exception e2
}catch(MyException e1){//code that handles exception e1
}catch(Exception e2){//code that handles exception e2
}finally{//clean up code, close resources
}}
Java OO Fundamentals
Agenda
Roadmap
Eclipse, The Tool
Java language Fundamentals
Developing Java code In Eclipse
Develop and Deploy Lotus Domino Java code using the Eclipse development platform
Wrap Up
Java Development Tooling – JDT
Eclipse’s Java Development Environment is often referred to as Java Development Tooling (JDT) Using the JDT you can do the following things with
Java programs: Write Compile Test Debug
Remember the right click menu!
Perspectives
When developing Java code, commonly used perspectives include: Java Perspective
Designed for working with Java projects Java Browsing Perspective
Designed for browsing the structure of Java projects Java Type Hierarchy Perspective
Designed for exploring type hierarchy Debug Perspective
Designed for debugging Java programs
Java Perspective
Contains: Outline View Editor area Package Explorer View Hierarchy View Tasks View
Java Browsing Perspective
Contains: Editor area Projects View Packages View Types View Members View
Java Type Hierarchy Perspective
Contains editor area and Hierarchy View
Build Path Project Preferences
You can set global preferences for a project Select Window → Preferences to
get Preferences View Good idea to separate your Java
files into source and compiled directories (src and bin)
This action only needs to be done once
Done for all subsequent projects
Tip
Creating a Java Project
Projects are used to organize resources (source, class, icons) for a project
To create a Java project: Select Window → New → Project …
from the menu The New Project wizard
comes up Select Java → Java Project Click Next
New Project Wizard
Specify a Project name
Click Next
New Project Wizard: Java Settings
Specify Java Settings Output folder (where compiled
files will be stored) Any external JAR files the project
depends on Classes from other projects that
are referenced in the project
Click Finish
Project Properties
You can change the Java build path at any time Choose Properties from the context menu on the project
Creating Packages
A package contains Java class files
To create a package for a project: Select the project Choose New → Package from the
context menu Specify package Name Click Finish
Creating Classes
To create a class in a package: Select the package Choose New → Class from the
context menu The Class wizard comes up Specify class details Click Finish
Using Code Assist
When activated, code assist opens a list of available code completions
Code Assist activates by Crtl+Space Activates automatically when a message needs to be sent to an object
(after the dot is typed)
Tip
Using Quick Fix (Ctrl + 1)
Useful if Java compiler shows errors Gives options for fixing the errors Activated through Edit → Quick Fix menu option
Error indication
Searching for Java Classes
When developing Java applications, a good search mechanism is very important You often search for class, method declarations,
and references It is important to be able to find things quickly
Eclipse Java Search mechanism is very extensive
It allows you to search for: Types, methods, constructors, packages, and fields Declarations, Implementers, References In the scope of Workspace, Working Set, or
Selected Resources
Organizing Java Code
Eclipse comes with extensive support for organizing and refactoring Java code
It is possible to: Generate getters and setters for the fields Organize missing import statements Move fields, methods, classes Rename methods, classes, packages
Generating Getters and Setters
Available for creating get and set methods on the fields It supports encapsulation activated by choosing Source → Generate
Getter and Setter from the editor’s context menu
Source Navigation F3
Navigate to a type, method, or field at the current cursor location
Ctrl+Shift+T Open an editor for any Java type that is available
in your workspace. Also via menu Navigate → Open Type … or using a toolbar icon
Ctrl+O Open a lookup dialog containing a list of
members in the current Java editor. Start typing characters to limit the list and press Enter to go to the selected member. A quick alternative to the Outline view.
Ctrl+F3 Open a member lookup dialog for the class
name at the current cursor location, e.g., position on Date and press Ctrl+F3 to review and lookup one of its methods
Source Code Templates
Provides a “shorthand” for common programming tasks
Eclipse JDT
Agenda
Roadmap
Eclipse, The Tool
Java language Fundamentals
Developing Java code In Eclipse
Develop and Deploy Lotus Domino Java code using the Eclipse development platform
Wrap Up
Develop and Deploy Lotus Domino Java Code
Java versions by Domino release ND 8
Java 5 (1.5) / with notes.ini variable set
– JavaCompilerTarget=1.5
– Notes/Domino will compile agents using
– javac -source 1.5 -target 1.5
Java 5 (1.5) / without notes.ini varibale set (Default)
– Notes/Domino will compile agents using
– javac -source 1.3 -target 1.2
Develop and Deploy Lotus Domino Java Code
Java versions by Domino release (cont) ND 7
Java 1.4.2 ND 6
Java 1.3.1 ND 5
Java 1.1.8
Develop and Deploy Lotus Domino Java Code
If you attempt to compile code using Java features not supported by the runtime you will receive compile errors
The following is an example of running Java 1.5 specific code in Notes without the .ini variable set
Develop and Deploy Lotus Domino Java Code
The JVM in ND 8 is enabled with a Just-in-Time compiler or JIT
Using JIT compiling will improve performance in the execution of Java code running on the ND 8 platform
JIT is enabled by default Although it is not recommended you can turn off the JIT using the
following .ini variable JavaEnableJIT=0
Develop and Deploy Lotus Domino Java Code
The Problem The Domino Designer client does not include support for Java code
completion or Pop-up syntax help
The Solution Write your Java agents in a Java IDE !!
Eclipse Rational Developer Any IDE that lets you access the .java file from the file system
Develop and Deploy Lotus Domino Java Code
Steps for Developing and Deploying Domino Java Code Create a Java Project in Eclipse Create Agent source code in Project Create a new Agent in the Designer Client Import source code from Eclipse into new Agent
Develop and Deploy Lotus Domino Java Code
Create a New Java Project in Eclipse File > New Project > Java Project
Provide a Project Name Select the JRE
– If you have configured Domino as one of your JREs in the workbench preferences you can select it here
Project Layout
– Keep separate source and output folders Click “Next”
Develop and Deploy Lotus Domino Java Code
In the Java Settings Dialog Click on the “Libraries” tab. This is your projects “Classpath”
This will allow you to add additional libraries to your project
– If you are NOT using the Domino 7 or 8 JRE you will need to add the “Notes.jar” file here
Click “Add External Jars”
– Navigate to the proper Domino Directory Domino 6
– C:\installdir\notes Domino 7
– C:\installdir\jvm\lib\ext Domino 8
– C:\installdir\jvm\lib\ext This is also where you would add third party
jar files to your project Like JDBC drivers, etc
Develop and Deploy Lotus Domino Java Code
The majority of Java Agents are created without a package reference Although it’s a good idea to start getting in the habit of using them Packages are typically the reverse DNS name of your organization
com.acme.code
In the “src” folder of your Java Project Create a package or use the “default package” Create a new Java Class
Right click package or folder and choose “New > Class” from context menu
This will open the “Java Class” wizard
Develop and Deploy Lotus Domino Java Code
Provide a Class name in the Name fieldDo not use the value of “JavaAgent” that is used by default in all new Java Agents in the Domino Designer Client
Choose a name that is indicative of the agent functionality
Do not worry about any of the other settings
Click the “Finish” button to create the class and open the source code in the Java Editor
Develop and Deploy Lotus Domino Java Code
The code created by the wizard will need to be replaced with template code created from a new agent in the Designer Client You can
Cut / paste the new agent template code from the Designer Client Create a “Snippet” in Eclipse that stores the new agent template
code Use Plug-in provided (See resources at end of presentation)import lotus.domino.*;
public class JavaAgent extends AgentBase {
public void NotesMain() {
try {Session session = getSession();AgentContext agentContext = session.getAgentContext();
// (Your code goes here)
} catch(Exception e) {e.printStackTrace();
}}
}
Develop and Deploy Lotus Domino Java Code
Every newly created agent in the Designer Client creates a new source file with a class name of “JavaAgent”
When the template code is added in eclipse this name will need to be “re-factored” to the name of the class created in Eclipse
Click on the “light bulb” and choose “Rename type to…”
Develop and Deploy Lotus Domino Java Code
Write the Java code in Eclipse to complete the agent functionality
Save the source code and ensure that there are no compile errors
Toggle back to the Designer Client Create a new Java Agent and give it the same name as the class in Eclipse Click the “Edit Project” button on the bottom of the agent IDE in the Notes
designer client Change the “Base Directory” to point to the source folder of your eclipse project
You will only have to do this once per database Add the source (.java NOT the .class) file to the Current Agent files One time only
Change the “Base Class” to the new source file name Delete “JavaAgent.java” from the file list
Click “OK” to import the source code
Develop and Deploy Lotus Domino Java Code
Develop and Deploy Lotus Domino Java Code
The first time the source code is imported the code block will be collapsed Click the “+” to expand it
When changes are made to the source code in Eclipse Click the “Edit Project” button Click on the “Refresh All” button Click “OK”
You will be prompted that the source code will be replaced with the new code Click “Yes” to accept the new code changes
Develop and Deploy Lotus Domino Java Code
Using this procedure Make sure you ALWAYS make your code edits in Eclipse Import the changes to Existing/New agents in the Notes Designer
Client
Develop and Deploy Lotus Domino Java Code - DEMO
Develop and Deploy Lotus Domino Java Code
Java Domino Objects Only implements the “Back End” objects Exposed via:
lotus.domino.* No Notes Client UI access You (the Domino Developer) already know 98.67 percent of all of the
Java class names for the Domino Back End Objects Drop “Notes” from the front of the LotusScript class names and you
have the Java class names
LotusScript Class Name
Java Class Name
NotesSession Session
NotesDatabase Database
NotesView View
NotesDocument Document
NotesItem Item
Develop and Deploy Lotus Domino Java Code
Performance Java Agent vs. LotusScript Agents
Java Agents and LotusScript Agents call the same C++ code base On an “Apples to Apples” comparison they will perform equitably
Classes the don’t exist in LotusScript AgentBase AppletBase and JAppletBase NotesError NotesException NotesFactory NotesThread
Develop and Deploy Lotus Domino Java Code
AgentBase Java Agents MUST extend AgentBase Java Agents MUST use the NotesMain() method as the entry point for
their functional code The getSession() method creates a Session object
import lotus.domino.*;
public class MyFirstAgent extends AgentBase {
public void NotesMain() {try {
Session session = getSession();AgentContext agentContext = session.getAgentContext();
// (Your code goes here)
}catch(NotesException ne){ne.printStackTrace();
} catch(Exception e) {e.printStackTrace();
}}
}
Develop and Deploy Lotus Domino Java Code
Primary problems LotusScript Developers have transitioning to Java Compile Errors
Java is Case Sensitive
– Yes, it’s always going to be case sensitive Data typing errors
– Java has no “Variant” data type Most common runtime Errors
Null Pointer exception Class not found exception
Develop and Deploy Lotus Domino Java Code
Domino Java agents have no access to the Notes UI
System.out.println() commands can be inserted into the code Output from agents is written to the “Debug Console” from code
executed on the client Output from agents is written to the Server Console from code
executed on the server
Access the Debug Console via the menu “File > Tools > Show Java Debug Console” from the Notes/Designer client
Develop and Deploy Lotus Domino Java Code
Code Walk Through Session AgentContext Database View Documents – Read
Help Doc Count Agents Documents – Create Items – Read Items – Create Run on Server Java Network I/O HTML Output XML Output Web Query Save
Wrap Up
Follow the “Roadmap” J2SE Servlets, JSPs, JSFs XML Rest of J2EE Specification
Start with Java Agents in Domino
Transition to Servlets running on the Domino Server
Transition to external Servlet/JSP – J2EE server
Avoid the Roadblocks !
Introduce yourself to Plug-ins and the Eclipse Rich Client Platform
Other Java Related Sessions you should checkout
AD201 - The Amazing IBM Lotus Notes 8: Extendable with Plug-ins
AD203 - Developing Secure Java Applications in IBM Lotus Notes 8
AD301 - IBM Lotus Domino Designer
AD308 - Java 5.0 for IBM Lotus Notes and Domino
AD312 - Using Eclipse To Develop, Debug and Test Java Agents
HND102 – IBM Lotus Domino Designer in Eclipse
HND103 – Developing Eclipse Plug-ins to Extend IBM Lotus Notes 8
Wrap Up
References and Resources NNSU
Domino Eclipse/RAD plug-in http://www.nnsu.com
TLCC Java Computer based training via Notes Databases http://www.tlcc.com
O’Reilly Publishing Head First… Series http://www.oreilly.com
SUN Developer Network http://java.sun.com
Eclipse Project http://www.eclipse.org
Wrap Up
References and Resources (cont) Apache Jakarta Project
http://jakarta.apache.org Developer Works
http://www.ibm.com/developerworks http://www.ibm.com/developerworks/java http://www.ibm.com/developerworks/lotus http://www.ibm.com/developerworks/xml
Remember the On-line Evaluations !!!!!
Please take a moment after this session to fill out the on-line evaluations !!!!!!
You got Questions? We got Answers !