class PointXY { 
:
}
class Human {
:
}
interface MemberOfPool {
:
}
PointXY oPointXY;
Human oHuman;
MemberOfPool oMemberOfPool;
Integer i;
Color oColor;

class SomeClass {
:
// aSomeField é um array do tipo inteiro
public int[] aSomeField = new int[10];
// aSomeVector é um vector
public Vector aSomeVector = new Vector();
{ 
:
}
:
} 

boolean isEmpty() { 
...
}
File findFile() {
...
}

MyClass myClass;
// foo
myClass.foo();

myClass.fooMyClass();
--ou --
myClass.myClassFoo();

static long max( long x, long y );
static double max( double x, double y );

static long maxl( long x, long y );
static double maxd( double x, double y );

class MyConstants {
// constante String
public static final String JOHN_DOE = "John Doe";
// constante int
public static final int JOHN_DOE_ID = 100;
:
} 

: 
String myName = "Barry Feigenbaum";
int myID = -1;
if(myName.equals(MyConstants.JOHN_DOE)) {
myId = MyConstants.JOHN_DOE_ID;
:
if(myID < 0) {
// Realiza algo
}
:
} 

class ClassName {
// variaveis
int iVariable1;
int iVariable2;
// acesso
public int getVariable1() {
return variable1;
}
// atribuição
public void setVariable1( int newVariable1 ) {
variable1 = newVariable1;
}
//
public boolean isReady() {
return variable1 == variable2;
}
}

public class SomeClass { 
private int field1; 
:
private int fieldN;
:
public SomeClass( int newfield1, ..., newfieldN ) {
// this.setfield1 é o atributo
// newfield1 é o argumento
this.setfield1 = newfield1;
:
this.setfieldN = newfieldN;
}
:
}

class <name extends <superclass> implements <interfaces> {
// public atributos e métodos visíveis
public static final data members
public static data members
public data members
public constructors
public finialize
public static methods
public methods

// Atributos e métodos visíveis somente para o package
static final data members
static data members
data members
constructors
static methods
methods
// package visibilidade protected para atributos e métodos
protected static final data
protected static data
protected data
protected constructors
protected static methods
protected methods

// visibilidade protected para atributos e métodos
private protected static final data
private protected static data
private protected data
private protected constructors
private protected static methods
private protected methods
// visibilidade private para atributos e métodos
private static final data members
private static data members
private data members
private constructors
private static methods
private methods
}

package persistence;
import java.io.IOException;
import java.io.DataOutputStream;
import java.io.DataInputStream;
public interface Persistent {
// saves object to file
public boolean storeOn( String f )
throws IOException;
// saves object to stream
public boolean storeOn( DataOutputStream s )
throws IOException;
// gets object from file
public boolean loadFrom( String f )
throws IOException;
// gets object from stream
public boolean loadFrom( DataInputStream s )
throws IOException;
}

import persistence.Persistent;
import application.AppClass;
public class MyClass implements Persistent {
private int value1;
// AppClass implementa Persistent tambem
private AppClass class1;
:
public boolean storeOn( String f ) throws IOException {
DataOutputStream s = new DataOutputStream( BufferedOutputStream(
FileOutputStream( f ) ) );
boolean result = storeOn( s );
s.close();
return result;
}
public boolean storeOn( DataOutputStream s ) throws IOException {
// put int
s.writeInt( value1 );
if( class != null ) {
// indicate AppClass present
s.writeBoolean( true );
// put instance
class1.stroreOn( s );
else
// indicate AppClass missing
s.writeBoolean( false );
}
public boolean loadFrom( String f ) throws IOException {
DataInputStream s = new DataInputStream( BufferredInputStream(
FileInputStream( f ) ) );
boolean result = loadFrom( s );
s.close();
return result;
}
public boolean loadFrom( DataInputStream s ) throws IOException; {
// get int
value1 = s.readInt( );
if( class1 != null ) {
// do cleanup on current state
class1.finalize( );
// only if AppClass saved
if( s.readBoolean( ) ) {
// get empty instance
class1 = new AppClass();
// fill it in
class1.loadFrom(s);
else
class1 = null;
}
}
}

--usando interfaces (modo preferencial) -//
class MyClass implements AnInterface {
private AnInterfaceImplementation implementation;
public MyClass() {
implementation = new AnInterfaceImplementation();
}
public void doIt( ) {
// implementação padrão para reuso
implementation.doIt();
}
}
--uso da implementação (se não existe nenhuma outra superclass) --
//
class MyClass implements AnInterface extends AnInterfaceImplementation
{
:
}
// uso do código
class Application {
public static void main(String[] args) {
AnInterface x = new MyClass();
:
x.doIt();
}
}

package demo;
public class Base {
public int field1 = 1;
public int getField1( ) {
return field1;
}
}
--outro arquivo fonte-

package demo;
public class Derived extends Base {
public int field1 = 2;
public int getField1( ) {
return field1;
}
}
--outro arquivo fonte -import 
demo.*;
class Application {
public static void main( String arg[] ) {
Base b = new Base( );
Derived d = new Derived( );
// imprime: 1,2
System.out.println( b.field1 + "," + d.field1 );
// imprime: 1,2
System.out.println( b.getField1( ) + "," + d.getField1( ) );
b = d;
// imprime: 1,2
System.out.println( b.field1 + "," + d.field1 );
// imprime: 2,2
System.out.println( b.getField1( ) + "," + d.getField1( ) );
}
}
<source><![CDATA[
			</p>
			<p>	
				Diferente deste exemplo, atributos são normalmente declarados como private com métodos públicos 
				de acesso. Isto poderia resultar em resultados inesperados. 
				<br/>
<source><![CDATA[
package demo;
public class Base {
private int field1 = 1;
public int getField1( ) {
return field1;
}
}
--outro arquivo fonte--
package demo;
public class Derived extends Base {
private int field1 = 2;
public int getField1() {
return field1;
}
}
--outro arquivo fonte -import 
demo.*;
class Application {
public static void main(String arg[]) {
Base b = new Base();
Derived d = new Derived();
// erro de compilação
//System.out.println(b.field1 + "," + d.field1);
// imprime: 1,2
System.out.println(b.getField1() + "," + d.getField1());
b = d;
// erro de compilação
//System.out.println(b.field1 + "," + d.field1);
// imprime: 2,2
System.out.println(b.getField1() + "," + d.getField1());
}
}

class Base {
public int field1 = 1;
}
class Derived extends Base {
public int field1 = 2;
public void x() {
super.field1 = this.field1; (use assim) 
// prints: true 
System.out.println(((Base)this).field1 == this.field1);(Não 
use) 
} 
} 

package com.acme.dados;
public class MPC {
void method (int i, int j) {} // VIOLACAO
void j() {}
private int i = 0;
}

package com.acme.dados;
public class MPCFixed {
void method (int first, int second) {} // INDICADO
void j() {}
private int i = 0;
}

class Base {
private void foo() {
...
}
}
class Derived extends Base {
public void foo() {
...
}
}
class Application {
static void func() {
Derived d = new Derived(); 
Base b = d; 
// OK 
d.foo(); 
// erro de compilação
b.foo();
}
}

class MyClass {
// data member
private MyType data;
public MyType getData( ) {
return data;
}
public void setData( MyType newData ){
data = newData;
}
}

class MyClass {
// data atributo
private MyType data;
// data atributo
private MyType data2;
public MyType getData( ) {
return data;
}
protected void setData ( MyType newData ){
data = newData;
}
public MyType getData2( ) {
return data2;
}
private void setData2( MyType newData2 ) {
data2 = newData2;
}
}

class MyClass {
// data member
private String data;
public MyType getData( ) {
return data;
}
protected void setData ( String newData ){
data = newData;
}
// use setter padrão
public void setData(int newData ) {
setData(new String(newData));
}
}

abstract class MyClass {
// get
public abstract MyType data( );
// set
public abstract void data( MyType x );
}
class MySubClass extends MyClass {
AnotherType data;
public MyType getData( ) {
return ( MyType ) data;
}
public void setData( MyType x ) {
data = ( AnotherType )x;
}
}

package com.acme.dados; 
public class LEVEL { 
class Level1 { 
class Level2 { 
class Level3 { // VIOLACAO 
private boolean _isClosed = false;
}
private int _count = 0;
} 
private int _size = 0;
}
private int _length = 0;
} 

package com.acme.dados; 
public class LEVELFixed { 
class Level1 { 
class Level2 { 
private int _count = 0;
}
private int _size = 0;
} 
private int _length = 0; 
} 
Level3Fixed.java'
Segundo arquivo ': 
package com.acme.dados; 
class Level3Fixed { 
private boolean _isClosed = false; 
} 

import java.util.Vector;
// de Integers
class IntCollection {
protected Vector elements;
// bubble sort
public void sort( ) {
int i, j, size = elements.size();
// para cada elemento
for( i = 0; i < size -1; i++ ) {
// comparação
for( j = i + 1; j < size; j++ ) {
Integer t1 = (Integer)elements.elementAt( i );
Integer t2 = (Integer)elements.elementAt( j );
//
if( t1.intValue() t2.intValue( ) ) {
elements.setElement( i, t2 );
elements.setElement( j, t1 );
}
}
}
}
// adiciona elementos
public void add( int x ) {
elements.addElement( new Integer( x ) );
}
}
// de Strings
class StringCollection extends Collection {
protected Vector elements;
// bubble sort
public void sort( ) {
int i, j, size = _elements.size( );
// for each element 
for( i = 0; i < size -1; i++ ) { 
// compare against all others 
for( j = i + 1; j < size; j++ ) { 
String t1 = (String)_elements.elementAt( i ); 
String t2 = (String)_elements.elementAt( j ); 
// check reorder needed 
if(t1.compareTo( t2 ) 0) { 
// swap elements 
elements.setElement( i, t2 ); 
elements.setElement( j, t1 ); 
} 
} 
} 
} 
// adiciona elemento 
public void add( int x ) { 
elements.addElement( x ); 
} 
} 

import java.util.Vector; 
class List { 
private Vector elements; 
: 
// imprimir saída na stream 
public void print() { 
System.out.print("List("); 
for(int i = 0; i < elements.size(); i++) 
System.out.print((i == 0 ? "" : ", ") + 
elements.elementAt(i)); 
System.out.print(")"); 
} 
// imprimir erro na stream 
public void dump() { 
System.err.print("List("); 
for(int i = 0; i < elements.size(); i++) 
System.err.print((i == 0 ? "" : ", ") + 
elements.elementAt(i)); 
System.err.print(")"); 
} 
} 

import java.util.Vector;
import java.io.PrintStream;
class List {
private Vector elements;
:
protected void dumpOn(PrintStream s) {
s.print("List(");
for(int i = 0; i < elements.size(); i++)
s.print((i == 0 ? "" : ", ") + elements.elementAt(i));
s.print(")");
}
// imprime a saída em uma stream
public void print() {
dumpOn(System.out);
}
// imprime erro em uma stream
public void dump() {
dumpOn(System.err);
}
}

import java.io.*;
class SomeClass {
public void doIt(String name)throws Exception,FileNotFoundException { 
FileInputStream fis;
// declaração de IOException
// e FileNotFoundException
fis = new FileInputStream(name);
:
}
}
--ou -public 
void doIt(String name) {
try {
FileInputStream fis;
fis = new FileInputStream(name);
:
}
catch(IOException ex) {
// gerencia exception aqui
}
}
}

package com.acme.dados;
public class AECB {
public void method () {
try {
System.in.read ();
} catch (java.io.IOException e) {
// VIOLACAO
}
}
}

package com.acme.dados;
public class AECBFixed {
public void method () {
try {
System.in.read ();
} catch (java.io.IOException e) {
System.out.println("Descriptive error"); // INDICADO
}
}
}

import java.util.HashTable;
class SomeClass {
static HashTable dictionary;
int value;
:
public SomeClass(String key, int value) {
dictionary.put(key, (Object)new Integer(_value = value));
}
:
public void printKey(String key) {
:
System.out.println("Value of " + key + " is " +
(Integer)(dictionary.get(key)).intValue());
:
}
:
}

// :
public void printKey(String key) {
:
Integer i = _dictionary.get(key);
System.out.println("Value " + key + " is " + (i != null ?
i.intValue() "undefined");
:
}
// :

class SomeClass { 
: 
void someMethod() { 
// array de ints 
int[] intArray = new int[10] 
// array de Integers 
Integer[] integerArray = new Integer[10]; 
// vector de Objects (regardless of name)
Vector integerVector = new Vector();
intArray[0] = 1;
// erro de compilação
intArray[1] = new Integer(1);
// erro de compilação
integerArray[1] = 1;
integerArray[1] = new Integer(1);
// erro de compilação
integerVector.addElement(1);
integerVector.addElement(new Integer(1));
integerVector.addElement(new Integer(1).toString());
}
:
}

:
String x;
// objeto de algum tipo
Object o = new Blivit(...);
// x é "33" : gerado como Integer(1 + 2).toString() + "3"
x = 1 + 2 + "3";
// x é "123": gerado como ("1" + Integer(2).toString()) + 
Integer(3).toString() 
x = "1" + 2 + 3; 
// x is "123": gerado como ("1" + Integer(2).toString()) + 
Character('3').toString() 
x = "1" + 2 + '3'; 
// x é "15" : gerado como "1" + Integer(2 + 3).toString()
x = "1" + (2 + 3);
// x é "23" : gerado como ("" + Integer(2).toString()) + "3"
x = "" + 2 + "3";
// erro de compilação, + não defindo para os referente tipos
x = o + 1;
// erro de compilação, + não defindo para os referente tipos
x = 1 + o;
// x é "Blivit(...)1" : gerado como o.toString() +
Integer(1).toString()
x = o.toString() + 1;
// x é "1Blivit(...)" : gerado como "1" + o.toString()
x = "1" + o;
:

:
int[][] aai = new int[100][50];
--equivalente -int[][] 
aai = new int[100][];
// aai.length == 100
for(int temp = 0; temp < aai.length; temp++)
// aai[*].length == 50
aii[temp] = new int[50];
:

:
int[][] aai = new int[100][];
// aai.length == 100
for(int temp = 0; temp < aai.length; temp++)
// aai[0].length == 1
// aai[1].length == 2
// aai[2].length == 3
aii[temp] = new int[temp + 1];
:
// aai[99].length == 100

class SomeClass {
public static void initAII(int[][] aii) {
// check dimension 1
for(int i = 0; i < aii.length; i++)
// check each dimension 2
for(int j = 0; j < aii[i].length; j++)
aii[i][j] = i * j;
}
}

class Foo {
...
Connection conn = null;
Statement stmt = null
try {
conn = DriverManager.getConnection( url, user, pwd );
Statement stmt = con.createStatement( );
...
// sua lógica de negócio aqui
...
} catch (SQLException e) {
e.printStackTrace();
} finally {
// limpa todos os recursos usados no statement
stmt.close();
// limpa todos os recursos usados e fecha a sessão
conn.close();
}
}

package com.acme.dados;
public class DUN {
boolean method (boolean a, boolean b) { // VIOLACAO
if (!a)
return (!a && !b);
else
return !b;
}
}

package com.acme.dados;
public class DUNFixed {
boolean method (boolean a, boolean b) {
if (a)
return !b;
else
return (! (a || b) );
}
}

package com.acme.dados;
public class NFS {
static int max = 10;
int size = max; // VIOLACAO
}

package com.acme.dados;
class AFP {
void method (int[] a) {
a[0] = 0; // VIOLACAO 
} 
} 

package com.acme.dados;
class AFPFixed {
void method (int[] a) {
int[] copy = new int [a.length];
System.arraycopy (a, 0, copy, 0, a.length);
copy[0] = 0; // INDICADO
}
}

package com.acme.dados;
abstract class ASFI { // VIOLACAO
abstract void method();
final static String ID = "final static string";
}

package com.acme.dados;
interface ASFIFixed { // INDICADO
void method();
String ID = "MISC_ASFI";
// Não precisa definir "final static", isto esta implícito
}

package com.acme.dados;
public class CTOR {
public CTOR () {
_size = readSize(); // VIOLACAO
}
public int readSize () {
return fis.read ();
}
private FileInputStream fis = new FileInputStream ("data.out");
private int _size;
}

package com.acme.dados;
public class CTORFixed {
public CTORFixed () {
_size = readSize ();
}
private int readSize () { // INDICADO
return fis.read ();
}
private FileInputStream fis = new FileInputStream ("data.out");
private int _size;
}

package com.acme.dados;
public class ISEM {
public boolean isHello (String str) {
return (s != null && s.equals("Hello")); // VIOLACAO 
} 
} 

package com.acme.dados;
public class ISEMFixed {
public boolean isHello (String str) {
return "Hello".equals (str); // INDICADO
}
}

package com.acme.dados;
class ACDO {
void method () {
System.out.println (_s);
}
private String _s = new String ("ACDO"); // VIOLACAO
}

package com.acme.dados;
class ACDOFixed {
void method () {
System.out.println (_s);
}
private String _s = "ACDO"; // INDICADO
}

package com.acme.dados;
public class AUTP {
String foobar (int x) {
return new Integer (x).toString (); // VIOLACAO 
} 
} 

package com.acme.br;
class AUTPFixed {
String foobar (int x) {
return Integer.toString (x); // INDICADO
}
}

package com.acme.dados;
import java.util.Date;
public class DUD {
Date d[]; // VIOLACAO
}

package com.acme.dados;
import java.util.Date;
public class DUD {
long d[]; // INDICADO
}

package com.acme.dados;
import java.util.Vector;
public class STV {
public static Vector vector = new Vector (); // VIOLACAO
void addToVector () {
Object o = new Object ();
vector.add (o); // este objeto temporariamente não será liberado 
} 
} 

package com.acme.dados;
import java.util.Vector;
public class STVFixed {
public static void addToVector () {
// verifica o tamanho máximo do Vector antes de chamar 'add()'.
if (vector.size() < MAX_SIZE) { // INDICADO
Object o = new Object ();
vector.add(o);
}
else {
System.err.println("vector MAX_SIZE excedido.");
}
}
public static Vector vector = new Vector (5); // INDICADO
public static final int MAX_SIZE = 100;
}

package com.acme.dados;
public class AAS {
void method () {
int i = 0;
i = i -1; // VIOLACAO
}
}

package com.acme.dados;
public class AAS {
void method () {
int i = 0;
i -= 1;
}
}

package com.acme.dados;
import java.util.Vector;
class CEL {
void method (Vector vector) {
for (int i = 0; i < vector.size (); i++) // VIOLACAO
{
System.out.println(i);
}
}
}

package com.acme.dados;
class CELFixed {
void method (Vector vector) {
int size = vector.size ();
for (int i = 0; i < size; i++) // INDICADO
{
System.out.println(i);
}
}
}

package com.acme.dados;
public class IF {
public int method (boolean isDone) {
if (isDone) // VIOLACAO
return 0;
else
return 10;
}
}

public class IFFixed {
public int method (boolean isDone) {
return isDone ? 0 : 10;
}
}

package com.acme.dados;
public class IFAS {
void method(boolean isTrue) {
if (isTrue) // VIOLACAO
_value = 0;
else
_value = 1;
}
private int _value = 0;
}

package examples.Regras.opt;
public class IFASFixed {
void method(boolean isTrue) {
_value = (isTrue ? 0 : 1); // INDICADO
}
private int _value = 0;
}

package com.acme.dados;
public class PCTS {
private void method(String s) {
if (s.startsWith("a")) // VIOLACAO
System.out.println("starts with a.");
}
}

package examples.Regras.opt;
public class PCTSFixed {
private void method(String s) {
if (s.length () > 0 && s.charAt(0) == 'a') // INDICADO
System.out.println("starts with a.");
}
}

package com.acme.dados;
public class SYN {
public synchronized void method () {
}
private void test () {
for (int i = 0; i < 100; i++) {
method (); // VIOLACAO 
} 
} 
} 

package com.acme.dados;
import java.io.FileInputStream;
public class TRY {
void method (FileInputStream fis) {
for (int i = 0; i < size; i++) {
try { // VIOLACAO
_sum += fis.read ();
} catch (Exception e) {}
}
}
private int _sum;
}

package com.acme.dados;
import java.io.FileInputStream;
public class TRY {
void method (FileInputStream fis) {
try { // INDICADO
for (int i = 0; i < size; i++) {
_sum += fis.read ();
}
} catch (Exception e) {}
}
}

package com.acme.dados;
class UNC {
String _id = "UNC";
}
class Dog extends UNC {
void method () {
Dog dog = new Dog (); 
UNC animal = (UNC)dog; // VIOLACAO 
Object o = (Object)dog; // VIOLACAO 
} 
} 

class DogFixed extends UNC {
void method () {
Dog dog = new Dog();
UNC animal = dog; // INDICADO
Object o = dog; // INDICADO
}
}

package com.acme.dados;
public class USV {
void addSum (int[] values) {
for (int i=0; i < value.length; i++)
_sum += value[i]; // VIOLACAO.
}
private int _sum;
}

package com.acme.dados;
public class USVFixed {
void addSum (int[] values) {
int sum = _sum; // variavel local temporaria.
for (int i=0; i < value.length; i++)
sum += value[i];
_sum = sum;
}
private int _sum;
}