Spring Semester, 2001
Assignment 1 Comments
© 2001, All Rights Reserved, SDSU & Roger Whitney
San Diego State University -- This page last updated 10-Apr-01
|
|
CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2001 Assignment 1 Comments |
|
|---|---|---|
|
© 2001, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 10-Apr-01 |
public void foo()
{
code here
}
public void bar() { code here }
public void foobar() {
code here
}
public abstract class HttpTransaction
{
HashMap headers = new HashMap();
byte[] body;
abstract void parseFirstLine(ByteReader input ); q
abstract String firstLineToString();
public void fromStream( InputStream input) throws IOException
{
ByteReader bufferedInput = new ByteReader( input);
parseFirstLine(bufferedInput);
if ( hasHeaders() )
parseHeaders(bufferedInput);
if (hasBody() )
parseBody(bufferedInput);
}
public byte[] toBytes()
{
if (!hasBody())
return toString().getBytes();
String headerString = toString();
int length = headerString.length() + body.length;
byte[] transaction = new byte[length];
System.arraycopy(headerString.getBytes(), 0, transaction, 0, headerString.length());
System.arraycopy(body, 0, transaction, headerString.length(), body.length);
return transaction;
}
public boolean hasContentLength()
{
return (headers.containsKey( "Content-length" ) ||
headers.containsKey( "Content-Length" ));
}
public byte[] toBytes()
{
if (!hasBody())
return toString().getBytes(); //get the string and
convert it to bytes then return it
String headerString = toString();//convert to a string
int length = headerString.length() +
body.length;
byte[] transaction = new byte[length];//declare transaction
System.arraycopy(headerString.getBytes(), 0,
transaction, 0, headerString.length());
System.arraycopy(body, 0, transaction,
headerString.length(), body.length);
return transaction;
}
{
String requestLine = readLine(input); // Read a
Line of input from the input
while (requestLine.length() > 0 )
{
int separatorIndex = requestLine.indexOf(':');
String name = requestLine.substring(0,
separatorIndex);
String value =
requestLine.substring(separatorIndex + 1).trim();
headers.put( name, value);
requestLine = readLine(input);
String requestLine = readLine(input); // Read a Line of input from the input
if ( blah ) {
if (more blah) {
foo;
else {
if ( bar ) {
not bar
else {
if ( more bar ) {
if (even more bar ) {
if (still more bar ) {
if (even still more bar ) {
if ( bar until you can’t stand it ) {
if ( foo ) {
if ( more foo ) {
if ( still more foo ) {
if ( you can understand the nesting level here please do not work for me) {
}
}
}
}
}
}
}
}
}
}
double getPayAmount() {
double result;
if ( _isDead)
result = deadAMount();
else {
if ( _isSeparated)
result = separatedAmount();
else {
if (_isRetired)
result = retiredAmount();
else
result = normalPayAmount();
}
}
}
double getPayAmount() {
if ( _isDead)
return deadAMount();
if ( _isSeparated)
return separatedAmount();
if (_isRetired)
return retiredAmount();
return normalPayAmount();
}
if (date.before (SUMMER_START) || date.after(SUMMER_END))
charge = quality * _winterRate + _winterServiceCharge;
else
charge = quantity * _summerRate
if (notSummer( date))
charge = winterCharge(quantity);
else
charge = summerCharge(quantity);
void add(int key, String value)
if (key < _key ) {
if (right == null)
left == new BinaryNode(key, value);
else
left .add( key, value);
etc.
void add(int key, String value)
if (key < _key ) {
left .add( key, value);
etc.
void add(int key, String value)
if (key < _key ) {
if (left == null)
left = new BinaryNode(key, value);
else
left.add( key, value);
else {
if (key == _key )
value = _value;
else {
if (key > _key ) {
if ( right == null ) {
right = new BinaryNode(key, value);
else
left.add( key, value);
}
}
}
}
Applying
the above ideas this becomes
void add(int key, String value)
if (key < _key )
retun left.add( key, value);
if (key == _key )
return value = _value;
if (key > _key )
return left.add( key, value);
}
for i := 1 to Num do MeetsCriteria[ i ] := True; for i := 1 to Num / 2 do begin j := i + i; while ( j <= Num ) do begin MeetsCriteria[ j ] := False; j := j + i; end; for i := 1 to Mun do if MeetsCriteria[ i ] then writeln( i, ' meets criteria ' );
for PrimeCandidate:= 1 to Num do
IsPrime[ PrimeCandidate] := True;
for Factor:= 1 to Num / 2 do begin
FactorableNumber := Factor + Factor ;
while ( FactorableNumber <= Num ) do begin
IsPrime[ FactorableNumber ] := False;
FactorableNumber := FactorableNumber + Factor ;
end;
end;
for PrimeCandidate:= 1 to Num do
if IsPrime[ PrimeCandidate] then
writeln( PrimeCandidate, ' is Prime ' );
X := X + 1 /* add one to X /** Integer value */ private int key; /** String value */ private String value;
*p++->*c = a
/* first we need to increase p by one, then ..
(*(p++))->*c = a
ObjectPointerPointer++;
ObjectPointer = *ObjectPointerPointer;
ObjectPointer ->*DataMemberPointer = a;
/* **** Need to add error checking here **** */
{ get current employee information } intent
{ update EmpRec structure } what
/***********************************
* module: Print *
* *
* author: Roger Whitney *
* date: Sept. 10, 1995 *
* *
* blah blah blah *
* *
***********************************/
/***********************************
module: Print
author: Roger Whitney
date: Sept. 10, 1995
blah blah blah
***********************************/
MOV AX, 723h ; R. I. P. L. V. B.
MemToInit := MemoryAvailable(); { get memory available }
/* if allocation flag is zero */ if ( AllocFlag == 0 ) ...
/* if allocating a new member */ if ( AllocFlag == 0 ) ...
/* if allocating a new member */ if ( AllocFlag == NEW_MEMBER ) ...
{ check each character in "InputStr" until a
dollar sign is found or all characters have
been checked }
Done := false;
MaxPos := Length( InputStr );
i := 1;
while ( (not Done) and (i <= MaxLen) ) begin
if ( InputStr[ i ] = '$' ) then
Done := True
else
i := i + 1
end;
{ find the command-word terminator }
Done := false;
MaxPos := Length( InputStr );
i := 1;
while ( (not Done) and (i <= MaxPos ) ) begin
if ( InputStr[ i ] = '$' ) then
Done := True
else
i := i + 1
end;
{ find the command-word terminator }
FoundTheEnd := false;
MaxCommandLength := Length( InputStr );
Index := 1;
while ((not FoundTheEnd) and
(Index <= MaxCommandLength)) begin
if ( InputStr[ Index ] = '$' ) then
FoundTheEnd := True;
else
Index := Index + 1;
end;
var
CursorX: 1..MaxCols; { horizontal screen position of cursor }
CursorY: 1..MaxRows; { vertical position of cursor on screen }
AntennaLength: Real; { length of antenna in meters: >= 2 }
SignalStrength: Integer; { strength of signal in kilowatts: >= 1 }
CharCode: 0..255; { ASCII character code }
CharAttib: Integer; { 0=Plain; 1=Italic; 2=Bold }
CharSize: 4..127; { size of character in points }
Comment limitations on input data
Document flags to the bit level
procedure InsertionSort
{
Var Data: SortArray; { sort array elements }
FirstElement: Integer {index of first element to sort}
LastElement: Integer {index of last element to sort}
}
//*****************************************************
//*****************************************************
// Class: Proxy
//*****************************************************
//*****************************************************
public class Proxy {
//***************************************************
//Default Constructor
//***************************************************
public Proxy() { blah }
//***************************************************
//Constructor
//***************************************************
public Proxy(int size) {
_size = size;}
//***************************************************
//Main
//***************************************************
public static void public static void main( String[] args ) {
//Create a new socket
ServerSocket acceptor = new ServerSocket(0);
//Print out the port number
System.out.println("On port " + acceptor.getLocalPort());
while (true) {//runs forever, until program is manually killed
Socket client = acceptor.accept();//Accept a new connection
processRequest(//Process the client request
client.getInputStream(),//get the input
client.getOutputStream());//get the ouput
client.close();//Close the connection
public class Proxy
{
public Proxy()
{
blah
}
public Proxy(int size)
{
_size = size;
}
public static void public static void main( String[] args )
{
ServerSocket acceptor = new ServerSocket(0);
System.out.println("On port " + acceptor.getLocalPort());
//Must kill process to terminate
while (true)
{
Socket client = acceptor.accept();
processRequest(
client.getInputStream(),
client.getOutputStream());
client.close();
}
}
}
//-------------------------------------------------------------
public class Proxy
{
public Proxy()
{
blah
}
public Proxy(int size)
{
_size = size;
}
public static void public static void main( String[] args )
{
ServerSocket acceptor = new ServerSocket(0);
System.out.println("On port " + acceptor.getLocalPort());
//Must kill process to terminate
while (true) {
Socket client = acceptor.accept();
processRequest(
client.getInputStream(),
client.getOutputStream());
client.close();
thisIsTheJavaStandardNameStyleForMethodNamesAndVariables
ClassName
public Interator interator(int order)
{
switch(order)
{
case PREORDER:
return new PreorderInterator(this);
case INORDER:
return new InorderInterator(this);
default:
throw new IllegalArgumentExeption("No such order");
}
}
public Interator preorderInterator()
{
return new PreorderInterator(this);
}
public Interator inorderInterator()
{
return new InorderInterator(this);
}
abstract class Visitor
{
Node root;
abstract void visitTree(BinaryTree visitee);
abstract void visitNode(Node visitee);
}
class PreorderVisitor extends Visitor
{
Node root;
blah
etc.
}
abstract class Visitor
{
abstract void visitTree(Node visitee);
abstract void visitNode(Node visitee);
}
class PreorderVisitor extends Visitor
{
Node root;
blah
etc.
}
public class BinaryTreeIterator implements Iterator{
public static final int PREORDER = 1;
public static final int INORDER = 2;
int type;
public boolean hasNext() {
blah
if (PREORDER == type)
do the preorder thing
else if (INORDER == type)
do the inorder thing
else
now what?
more blah
}
public Object next() {
blah
if (PREORDER == type)
do the preorder thing
else if (INORDER == type)
do the inorder thing
else
now what?
more blah
}
}
Not
how every method becomes two methods
class BinarySearchTree {
public accept(Visitor visitor) {
visitor.visitBinarySerachTree( this);
root.accept( visitor);
}
}
class BinaryNode{
public accept(Visitor visitor) {
visitor.visitBinaryNode( this);
left.accept( visitor);
right.accept( visitor);
}
}
class NullNode{
public accept(Visitor visitor) {
visitor.visitNullNode( this);
}
}
class Visitor {
integer count = 0;
public visitBinarySerachTree(BinarySerachTree tree) {
}
public visitBinaryNode(BinaryNode node) {
count++;
reverseValue( node);
}
public visitNullNode(BinaryNode node) {
count++;
}
private void reverseValue(BinaryNode node) {
put your code here
}
}
class BinarySearchTree {
public accept(Visitor visitor) {
visitor.visitBinarySerachTree( this);
}
}
class BinaryNode{
public accept(Visitor visitor) {
visitor.visitBinaryNode( this);
}
}
class NullNode{
public accept(Visitor visitor) {
visitor.visitNullNode( this);
}
}
BinarySearchTree studentNames; Code here to populate the tree Visitor reverseNames = new Visitor(); studentNames.accept( reverseNames );
class Visitor {
integer count = 0;
public visitBinarySerachTree(BinarySerachTree tree) {
Node root = tree.root();
root.accept( this );
}
public visitBinaryNode(BinaryNode node) {
count++;
reverseValue( node);
Node left = node.left();
left.accept( this );
Node right = node.right();
right.accept( this );
}
public visitNullNode(BinaryNode node) {
count++;
}
private void reverseValue(BinaryNode node) {
put your code here
}
}
public visitBinaryNode(BinaryNode node) {
count++;
reverseValue( node);
if ( node.left() != null );
visitBinaryNode( node.left() );
if ( node.right() != null );
visitBinaryNode( node.right() );
}
public visitBinaryNode(BinaryNode node) {
count++;
reverseValue( node);
Node left = node.left();
left.accept( this );
Node right = node.right();
right.accept( this );
}
class Visitor {
integer count = 0;
Iterator traversal;
public Visitor(Interator order) {
traversal = order;
}
public visitBinarySerachTree(BinarySerachTree tree) {
order.on( tree );
while ( order.hasNext() ) {
Node next = (Node) order.next();
next.accept( this );
}
}
public visitBinaryNode(BinaryNode node) {
count++;
reverseValue( node);
}
public visitNullNode(BinaryNode node) {
count++;
}
private void reverseValue(BinaryNode node) {
blah
}
}
BinarySearchTree studentNames; Code here to populate the tree Visitor reverseNames = new Visitor( new InorderIterator() ); studentNames.accept( reverseNames );
[1] Refactoring Text, pp. 250-254