ObjectOutputStream oos = new ObjectOutputStream(
    new FileOutputStream("SerialOutput"));
oos.writeObject(someObject);
oos.flush();

ObjectInputStream ois = new ObjectInputStream(
    new FileInputStream("SerialOutput"));
someObject = (SomeClass) ois.readObject();

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

class Assign {  
    public synchronized void doSomething() {  
        // If in Thread 1, perform Thread 1 actions  
        x = 1;  
        y = 2;  
        // If in Thread 2, perform Thread 2 actions  
        r1 = y;  
        r2 = x;  
    }  
} 

class Assign {  
    public void doSomething() {  
        synchronized (this) {  
            // If in Thread 1, perform Thread 1 actions  
            x = 1;  
            y = 2;  
            // If in Thread 2, perform Thread 2 actions  
            r1 = y;  
            r2 = x;  
        }  
    }  
} 

    public void doPrivilegedAction(String username, char[] password) throws SQLException 
    {
        Connection connection = getConnection();
        if (connection == null) 
        {
            // Handle error
        }

        try
        {
            String pwd = hashPassword(password);
            String sqlString = "SELECT * FROM db_user WHERE username = '"
                               + username +
                               "' AND password = '" + pwd + "'";
            Statement stmt = connection.createStatement();

            ResultSet rs = stmt.executeQuery(sqlString);
            if (!rs.next()) 
            {
                throw new SecurityException("User name or password incorrect");
            }

            // Authenticated; proceed
        }
        finally 
        {
            try 
            {
                connection.close();
            } 
            catch (SQLException x) 
            {
                // Forward to handler
            }
        }
    }

    public void doPrivilegedAction(String username, char[] password) throws SQLException
    {
        Connection connection = getConnection();
        if (connection == null) 
        {
            // Handle error
        }

        try
        {
            String pwd = hashPassword(password);
            // Validate username length
            if (username.length() > 8) 
            {
                // Handle error
            }

            String sqlString = "SELECT * FROM db_user WHERE username=? AND password=?";
            PreparedStatement stmt = connection.prepareStatement(sqlString);
            stmt.setString(1, username);
            stmt.setString(2, pwd);

            ResultSet rs = stmt.executeQuery();
            if (!rs.next()) 
            {
                throw new SecurityException("User name or password incorrect");
            }

            // Authenticated; proceed
        }
        finally 
        {
            try 
            {
                connection.close();
            } 
            catch (SQLException x) 
            {
                // Forward to handler
            }
        }
    }

class Format 
{
    static Calendar c = new GregorianCalendar(1995, GregorianCalendar.MAY, 23);

    public static void main(String[] args)
    {  
        // args[0] should contain the credit card expiration date
        // but might contain %1$tm, %1$te or %1$tY format specifiers
        System.out.format(args[0] + " did not match! HINT: It was issued on %1$terd of some month", c);
    }
}

class Format 
{
    static Calendar c = new GregorianCalendar(1995, GregorianCalendar.MAY, 23);

    public static void main(String[] args)
    {
        // args[0] is the credit card expiration date
        // Perform comparison with c, 
        // if it doesn't match, print the following line
        System.out.format("%s did not match! HINT: It was issued on %terd of some month", args[0], c);
    }
}

class DirList 
{
    public static void main(String[] args) throws Exception 
    {
        String dir = System.getProperty("dir");
        Runtime rt = Runtime.getRuntime();
        Process proc = rt.exec("cmd.exe /C dir " + dir);
        int result = proc.waitFor();
        if (result != 0) 
        {
            System.out.println("process error: " + result);
        }

        InputStream in = (result == 0) ? proc.getInputStream() : proc.getErrorStream();
        int c;
        while ((c = in.read()) != -1) 
        {
            System.out.print((char) c);
        }
    }
}

import java.io.File;

class DirList
{
    public static void main(String[] args) throws Exception 
    {
        File dir = new File(System.getProperty("dir"));
        if (!dir.isDirectory()) 
        {
            System.out.println("Not a directory");
        }
        else
        {
            for (String file : dir.list()) 
            {
                System.out.println(file);
            }
        }
    }
}

    public void deleteFile()
    {
        File someFile = new File("someFileName.txt");
        // Do something with someFile
        someFile.delete();
    }

    public void deleteFile()
    {
        File someFile = new File("someFileName.txt");
        // Do something with someFile
        if (!someFile.delete()) 
        {
            // Handle failure to delete the file
        }
    }

public class Replace
{
    public static void main(String[] args) 
    {
        String original = "insecure";
        original.replace('i', '9');
        System.out.println(original);
    }
}

public class Replace
{
    public static void main(String[] args) 
    {
        String original = "insecure";
        original = original.replace('i', '9');
        System.out.println(original);
    }
}

    public void arrayEqualsExample()
    {
        int[] arr1 = new int[20];
        int[] arr2 = new int[20];
        System.out.println(arr1.equals(arr2));
    }

    public void arrayEqualsExample()
    {
        int[] arr1 = new int[20];
        int[] arr2 = new int[20];
        System.out.println(Arrays.equals(arr1, arr2));
    }

public class Wrapper 
{
    public static void main(String[] args) 
    {
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 1000;
        Integer i4 = 1000;

        System.out.println(i1 == i2);
        System.out.println(i1 != i2);
        System.out.println(i3 == i4);
        System.out.println(i3 != i4);
    }
}

true
false
false
true

public class Wrapper 
{
    public static void main(String[] args) 
    {
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 1000;
        Integer i4 = 1000;

        System.out.println(i1.equals(i2));
        System.out.println(!i1.equals(i2));
        System.out.println(i3.equals(i4));
        System.out.println(!i3.equals(i4));
    }
}

true
false
true
false

class Account
{ 
    // Maintains all banking-related data such as account balance
    private double balance = 100;

    boolean withdraw(double amount) 
    {
        if ((balance - amount) >= 0) 
        {
            balance -= amount;
            System.out.println("Withdrawal successful. The balance is : " + balance);
            return true;
        }

        return false;
    }
}

public class BankAccount extends Account
{
    // Subclass handles authentication
    @Override
    boolean withdraw(double amount) 
    {
        if (!securityCheck()) 
        {
            throw new IllegalAccessException();
        }
    
        return super.withdraw(amount);
    }

    private final boolean securityCheck() 
    {
        // Check that account management may proceed
    }
}

public class Client 
{
    public static void main(String[] args) 
    {
        Account account = new BankAccount();

        // Enforce security manager check
        boolean result = account.withdraw(200.0);   
        System.out.println("Withdrawal successful? " + result);
    }
}

class Account 
{ 
    // Maintains all banking-related data such as account balance
    private double balance = 100;

    boolean overdraft() 
    {
        balance += 300;     // Add 300 in case there is an overdraft
        System.out.println("Added back-up amount. The balance is :" + balance);
        return true;
    }

    // Other Account methods
}

public class BankAccount extends Account
{
    // Unchanged
}

public class Client 
{
    public static void main(String[] args) 
    {
        Account account = new BankAccount();

        // Enforce security manager check
        boolean result = account.withdraw(200.0);
        if (!result) 
        {
            result = account.overdraft();
        }
        System.out.println("Withdrawal successful? " + result);
    }
}

public class BankAccount extends Account 
{
    // ...

    @Override boolean overdraft()
    {
        throw new IllegalAccessException();
    }
}

class MutableClass 
{
    private Date d;

    public MutableClass() 
    {
        d = new Date();
    }

    public Date getDate() 
    {
        return d;
    }
}

    public Date getDate() 
    {
        return (Date)d.clone();
    }

class MutableClass 
{
    private Date[] dates;

    public MutableClass() 
    {
        dates = new Date[20];
        for (int i = 0; i < dates.length; i++) 
        {
            dates[i] = new Date();
        }
    }

    public Date[] getDates() 
    {
        return (Date[])dates.clone();
    }
}

class MutableClass 
{
    private Date[] dates;

    public MutableClass() 
    {
        dates = new Date[20];
        for (int i = 0; i < dates.length; i++) 
        {
            dates[i] = new Date();
        }
    }

    public Date[] getDates() 
    {
        Date[] copiedDates = new Date[dates.length];
        for (int i = 0; i < dates.length; i++)
        {
            copiedDates = (Date) date[i].clone();
        }
        return copiedDates;
    }
}

public final class MutableDemo 
{
    // java.net.HttpCookie is mutable
    public void useMutableInput(HttpCookie cookie) 
    {
        if (cookie == null) 
        {
            throw new NullPointerException();
        }

        // Check whether cookie has expired
        if (cookie.hasExpired()) 
        {
            // Cookie is no longer valid; handle condition by throwing an exception
        }

        doLogic(cookie);
    }
}

public final class MutableDemo 
{
    // java.net.HttpCookie is mutable
    public void useMutableInput(HttpCookie cookie) 
    {
        if (cookie == null) 
        {
            throw new NullPointerException();
        }

        // Create copy
        cookie = (HttpCookie)cookie.clone();

        // Check whether cookie has expired
        if (cookie.hasExpired()) 
        {
            // Cookie is no longer valid; handle condition by throwing an exception
        }
 
        doLogic(cookie);
    }
}

class Coordinates 
{
    private int x;
    private int y;

    public class Point 
    {
        public void getPoint() 
        {
            System.out.println("(" + x + "," + y + ")");
        }
    }
}

class AnotherClass 
{
    public static void main(String[] args) 
    {
        Coordinates c = new Coordinates();
        Coordinates.Point p = c.new Point();
        p.getPoint();
    }
}

class Coordinates 
{
    private int x;
    private int y;

    private class Point 
    {
        private void getPoint() 
        {
            System.out.println("(" + x + "," + y + ")");
        }
    }
}

class AnotherClass 
{
    public static void main(String[] args) 
    {
        Coordinates c = new Coordinates();
        Coordinates.Point p = c.new Point(); // Fails to compile
        p.getPoint();
    }
}

    // Determine whether objects x and y have the same class name
    if (x.getClass().getName().equals(y.getClass().getName())) 
    {
        // Objects have the same class
    }

    // Determine whether objects x and y have the same class
    if (x.getClass() == y.getClass()) 
    {
        // Objects have the same class
    }

    public void readSensitiveFile() 
    {
        try 
        {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) 
            {  
                // Check for permission to read file
                sm.checkRead("/temp/tempFile");
            }

            // Access the file
        }
        catch (SecurityException se) 
        {
            // Log exception
        }
    }

    public final void readSensitiveFile() 
    {
        try 
        {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) 
            {  
                // Check for permission to read file
                sm.checkRead("/temp/tempFile");
            }

            // Access the file
        }
        catch (SecurityException se) 
        {
            // Log exception
        }
    }

    private void readSensitiveFile() 
    {
        try 
        {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) 
            {  
                // Check for permission to read file
                sm.checkRead("/temp/tempFile");
            }

            // Access the file
        }
        catch (SecurityException se) 
        {
            // Log exception
        }
    }

class Super 
{
    protected void doLogic() 
    {
        System.out.println("Super invoked");
    }
}

public class Sub extends Super 
{
    public void doLogic() 
    {
        System.out.println("Sub invoked");
    
        // Do sensitive operations
    }
}

class Super 
{
    protected final void doLogic() //  Declare as final
    {
        System.out.println("Super invoked");
    }
}

public final class CaseInsensitiveString 
{
    private String s;
    
    public CaseInsensitiveString(String s) 
    {
        if (s == null) 
        {
            throw new NullPointerException();
        }

        this.s = s;
    }

    public boolean equals(Object o) 
    {
        if (o instanceof CaseInsensitiveString) 
        {
            return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
        }

        if (o instanceof String) 
        {
            return s.equalsIgnoreCase((String)o);
        }

        return false;
    }

    // Comply with MET09-J
    public int hashCode() {/* ... */}

    public static void main(String[] args) 
    {
        CaseInsensitiveString cis = new CaseInsensitiveString("Java");
        String s = "java";
        System.out.println(cis.equals(s));
        System.out.println(s.equals(cis));
    }
}

true
false

public final class CaseInsensitiveString 
{
    private String s;
    
    public CaseInsensitiveString(String s) 
    {
        if (s == null) 
        {
            throw new NullPointerException();
        }

        this.s = s;
    }

    public boolean equals(Object o) 
    {
        return o instanceof CaseInsensitiveString && ((CaseInsensitiveString)o).s.equalsIgnoreCase(s);
    }

    // Comply with MET09-J
    public int hashCode() {/* ... */}

    public static void main(String[] args) 
    {
        CaseInsensitiveString cis = new CaseInsensitiveString("Java");
        String s = "java";
        System.out.println(cis.equals(s));
        System.out.println(s.equals(cis));
    }
}

false
false

public class Card 
{
    private final int number;

    public Card(int number) 
    {
        this.number = number;
    }

    public boolean equals(Object o) 
    {
        if (!(o instanceof Card)) 
        {
            return false;
        }

        Card c = (Card)o;
        return c.number == number;
    }

    public int hashCode() {/* ... */}
}

class XCard extends Card 
{
    private String type;

    public XCard(int number, String type) 
    {
        super(number);
        this.type = type;
    }

    public boolean equals(Object o) 
    {
        if (!(o instanceof Card)) 
        {
            return false;
        }

        // Normal Card, do not compare type
        if (!(o instanceof XCard))
        {
            return o.equals(this);
        }

        // It is an XCard, compare type as well
        XCard xc = (XCard)o;
        return super.equals(o) && xc.type == type;
    }
 
    public int hashCode() {/* ... */}

    public static void main(String[] args) 
    {
        XCard p1 = new XCard(1, "type1");
        Card p2 = new Card(1);
        XCard p3 = new XCard(1, "type2");
        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));
        System.out.println(p1.equals(p3));
    }
}

true
true
false

class XCard 
{
    private String type;
    private Card card; // Composition

    public XCard(int number, String type) 
    {
        card = new Card(number);
        this.type = type;
    }

    public Card viewCard() 
    {
        return card;
    }

    public boolean equals(Object o) 
    {
        if (!(o instanceof XCard)) 
        {
            return false;
        }

        XCard cp = (XCard)o;
        return cp.card.equals(card) && cp.type.equals(type);
    }
  
    public int hashCode() {/* ... */}

    public static void main(String[] args) 
    {
        XCard p1 = new XCard(1, "type1");
        Card p2 = new Card(1);
        XCard p3 = new XCard(1, "type2");
        XCard p4 = new XCard(1, "type1");

        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));
        System.out.println(p1.equals(p3));
        System.out.println(p1.equals(p4));
    }
}

false
false
false
true

public final class CreditCard 
{
    private final int number;

    public CreditCard(int number) 
    {
        this.number = number;
    }

    public boolean equals(Object o) 
    {
        if (o == this) 
        {
            return true;
        } 

        if (!(o instanceof CreditCard)) 
        {
            return false;
        }

        CreditCard cc = (CreditCard)o;
        return cc.number == number; 
    }

    public static void main(String[] args) 
    {
        Map<CreditCard, String> m = new HashMap<CreditCard, String>();
        m.put(new CreditCard(100), "4111111111111111");
        System.out.println(m.get(new CreditCard(100)));  
    }
}

public final class CreditCard 
{
    private final int number;

    public CreditCard(int number) 
    {
        this.number = number;
    }

    public boolean equals(Object o) 
    {
        if (o == this) 
        {
            return true;
        } 

        if (!(o instanceof CreditCard)) 
        {
            return false;
        }

        CreditCard cc = (CreditCard)o;
        return cc.number == number; 
    }

    public int hashCode() 
    {
        int result = 17;
        result = 31 * result + number;
        return result;
    }

    public static void main(String[] args) 
    {
        Map<CreditCard, String> m = new HashMap<CreditCard, String>();
        m.put(new CreditCard(100), "4111111111111111");
        System.out.println(m.get(new CreditCard(100)));  
    }
}

    try
    {
        // ...
    }
    catch (SecurityException se) 
    {
        System.err.println(se);
        // Recover from exception
    }

    try
    {
        // ...
    }
    catch (SecurityException se) 
    {
        logger.log(Level.SEVERE, se);
        // Recover from exception
    }

class Dimensions 
{
    private int length;
    private int width;
    private int height;

    static public final int PADDING = 2;
    static public final int MAX_DIMENSION = 10;

    public Dimensions(int length, int width, int height) 
    {
        this.length = length;
        this.width = width;
        this.height = height;
    }

    protected int getVolumePackage(int weight)
    {
        length += PADDING;
        width  += PADDING;
        height += PADDING;

        try 
        {
            if (length <= PADDING || width <= PADDING || height <= PADDING 
                || length > MAX_DIMENSION + PADDING 
                || width > MAX_DIMENSION + PADDING 
                || height > MAX_DIMENSION + PADDING 
                || weight <= 0 || weight > 20) 
            {
                throw new IllegalArgumentException();
            }

            int volume = length * width * height;
            length -= PADDING;
            width -= PADDING; 
            height -= PADDING; // Revert

            return volume;
        }
        catch (Throwable t) 
        {
            MyExceptionReporter mer = new MyExceptionReporter();
            mer.report(t); // Sanitize
            return -1; // Non-positive error code
        }
    }
 
    public static void main(String[] args) 
    {
        Dimensions d = new Dimensions(8, 8, 8);
        System.out.println(d.getVolumePackage(21));
        System.out.println(d.getVolumePackage(19));
    }
}

-1
1728 // 1728 (12x12x12) instead of 1000 (10x10x10)

    protected int getVolumePackage(int weight)
    {
        length += PADDING;
        width  += PADDING;
        height += PADDING;

        try 
        {
            if (length <= PADDING || width <= PADDING || height <= PADDING 
                || length > MAX_DIMENSION + PADDING 
                || width > MAX_DIMENSION + PADDING 
                || height > MAX_DIMENSION + PADDING 
                || weight <= 0 || weight > 20) 
            {
                throw new IllegalArgumentException();
            }

            int volume = length * width * height;

            // Revert
            length -= PADDING;
            width -= PADDING; 
            height -= PADDING;

            return volume;
        }
        catch (Throwable t) 
        {
            MyExceptionReporter mer = new MyExceptionReporter();
            mer.report(t); // Sanitize
            
            // Revert
            length -= PADDING; 
            width -= PADDING; 
            height -= PADDING;

            return -1; // Non-positive error code
        }
    }

    protected int getVolumePackage(int weight)
    {
        length += PADDING;
        width  += PADDING;
        height += PADDING;

        try 
        {
            if (length <= PADDING || width <= PADDING || height <= PADDING 
                || length > MAX_DIMENSION + PADDING 
                || width > MAX_DIMENSION + PADDING 
                || height > MAX_DIMENSION + PADDING 
                || weight <= 0 || weight > 20) 
            {
                throw new IllegalArgumentException();
            }

            int volume = length * width * height;
            return volume;
        }
        catch (Throwable t) 
        {
            MyExceptionReporter mer = new MyExceptionReporter();
            mer.report(t); // Sanitize
            return -1; // Non-positive error code
        }
        finally
        {
            // Revert
            length -= PADDING;
            width -= PADDING; 
            height -= PADDING;
        }
    }

    protected int getVolumePackage(int weight)
    {
        try 
        {
            // Validate first
            if (length <= 0 || width <= 0 || height <= 0 
                || length > MAX_DIMENSION || width > MAX_DIMENSION || height > MAX_DIMENSION 
                || weight <= 0 || weight > 20) 
            {
              throw new IllegalArgumentException(); 
            }
        }
        catch (Throwable t)
        {
            MyExceptionReporter mer = new MyExceptionReporter();
            mer.report(t); // Sanitize
            return -1;
        }

        length += PADDING;
        width  += PADDING;
        height += PADDING;

        int volume = length * width * height;

        length -= PADDING;
        width -= PADDING; 
        height -= PADDING;
        
        return volume;
    }

    protected int getVolumePackage(int weight)
    {
        try 
        {
            // Validate first
            if (length <= 0 || width <= 0 || height <= 0 
                || length > MAX_DIMENSION || width > MAX_DIMENSION || height > MAX_DIMENSION 
                || weight <= 0 || weight > 20) 
            {
              throw new IllegalArgumentException(); 
            }
        }
        catch (Throwable t)
        {
            MyExceptionReporter mer = new MyExceptionReporter();
            mer.report(t); // Sanitize
            return -1;
        }

        int volume = (length + PADDING) * (width + PADDING) * (height + PADDING);
        return volume;
    }

class TryFinally
{
    private static boolean doLogic() 
    {
        try 
        {
            throw new IllegalStateException();
        } 
        finally
        {
            System.out.println("logic done");
            return true;
        }
    }
}

class TryFinally
{
    private static boolean doLogic() 
    {
        try 
        {
            throw new IllegalStateException();
        } 
        finally
        {
            System.out.println("logic done");
        }

        // Any return statements must go here; 
        // applicable only when exception is thrown conditionally
    }
}

public class Operation 
{
    public static void doOperation(String some_file) 
    {
        // ... Code to check or set character encoding ...
        try 
        {
            BufferedReader reader = new BufferedReader(new FileReader(some_file));
      
            try 
            {
                // Do operations 
            }
            finally
            {
                reader.close();
                // ... Other cleanup code ...
            }

        }
        catch (IOException x)
        {
            // Forward to handler
        }
    }
}

public class Operation 
{
    public static void doOperation(String some_file) 
    {
        // ... Code to check or set character encoding ...
        try 
        {
            BufferedReader reader = new BufferedReader(new FileReader(some_file));
      
            try 
            {
                // Do operations 
            }
            finally
            {
                try
                {
                    reader.close();
                }
                catch (IOException ie)
                {
                    // Forward to handle
                }

                // ... Other cleanup code ...
            }

        }
        catch (IOException x)
        {
            // Forward to handler
        }
    }
}

public class Operation 
{
    public static void doOperation(String some_file) 
    {
        // ... Code to check or set character encoding ...

        // try-with-resources
        try (BufferedReader reader = new BufferedReader(new FileReader(some_file))) 
        {
            // Do operations
        }
        catch (IOException ex)
        {
            System.err.println("thrown exception: " + ex.toString());
            Throwable[] suppressed = ex.getSuppressed();
            for (int i = 0; i < suppressed.length; i++)
            {
                System.err.println("suppressed exception: " + suppressed[i].toString());
            }

            // Forward to handler
        }
    }
}

    boolean isCapitalized(String s) 
    {
        if (s == null) 
        {
            throw new RuntimeException("Null String");
        }

        if (s.equals("")) 
        {
            return true;
        }

        String first = s.substring(0, 1);
        String rest = s.substring(1);
        return (first.equals(first.toUpperCase()) && rest.equals(rest.toLowerCase()));
    }

    boolean isCapitalized(String s) 
    {
        if (s == null) 
        {
            throw new NullPointerException();
        }

        if (s.equals("")) 
        {
            return true;
        }

        String first = s.substring(0, 1);
        String rest = s.substring(1);
        return (first.equals(first.toUpperCase()) && rest.equals(rest.toLowerCase()));
    }

    boolean isName(String s) 
    {
        try 
        {
            String names[] = s.split(" ");
            if (names.length != 2)
            {
                return false;
            }

            return (isCapitalized(names[0]) && isCapitalized(names[1]));
        }
        catch (NullPointerException e) 
        {
            return false;
        }
    }

    boolean isCapitalized(String s) 
    {
        if (s == null) 
        {
            return false;
        }

        if (s.equals("")) 
        {
            return true;
        }

        String first = s.substring(0, 1);
        String rest = s.substring(1);
        return (first.equals(first.toUpperCase()) && rest.equals(rest.toLowerCase()));
    }

final class ControlledStop implements Runnable 
{
    private boolean done = false;
    
    @Override
    public void run()
    {
        while (!done) 
        {
            try
            {
                // ...
                Thread.currentThread().sleep(1000); // Do something
            }
            catch(InterruptedException ie)
            { 
                Thread.currentThread().interrupt(); // Reset interrupted status
            } 
        }    
    }

    public void shutdown() 
    {
        done = true;
    }
}

final class ControlledStop implements Runnable 
{
    private volatile boolean done = false;
    
    @Override
    public void run()
    {
        while (!done) 
        {
            try
            {
                // ...
                Thread.currentThread().sleep(1000); // Do something
            }
            catch(InterruptedException ie)
            { 
                Thread.currentThread().interrupt(); // Reset interrupted status
            } 
        }    
    }

    public void shutdown() 
    {
        done = true;
    }
}

final class ControlledStop implements Runnable 
{
    private final AtomicBoolean done = new AtomicBoolean(false);
    
    @Override
    public void run()
    {
        while (!done.get()) 
        {
            try
            {
                // ...
                Thread.currentThread().sleep(1000); // Do something
            }
            catch(InterruptedException ie)
            { 
                Thread.currentThread().interrupt(); // Reset interrupted status
            } 
        }    
    }

    public void shutdown() 
    {
        done.set(true);
    }
}

final class ControlledStop implements Runnable 
{
    private boolean done = false;
    
    @Override
    public void run()
    {
        while (!isDone()) 
        {
            try
            {
                // ...
                Thread.currentThread().sleep(1000); // Do something
            }
            catch(InterruptedException ie)
            { 
                Thread.currentThread().interrupt(); // Reset interrupted status
            } 
        }    
    }

    public synchronized boolean isDone()
    {
        return done;
    }

    public synchronized void shutdown() 
    {
        done = true;
    }
}

// Immutable Helper
public final class Helper 
{
    private final int n;

    public Helper(int n)
    {
        this.n = n;
    }
}

final class Foo 
{
    private Helper helper;

    public Helper getHelper() 
    {
        return helper;
    }

    public void setHelper(int num) 
    {
        helper = new Helper(num);
    }
}

final class Foo 
{
    private volatile Helper helper;

    public Helper getHelper() 
    {
        return helper;
    }

    public void setHelper(int num) 
    {
        helper = new Helper(num);
    }
}

final class Foo 
{
    private AtomicReference<Helper> helperRef = new AtomicReference<>();

    public Helper getHelper() 
    {
        return helperRef.get();
    }

    public void setHelper(int num) 
    {
        helperRef.set(new Helper(num));
    }
}

final class Foo 
{
    private Helper helper;

    public synchronized Helper getHelper() 
    {
        return helper;
    }

    public synchronized void setHelper(int num) 
    {
        helper = new Helper(num);
    }
}

final class Flag 
{
    private boolean flag = true;

    public void toggle()
    {
        flag = !flag;
    }

    public boolean getFlag() 
    {
        return flag;
    }
}

final class Flag 
{
    private volatile boolean flag = true;

    public void toggle()
    {
        flag = !flag;
    }

    public boolean getFlag() 
    {
        return flag;
    }
}

final class Flag 
{
    private boolean flag = true;

    public synchronized void toggle()
    {
        flag = !flag;
    }

    public synchronized boolean getFlag() 
    {
        return flag;
    }
}

final class Flag 
{
    private volatile boolean flag = true;

    public synchronized void toggle()
    {
        flag = !flag;
    }

    public boolean getFlag() 
    {
        return flag;
    }
}

final class Flag 
{
    private boolean flag = true;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();
    
    public void toggle() 
    {
        writeLock.lock();
        try 
        {
            flag = !flag;
        } 
        finally 
        {
            writeLock.unlock();
        }
    }

    public boolean getFlag() 
    {
        readLock.lock();
        try
        {
            return flag;
        }
        finally 
        {
            readLock.unlock();
        }
    }
}

final class Flag 
{
    private AtomicBoolean flag = new AtomicBoolean(true);
        
    public void toggle()
    {
        boolean temp;
        do
        {
            temp = flag.get();
        }
        while (!flag.compareAndSet(temp, !temp));
    }

    public AtomicBoolean getFlag() 
    {
        return flag;
    }
}

final class Adder
{
    private final AtomicReference<BigInteger> first;
    private final AtomicReference<BigInteger> second;

    public Adder(BigInteger f, BigInteger s) 
    {
        first  = new AtomicReference<BigInteger>(f);
        second = new AtomicReference<BigInteger>(s);
    }

    public void update(BigInteger f, BigInteger s) 
    {
        first.set(f);
        second.set(s);
    }

    public BigInteger add()
    {
        return first.get().add(second.get());
    }
}

final class Adder
{
    private final AtomicReference<BigInteger> first;
    private final AtomicReference<BigInteger> second;

    public Adder(BigInteger f, BigInteger s) 
    {
        first  = new AtomicReference<BigInteger>(f);
        second = new AtomicReference<BigInteger>(s);
    }

    public synchronized void update(BigInteger f, BigInteger s) 
    {
        first.set(f);
        second.set(s);
    }

    public synchronized BigInteger add()
    {
        return first.get().add(second.get());
    }
}

final class KeyedCounter 
{
    private final Map<String, Integer> map = Collections.synchronizedMap(new HashMap<String, Integer>());

    public void increment(String key)
    {
        Integer old = map.get(key);
        int oldValue = (old == null) ? 0 : old.intValue();
        if (oldValue == Integer.MAX_VALUE) 
        {
            throw new ArithmeticException("Out of range");
        }
        map.put( key, oldValue + 1);
    }

    public Integer getCount(String key) 
    {
        return map.get(key);
    }
}

final class KeyedCounter
{
    private final Map<String, Integer> map = new HashMap<String, Integer>();
    private final Object lock = new Object();

    public void increment(String key) 
    {
        synchronized (lock) 
        {
            Integer old = map.get(key);
            int oldValue = (old == null) ? 0 : old.intValue();
            if (oldValue == Integer.MAX_VALUE) 
            {
                throw new ArithmeticException("Out of range");
            }
            map.put(key, oldValue + 1);
        }
    }

    public Integer getCount(String key) 
    {
        synchronized (lock) 
        {
            return map.get(key);
        }
    }
}

final class KeyedCounter 
{
    private final ConcurrentMap<String, AtomicInteger> map = new ConcurrentHashMap<String, AtomicInteger>();
    private final Object lock = new Object();

    public void increment(String key) 
    {
        AtomicInteger value = new AtomicInteger();
        AtomicInteger old = map.putIfAbsent(key, value);
        if (old != null) 
        {
            value = old;
        }

        synchronized (lock) 
        {
            if (value.get() == Integer.MAX_VALUE) 
            {
                throw new ArithmeticException("Out of range");
            }

            value.incrementAndGet(); // Increment the value atomically
        }
    }

    public Integer getCount(String key) 
    {
        AtomicInteger value = map.get(key);
        return (value == null) ? null : value.get();
    }
 
    // Other accessors ...
}

class LongContainer 
{
    private long i = 0;
    
    void assignValue(long j)
    {
        i = j;
    }

    void printLong() 
    {
        System.out.println("i = " + i);
    }
}

class LongContainer 
{
    private volatile long i = 0;
    
    void assignValue(long j)
    {
        i = j;
    }

    void printLong() 
    {
        System.out.println("i = " + i);
    }
}

public class SomeObject
{
    public synchronized void changeValue() 
    { 
        // ...
    }

    public static SomeObject lookup(String name) 
    {
        // ...
    }
}

// Untrusted code
String name = // ...
SomeObject someObject = SomeObject.lookup(name);
if (someObject == null) 
{
    // ... handle error
}

synchronized (someObject)
{
    while (true) 
    {
        Thread.sleep(Integer.MAX_VALUE); // Indefinitely lock someObject
    }
}

public class SomeObject
{
    private final Object lock = new Object(); //private final lock object

    public void changeValue() 
    { 
        synchronized (lock)  // Locks on the private Object
        {
            // ...
        }
    }
}

public class SomeObject 
{
    public static synchronized void changeValue() 
    {
        // ...
    }
}

// Untrusted code
synchronized (SomeObject.class) 
{
    while (true) 
    {
        Thread.sleep(Integer.MAX_VALUE); // Indefinitely delay someObject
    }
}

public class SomeObject
{
    private static final Object lock = new Object();

    public void changeValue() 
    { 
        synchronized (lock)  // Locks on the private Object
        {
            // ...
        }
    }
}

private int count = 0;
private final Integer lock = count;

public void doSomething()
{
    synchronized (Lock) 
    {
        // ...
    }
}

private int count = 0;
private final Integer lock = new Integer(count);

public void doSomething()
{
    synchronized (lock) 
    {
        // ...
    }
}

private final String lock = "LOCK";

public void doSomething() 
{
    synchronized (lock) 
    {
        // ...
    }
}

private final String lock = new String("LOCK");

public void doSomething() 
{
    synchronized (lock) 
    {
        // ...
    }
}

private final Lock lock = new ReentrantLock();

public void doSomething()
{
    synchronized(lock) 
    {
        // ...
    }
}

private final Lock lock = new ReentrantLock();

public void doSomething()
{
    lock.lock();

    try 
    {
        // ...
    }
    finally
    {
        lock.unlock();
    }
}

public final class CountHits 
{
    private static int counter;

    public void incrementCounter()
    {
        counter++;
    }
}

public final class CountHits 
{
    private static int counter;
    private static final Object lock = new Object();

    public void incrementCounter()
    {
        synchronized (lock) 
        {
            counter++;
        }
    }
}

public final class CountBoxes implements Runnable
{
    private static volatile int counter;
    // ...
    private final Object lock = new Object();

    @Override
    public void run()
    {
        synchronized (lock) 
        {
            counter++;
            // ...
        }
    }

    public static void main(String[] args) 
    {
        for (int i = 0; i < 2; i++) 
        {
            new Thread(new CountBoxes()).start();
        }
    }
}

public final class CountBoxes implements Runnable
{
    private static volatile int counter;
    // ...
    private final Object lock = new Object();

    public synchronized void run()
    {
        counter++;
    }
    // ...
}

public class CountBoxes implements Runnable 
{
    private static int counter;
    // ...
    private static final Object lock = new Object();

    public void run() 
    {
        synchronized (lock) 
        {
            counter++;
            // ...
        }
    }
    // ...
}

public final class Client 
{
    private final Lock lock = new ReentrantLock();

    public void doSomething(File file) 
    {
        InputStream in = null;
        try
        {
            lock.lock();
            in = new FileInputStream(file);
            // Perform operations on the open file
            lock.unlock();
        } 
        catch (FileNotFoundException x) 
        {
            // Handle exception
        }
        finally
        {
            if (in != null)
            {
                try
                {
                    in.close();
                }
                catch (IOException x)
                {
                    // Handle exception
                }  
            }
        }
    }
}

public final class Client 
{
    private final Lock lock = new ReentrantLock();

    public void doSomething(File file) 
    {
        InputStream in = null;
        try
        {
            lock.lock();
            in = new FileInputStream(file);
            // Perform operations on the open file
            lock.unlock();
        } 
        catch (FileNotFoundException x) 
        {
            // Handle exception
        }
        finally
        {
            lock.unlock();

            if (in != null)
            {
                try
                {
                    in.close();
                }
                catch (IOException x)
                {
                    // Handle exception
                }  
            }
        }
    }
}

public final class Foo implements Runnable 
{
    @Override
    public void run() 
    {
        // ...
    }

    public static void main(String[] args) 
    {
        Foo foo = new Foo();
        new Thread(foo).run();
    }
}

public final class Foo implements Runnable 
{
    @Override
    public void run() 
    {
        // ...
    }

    public static void main(String[] args) 
    {
        Foo foo = new Foo();
        new Thread(foo).start();
    }
}

public final class ProcessStep implements Runnable 
{
    private static final Object lock = new Object();
    private static int time = 0;
    // Do Perform operations when field time reaches this value
    private final int step; 

    public ProcessStep(int step) 
    {
        this.step = step;
    }

    @Override
    public void run() 
    {
        try
        {
            synchronized (lock)
            {
                while (time != step)
                {
                    lock.wait();
                }

                // Perform operations
       
                time++;
                lock.notify();
            }
        }
        catch (InterruptedException ie) 
        {
            // Reset interrupted status
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args)
    {
        for (int i = 4; i >= 0; i--) 
        {
            new Thread(new ProcessStep(i)).start();
        }
    }
}

public final class ProcessStep implements Runnable 
{
    private static final Object lock = new Object();
    private static int time = 0;
    // Do Perform operations when field time reaches this value
    private final int step; 

    public ProcessStep(int step) 
    {
        this.step = step;
    }

    @Override
    public void run() 
    {
        try
        {
            synchronized (lock)
            {
                while (time != step)
                {
                    lock.wait();
                }

                // Perform operations
       
                time++;
                lock.notifyAll(); // Use notifyAll() instead of notify()
            }
        }
        catch (InterruptedException ie) 
        {
            // Reset interrupted status
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args)
    {
        for (int i = 4; i >= 0; i--) 
        {
            new Thread(new ProcessStep(i)).start();
        }
    }
}

synchronized (object) 
{
    if (<condition does not hold>) 
    {
        object.wait();
    }

    // Proceed when condition holds
}

synchronized (object) 
{
    while (<condition does not hold>) 
    {
        object.wait();
    }

    // Proceed when condition holds
}

class Helper
{
    public void handle(Socket socket) 
    {
        // ...
    }
}

final class RequestHandler
{
    private final Helper helper = new Helper();
    private final ServerSocket server;

    private RequestHandler(int port) throws IOException 
    {
        server = new ServerSocket(port);
    }

    public static RequestHandler newInstance() throws IOException 
    {
        return new RequestHandler(0); // Selects next available port
    }

    public void handleRequest() 
    {
        new Thread(new Runnable() {
            public void run() {
                try
                {
                    helper.handle(server.accept());
                }
                catch (IOException e) 
                {
                    // Forward to handler
                }
            }
        }).start();
    }
}

// class Helper remains unchanged

final class RequestHandler
{
    private final Helper helper = new Helper();
    private final ServerSocket server;
    private final ExecutorService exec;

    private RequestHandler(int port, int poolSize) throws IOException 
    {
        server = new ServerSocket(port);
        exec = Executors.newFixedThreadPool(poolSize);
    }

    public static RequestHandler newInstance(int poolSize) throws IOException
    {
        return new RequestHandler(0, poolSize);
    }

    public void handleRequest() 
    {
        Future<?> future = exec.submit(new Runnable() {
            @Override
            public void run()
            {
                try
                {
                    helper.handle(server.accept());
                }
                catch (IOException e)
                {
                    // Forward to handler
                }
            }
        });
    }

    // ... Other methods such as shutting down the thread pool 
  
    // and task cancellation ...
}

final class PoolService
{
    private final ExecutorService pool = Executors.newFixedThreadPool(10);

    public void doSomething() 
    {
        pool.execute(new Task());
    }
}

final class Task implements Runnable
{
    @Override
    public void run()
    {
        // ...
        throw new NullPointerException();
        // ...
    }
}

final class PoolService
{
    // The values have been hard-coded for brevity
    ExecutorService pool = new CustomThreadPoolExecutor(
        10, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
    // ...
}

class CustomThreadPoolExecutor extends ThreadPoolExecutor
{
    // ... Constructor ...
    public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) \
    { 
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    public void afterExecute(Runnable r, Throwable t) 
    {
        super.afterExecute(r, t);
        if (t != null)
        {
            // Exception occurred, forward to handler
        }

        // ... Perform task-specific cleanup actions
    }

    @Override
    public void terminated()
    {
        super.terminated();
        // ... Perform final clean-up actions
    }
}

final class PoolService
{
    private static final ThreadFactory factory = new ExceptionThreadFactory(new MyExceptionHandler());
    private static final ExecutorService pool = Executors.newFixedThreadPool(10, factory);

    public void doSomething() 
    {
        pool.execute(new Task()); // Task is a runnable class
    }

    public static class ExceptionThreadFactory implements ThreadFactory
    {
        private static final ThreadFactory defaultFactory = Executors.defaultThreadFactory();
        private final Thread.UncaughtExceptionHandler handler;
    
        public ExceptionThreadFactory(Thread.UncaughtExceptionHandler handler)
        {
            this.handler = handler;
        }

        @Override
        public Thread newThread(Runnable run)
        {
            Thread thread = defaultFactory.newThread(run);
            thread.setUncaughtExceptionHandler(handler);
            return thread;
        }
    }

    public static class MyExceptionHandler extends ExceptionReporter      implements Thread.UncaughtExceptionHandler
    {
        // ...
        
        @Override
        public void uncaughtException(Thread thread, Throwable t)
        {
            // Recovery or logging code
        }
    }
}

final class PoolService
{
    private final ExecutorService pool = Executors.newFixedThreadPool(10);

    public void doSomething()
    {
        Future<?> future = pool.submit(new Task());
    
        // ...
    
        try
        {
            future.get();
        }
        catch (InterruptedException e)
        {
            Thread.currentThread().interrupt(); // Reset interrupted status
        }
        catch (ExecutionException e)
        {
            Throwable exception = e.getCause();
            // Forward to exception reporter
        }
    }
}

class Base
{
    public synchronized void doSomething()
    {
        // ...
    }
}

class Derived extends Base
{
    @Override
    public void doSomething()
    {
        // ...
    }
}

class Base
{
    public synchronized void doSomething()
    {
        // ...
    }
}

class Derived extends Base
{
    @Override
    public synchronized void doSomething()
    {
        // ...
    }
}

class Base
{
    public synchronized void doSomething()
    {
        // ...
    }
}

class Derived extends Base
{
    private final Object lock = new Object();

    @Override
    public void doSomething()
    {
        synchronized (lock)
        {
            // ...
        }
    }
}

File file = new File(args[0]);
file.delete();

File file = new File("file");
if (!file.delete())
{
    System.out.println("Deletion failed");
}

Path file = new File(args[0]).toPath();
try 
{
    Files.delete(file);
}
catch (IOException x)
{
    System.out.println("Deletion failed");
    // Handle error
}

class TempFile
{
    public static void main(String[] args) throws IOException
    {
        File f = File.createTempFile("tempnam",".tmp");
        FileOutputStream fop = null;
        try
        {
            fop = new FileOutputStream(f);
            String str = "Data";
            fop.write(str.getBytes());
            fop.flush();
        }
        finally
        {
            // Stream/file still open; file will
            // not be deleted on Windows systems
            f.deleteOnExit(); // Delete the file when the JVM terminates
            if (fop != null)
            {
                try
                {
                    fop.close();
                }
                catch (IOException x)
                {
                    // Handle error
                }
            }
        }
    }
}

class TempFile
{
    public static void main(String[] args)
    {
        Path tempFile = null;
        try
        {
            tempFile = Files.createTempFile("tempnam", ".tmp");
            try (BufferedWriter writer = Files.newBufferedWriter(tempFile, Charset.forName("UTF8"), StandardOpenOption.DELETE_ON_CLOSE)) 
            {
                // Write to file
            }
            System.out.println("Temporary file write done, file erased");
        }
        catch (FileAlreadyExistsException x)
        {
            System.err.println("File exists: " + tempFile);
        }
        catch (IOException x)
        {
            // Some other sort of failure, such as permissions.
            System.err.println("Error creating temporary file: " + x);
        }
    }
}

public int processFile(String fileName) throws IOException, FileNotFoundException 
{
    FileInputStream stream = new FileInputStream(fileName);
    BufferedReader bufRead = new BufferedReader(new InputStreamReader(stream));
    String line;
    while ((line = bufRead.readLine()) != null) 
    {
        sendLine(line);
    }
    return 1;
}

try
{
    final FileInputStream stream = new FileInputStream(fileName);
    try
    {
        final BufferedReader bufRead = new BufferedReader(new InputStreamReader(stream));
        String line;
        while ((line = bufRead.readLine()) != null)
        {
            sendLine(line);
        }
    }
    finally
    {
        if (stream != null)
        {
            try
            {
                stream.close();
            }
            catch (IOException e)
            {
                // Forward to handler
            }
        }
    }
}
catch (IOException e)
{
    // Forward to handler
}

try (FileInputStream stream = new FileInputStream(fileName);
     BufferedReader bufRead = new BufferedReader(new InputStreamReader(stream))) 
{
    String line;
    while ((line = bufRead.readLine()) != null)
    {
        sendLine(line);
    }
}
catch (IOException e)
{
    // Forward to handler
}

FileInputStream in;
// Initialize stream 
byte data;
while ((data = (byte) in.read()) != -1) 
{ 
    // ... 
}

FileInputStream in;
// Initialize stream 
int inbuff;
byte data;
while ((inbuff = in.read()) != -1)
{ 
    data = (byte) inbuff;
    // ...  
}

FileReader in;
// Initialize stream 
char data;
while ((data = (char) in.read()) != -1) 
{ 
    // ... 
}

FileReader in;
// Initialize stream 
int inbuff;
char data;
while ((inbuff = in.read()) != -1)
{ 
    data = (char) inbuff;
    // ...  
}

class ConsoleWrite
{
    public static void main(String[] args)
    { 
        System.out.write(Integer.valueOf(args[0]));
        System.out.flush();
    }
}

class FileWrite
{
    public static void main(String[] args) throws NumberFormatException, IOException 
    { 
        // Perform range checking  
        int value = Integer.valueOf(args[0]);
        if (value < 0 || value > 255) 
        {
            throw new ArithmeticException("Value is out of range");
        }

        System.out.write(value);
        System.out.flush(); 
    }
}

class FileWrite
{
    public static void main(String[] args) throws NumberFormatException, IOException 
    { 
        DataOutputStream dos = new DataOutputStream(System.out);
        dos.writeInt(Integer.valueOf(args[0].toString()));
        System.out.flush(); 
    }     
}

class GameWeapon implements Serializable
{
    int numOfWeapons = 10;

    public String toString()
    {
        return String.valueOf(numOfWeapons);
    }
}

public class GameWeapon implements Serializable {
    private static final long serialVersionUID = 24L;
    
    int numOfWeapons = 10;

    public String toString()
    {
        return String.valueOf(numOfWeapons);
    }
}

class WeaponStore implements Serializable 
{
    int numOfWeapons = 10; // Total number of weapons
}

public class GameWeapon implements Serializable 
{
    WeaponStore ws = new WeaponStore();

    private static final ObjectStreamField[] serialPersistentFields = {new ObjectStreamField("ws", WeaponStore.class)};
    
    private void readObject(ObjectInputStream ois) throws IOException
    {
        try
        {
            ObjectInputStream.GetField gf = ois.readFields();
            this.ws = (WeaponStore) gf.get("ws", ws);
        }
        catch (ClassNotFoundException e)
        { /* Forward to handler */ 
        }
    }

    private void writeObject(ObjectOutputStream oos) throws IOException
    {
        ObjectOutputStream.PutField pf = oos.putFields();
        pf.put("ws", ws);
        oos.writeFields();
    }

    public String toString() 
    {
        return String.valueOf(ws);
    }
}

public class Ser implements Serializable 
{
    private final long serialVersionUID = 123456789;

    private Ser()
    {
        // initialize
    }

    public static void writeObject(final ObjectOutputStream stream) throws IOException
    {
        stream.defaultWriteObject();
    }

    public static void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException
    {
        stream.defaultReadObject();
    }
}

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

    private void writeObject(final ObjectOutputStream stream) throws IOException
    {
        stream.defaultWriteObject();
    }

    private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException
    {
        stream.defaultReadObject();
    }

class Extendable implements Serializable
{
    private Object readResolve()
    {
        // ...
    }

    private Object writeReplace()
    {
        // ...
    }
}

class Extendable implements Serializable
{
    protected static Object readResolve()
    {
        // ...
    }

    protected static Object writeReplace()
    {
        // ...
    }
}

class Extendable implements Serializable
{
    protected Object readResolve()
    {
        // ...
    }

    protected Object writeReplace()
    {
        // ...
    }
}

private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException
{
    overridableMethod(); 
    stream.defaultReadObject();
}

public void overridableMethod() 
{
    // ...
}

private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException
{
    stream.defaultReadObject();
}

class FieldExample
{
    private int i = 3;
    private int j = 4;

    public String toString() 
    {
        return "FieldExample: i=" + i + ", j=" + j;
    }

    public void zeroI() 
    {
        this.i = 0;
    }

    public void zeroField(String fieldName) 
    {
        try
        {
            Field f = this.getClass().getDeclaredField(fieldName);
            // Subsequent access to field f passes language access checks
            // because zeroField() could have accessed the field via
            // ordinary field references
            f.setInt(this, 0);
            // Log appropriately or throw sanitized exception; see EXC06-J

        }
        catch (NoSuchFieldException ex) 
        {
            // Report to handler
        }
        catch (IllegalAccessException ex) 
        {
            // Report to handler
        }
    }

    public static void main(String[] args)
    {
        FieldExample fe = new FieldExample();
        System.out.println(fe.toString());
        for (String arg : args) 
        {
            fe.zeroField(arg);
            System.out.println(fe.toString());
        }
    }
}

class FieldExample 
{
    // ...

    private void zeroField(String fieldName) 
    {
        // ...
    }
}

class FieldExample 
{
    // ...
    
    public void zeroField(String fieldName) 
    {
        // ...
    }

    public void zeroI()
    {
        this.i = 0;
    }

    public void zeroJ() 
    {
        this.j = 0;
    }
}

String username = System.getenv("USER");

String username = System.getProperty("user.name");

public int nop()
{
    while (true) 
    {
    }
}

public final int DURATION=10000; // In milliseconds

public void nop() throws InterruptedException 
{
    while (true)
    {
        // Useful operations
        Thread.sleep(DURATION);
    }
}

public void nop() throws InterruptedException 
{
    while (true)
    {
        Thread.yield();
    }
}

import java.util.Random;
// ...

Random number = new Random(123L);
//...
for (int i = 0; i < 20; i++) 
{
    // Generate another random integer in the range [0, 20]
    int n = number.nextInt(21);
    System.out.println(n);
}

import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
// ...
public static void main (String args[]) 
{
    SecureRandom number = new SecureRandom();

    // Generate 20 integers 0..20
    for (int i = 0; i < 20; i++) 
    {
        System.out.println(number.nextInt(21));
    }
}

import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;

public static void main (String args[]) 
{
    try 
    {
        SecureRandom number = SecureRandom.getInstanceStrong();

        // Generate 20 integers 0..20
        for (int i = 0; i < 20; i++) 
        {
            System.out.println(number.nextInt(21));
        }
    }
    catch (NoSuchAlgorithmException nsae) 
    {
    // Forward to handler
    }
}

public class Leak 
{
    static Vector vector = new Vector();

    public void useVector(int count) 
    {
        for (int n = 0; n < count; n++) 
        {
            vector.add(Integer.toString(n));
        }
        // ...
        for (int n = count - 1; n > 0; n--) 
        { // Free the memory
            vector.removeElementAt(n);
        }   
    }

    public static void main(String[] args) throws IOException 
    {
        Leak le = new Leak();
        int i = 1;
        while (true) 
        {
            System.out.println("Iteration: " + i);
            le.useVector(1);
            i++;
        }
    }
}