Top Banner
Main and Control Flow • Programming without ObjectEditor • Main Class • Control Flow •“Real” Programming •Linear •Branching •Looping • Programmer-Defined Overloading • Console Input
70

Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Dec 20, 2015

Download

Documents

Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Page 1: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Main and Control Flow

• Programming without ObjectEditor

• Main Class

• Control Flow

•“Real” Programming

•Linear

•Branching

•Looping

• Programmer-Defined Overloading

• Console Input

• Programmer-Defined Library Class

Page 2: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Programming Vs Bicycle Riding

Statements Expressions

Primitive Types

Least Privilege Interfaces Reuse Stepwise-

Refinement

Page 3: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Interface

Implements

Class

Method

Return Type/ Formal Parameter

Statement

Starting with the Big Picture

Variable (State)

Local Variable

Method Header

Signature

Name

Named Constant

Statement List

Statement ...

Statement

Page 4: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Starting with the Small Picture

Class

Method

Return Type/ Formal Parameter

Statement List

Statement ...

Variable (State)

Local Variable

Interface

Method Header

Signature

Name

Named Constant

Implements

Statement

Page 5: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Interface

Implements

Class

Method

Return Type/ Formal Parameter

Statement

Starting with the Abstractions

Variable (State)

Local Variable

Method Header

Signature

Name

Named Constant

Statement List

Statement ...

Statement

Data Abstraction

exports

Operation Abstraction

exports

Page 6: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Interface

Implements

Class

Method

Return Type/ Formal Parameter

Statement

Starting with Optional Components

Variable (State)

Local Variable

Method Header

Signature

Name

Named Constant

Statement List

Statement ...

Statement

Real-Work

Required

Page 7: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Focussing on Control Flow (“Real Programming”)

StatementStatement List

Statement ...

Statement List

Statement ...

Statement

Linear

Statement List

Stmt

Statement

Stmt

BranchingStatement List

Stmt

Statement

Stmt

Looping

Page 8: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Removing Training WheelsText Editor

ALoanPair Source Code

creates

Java Compiler

reads

ALoanPairObject (Byte) Code

creates

Java Interpreter

ALoanPair Instance

getTotalLoan()

instantiates

calls

ObjectEditor

main

calls

, Main Class

Main ClassObject (Byte) Code

Static method

Page 9: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Equivalent User Interfaces

Page 10: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Algorithm (edit)

Page 11: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Algorithm (edited)

Page 12: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Algorithm (soln)

• Create ALoanPair instance based on the two values entered by the user in the console window.

• Print the properties of the loan pair object in the console window.

• Pause until user presses some keystroke.

Page 13: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

public static void main (String[] args) {

LoanPair loanPair = new ALoanPair(readCarLoan(), readHouseLoan());

print (loanPair);

pause();

}

Main Method

Method chaining

List of user-supplied argumentsmain header

Page 14: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

public static void main (String[] args) {

Loan carLoan = readCarLoan();

Loan houseLoan = readHouseLoan();

LoanPair loanPair = new ALoanPair(carLoan, houseLoan());

print (loanPair);

pause();

}

Main Method without Method Chaining

Undefined

Stepwise refinement

Page 15: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

readCarLoan()

Page 16: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

readCarLoan()

• Prompt user

• Return an instance of ALoan constructed from the principal.

public static Loan readCarLoan() {System.out.println("Please enter car principal:");return new ALoan(readInt());

}

Called by class method (main)

Undefined

Page 17: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

static DataInputStream dataIn = new DataInputStream (System.in); public static int readInt() {

try {return Integer.parseInt(dataIn.readLine());

} catch (Exception e) {System.out.println(e);return 0;

}}

readInt()• Wait for the user to enter a string (of digits) on the next line.

• Return the int represented by the string.

• In case the user makes an error or terminates input before entring a valid int, return 0 and print an error message.

Page 18: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

try {return Integer.parseInt(dataIn.readLine());

} catch (Exception e) {

System.out.println(e);return 0;

}

Try-Catch Block

Exception Object

Program fragment that can cause exception

Exception Handler

Page 19: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

public class ALoanPairDriver {

...

}

import java.io.DataInputStream;

public class ALoanPairDriver {

….

…...

}

Importing a Package

new DataInputStream(System.in)

new java.io.DataInputStream(System.in)

package java.io;

public class DataInputStream {

….

}

short name

full name

Import Declaration

Page 20: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Printing a LoanPair

Page 21: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Printing a LoanPair

public static void print (LoanPair loanPair) {System.out.println("****Car Loan*****");print(loanPair.getCarLoan());System.out.println("****House Loan****");print(loanPair.getHouseLoan());System.out.println("****Total Loan****");print (loanPair.getTotalLoan());

}

public static void print (Loan loan) { System.out.println("Principal:" + loan.getPrincipal()); System.out.println("Yearly Interest:" + loan.getYearlyInterest()); System.out.println("Monthly Interest:" + loan.getMonthlyInterest());}

Programmer-defined Overloading

Page 22: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

public static void pause() {try {

System.in.read();} catch (Exception e) {

System.out.println(e);}

}

pause()Returns single char

System.out.println(pause());

Legal Expression & Statement

Page 23: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

public static void pause() {try {

System.in.read();} catch (Exception e) {

System.out.println(e);}

}

Expression Vs Statement

System.out.println(pause());

5 + 3;

Illegal

Page 24: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Function Calls

• Can be used as expression

• Can be used as statement– When return value is to be ignored– Rarely happens– Check program to see all return values being

used as expressions

• Other expressions not statements

• Procedure calls never expressions

Page 25: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Multi-level Algorithm/Code

main

print (Loan)

readCarLoan readHouseLoan print(LoanPair) pause

readInt

Page 26: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Class-Level Decomposition

Monolithic Main Class(Loan User Interface and Loan Computation)

Object EditorProgrammer-defined Class(A Loan Pair)

Driver(ALoanPairDriver)

Page 27: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Class-Level Decomposition

main

print (Loan)

readCarLoan readHouseLoan print(LoanPair) pause

readInt

Page 28: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Separate Class

pause()readInt()

readDouble()

readBoolean()

readChar()

Keyboard

readString()

Page 29: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Using Keyboard

public static Loan readCarLoan() {System.out.println("Please enter car principal:");return new ALoan(readInt());

}return new ALoan(Keyboard.readInt());

Page 30: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Separation of Concerns

• Make independent piece of code as separate method.

• Make independent set of methods as separate class.

• Use operation and data abstraction!

Page 31: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Running Main

Page 32: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Single-Stepping

Page 33: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Step Into Vs Step Over

Page 34: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Inspecting Variables

Page 35: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Conditionals

printPassFailStatus(95)

printPassFailStatus(25)

public static void printPassFailStatus(int score) {if (score < PASS_CUTOFF)

System.out.println("FAILED");else

System.out.println("PASSED");}

PASS

FAIL

Page 36: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

If-else Statement

if (<bool expr>)<statement 1>

else<statement 2>

Page 37: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

If-Else Statement

<bool expr>true false

<statement 1> <statement 2>

Page 38: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Compound Statementpublic void fancyPrintGrade(int score) {

if (score < PASS_CUTOFF) {

System.out.println("**************");System.out.println("FAILED");System.out.println("**************");

}else {

System.out.println("**************");System.out.println("PASSED");System.out.println("Congratulations!");System.out.println("**************");

} }

Page 39: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Avoding Code Duplication in If-Else

public void fancyPrintGrade(int score) { System.out.println("**************");

if (score < PASS_CUTOFF) System.out.println("FAILED");

else {System.out.println("PASSED");System.out.println("Congratulations!");

}System.out.println("**************");

}

Page 40: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Avoding Code Duplication in If-Else

public void fancyPrintGrade(int score) { System.out.println("**************");

if (score < PASS_CUTOFF) System.out.println("FAILED");

else {System.out.println("PASSED");System.out.println("Congratulations!");

}System.out.println("**************");

}

Page 41: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

If Statement

if (score == MAX_SCORE) System.out.println ("Perfect Score! Congratulations!");

if (<bool expr>) <statement>;

Page 42: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

if Statement

<bool expr>true

false<statement>

Page 43: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Nested if-elsepublic static char toLetterGrade (int score) {

if (score >= A_CUTOFF) return 'A';else if (score >= B_CUTOFF) return 'B';else if (score >= C_CUTOFF) return 'C';else if (score >= D_CUTOFF) return 'D';else return 'F';

}

Page 44: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Nested If-Elseif (score >= A_CUTOFF) return 'A';else

if (score >= B_CUTOFF) return 'B';else

if (score >= C_CUTOFF) return 'C';

else if (score >= D_CUTOFF) return 'D'; else

return 'F'; 

Page 45: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Nested If-Else

Page 46: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Looping

printHello(2)

hello

hello

printHello(3)

hello

hello

hello

Page 47: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loops

int counter = 0;if (counter < n) { counter = counter + 1; System.out.println (“hello”);}

public static void printHello(int n) {

}

Page 48: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loops

int counter = 0;while (counter < n) { counter = counter + 1; System.out.println (“hello”);}

public static void printHello(int n) {

}

Page 49: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

If Vs While Statement

if (<bool expr>) <statement>;

while (<bool expr>) <statement>;

Page 50: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

if Statement

<bool expr>true

false<statement>

Page 51: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

while Statement

<bool expr>true

false<statement>

Page 52: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

while loop

<bool expr>

true

false

<statement >

Page 53: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Sentinel-based Folding

Page 54: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Adding Fixed Number of Loans

Loan loan1 = readLoan();Loan loan2 = readLoan();Loan loan3 = readLoan();Loan loan4 = readLoan();Loan sumLoan = ALoan.add(loan1, ALoan.add(loan2,

ALoan.add(loan3, loan4)));print (sumLoan);

Page 55: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Generalizing to Variable # Loans

Loan loan1 = readLoan();Loan loan2 = readLoan();Loan loan3 = readLoan();Loan loan4 = readLoan();…Loan loanN = readLoan();Loan sumLoan = ALoan.add(loan1, ALoan.add(loan2,

ALoan.add(loan3, Aloan.add(loan4, ……(add (loanN-1, loanN)*;print (sumLoan);

Loops + Arrays

Recursion

Variable # of Statements

Variable # of Subexpressions (function calls)

Page 56: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Space Efficient Adding of Fixed Number of Loans

Loan loan1 = readLoan();Loan loan2 = readLoan();Loan sumLoan = ALoan.add(loan1, loan2);loan1 = readLoan(); // 3rd loansumLoan = ALoan.add(sumLoan, loan1);loan1 = readLoan(); // 4th loansumLoan = ALoan.add(sumLoan, loan1);print (sumLoan);

Page 57: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

More Space Efficient Adding of Fixed Number of Loans

Loan sumLoan = readLoan(); //first loanLoan nextLoan = readLoan(); //second loansumLoan = Aloan.add(nextLoan, sumLoan);nextLoan = readLoan(); // 3rd loansumLoan = ALoan.add(sumLoan, nextLoan);nextLoan = readLoan(); // 4th loansumLoan = ALoan.add(sumLoan, nextLoan);print (sumLoan);

Page 58: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

More Space Efficient Adding of Variable Number of Loans

Loan sumLoan = readLoan(); //first loanLoan nextLoan = readLoan(); //second loansumLoan = Aloan.add(nextLoan, sumLoan);nextLoan = readLoan(); // 3rd loansumLoan = ALoan.add(sumLoan, nextLoan);nextLoan = readLoan(); // 4th loan

sumLoan = ALoan.add(sumLoan, nextLoan); nextLoan = readLoan(); //Nth loan sumLoan = ALoan.add(sumLoan, nextLoan); nextLoan = readLoan(); //sentinel

print (sumLoan);

N-1 repetitions

Page 59: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

While Loop

Loan sumLoan = readLoan(); //first loan Loan nextLoan = readLoan(); //second loan while (nextLoan().getPrincipal() >= 0) {

sumLoan = ALoan.add(nextLoan, sumLoan);nextLoan = readLoan(); // next loan or sentinel

} print (sumLoan);

-1

Input Result

Program waits for ever for second loan

Boundary Condition

Page 60: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loan sumLoan = new ALoan(0); //initial value Loan nextLoan = readLoan(); //second loan while (nextLoan().getPrincipal() >= 0) {

sumLoan = ALoan.add(nextLoan, sumLoan);nextLoan = readLoan(); // next loan or sentinel

} print (sumLoan);

Correct Solution

ALoan.add(new ALoan(0), add(loan1, add (…., loanN)

identity

Page 61: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loan sumLoan = new ALoan(0); //initial value Loan nextLoan = readLoan(); //second loan while (nextLoan().getPrincipal() >= 0) {

sumLoan = ALoan.add(nextLoan, sumLoan);nextLoan = readLoan(); // next loan or sentinel

} print (sumLoan);

A Single Sentinel Value

Page 62: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loan sumLoan = new ALoan(0); //initial value Loan nextLoan = readLoan(); //second loan while (nextLoan().getPrincipal() >= 0) {

sumLoan = Aloan.add(nextLoan, sumLoan);nextLoan = readLoan(); // next loan or sentinel

} print (sumLoan);

A Single Loan

Page 63: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Loan sumLoan = new ALoan(0); //initial value Loan nextLoan = readLoan(); //second loan while (nextLoan().getPrincipal() >= 0) {

sumLoan = Aloan.add(nextLoan, sumLoan);nextLoan = readLoan(); // next loan or sentinel

} print (sumLoan);

Two Loans

Page 64: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Multiplying Numbers (edit)

???

Page 65: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Multiplying Numbers (edited)

???

Page 66: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Multiplying Numbers int product = 1; int num = Keyboard.readInt(); while (num >= 0) { product = product*num; num = Keyboard.readInt(); }

print (product);

1*20*2*3

Identity

Page 67: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Comparing Two Solutions int product = 1; int num = Keyboard.readInt(); while (num >= 0) { product = product*num; num = Keyboard.readInt(); }

print (product);

Loan sumLoan = new ALoan(0); Loan nextLoan = readLoan(); while (nextLoan().getPrincipal() >= 0) {

sumLoan = ALoan.add(nextLoan, sumLoan); nextLoan = readLoan();

} print (sumLoan); // print value

Identityresult

nextVal

read first value

read other values

Binary folding function

!isSentinel(nextVal)

Page 68: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Generalized Folding of a Sentinal-Terminated List

a1

f

f

f

ana3a2

f: T, T T

F(x, I) x

Page 69: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

T result = I;T nextValue = getNextValue()while (!isSentinel(nextValue)) { result = f(result, nextValue); nextValue = getNextValue(..);}

Generalized Folding SolutionLoan, int new ALoan(0), 1

ALoan.add(), *

>= 0

Page 70: Main and Control Flow Programming without ObjectEditor Main Class Control Flow “Real” Programming Linear Branching Looping Programmer-Defined Overloading.

Comparing Two Solutions (Comments)

int product = 1; //identity int num = Keyboard.readInt(); // read next list value while (num >= 0) { // sentinel checking product = product*num; // binary folding function num = Keyboard.readInt(); // read next value }

print (product);// print value

Loan sumLoan = new ALoan(0); //identity Loan nextLoan = readLoan(); // read next list value while (nextLoan().getPrincipal() >= 0) {// sentinel checking

sumLoan = Aloan.add(nextLoan, sumLoan); // binary folding functionnextLoan = readLoan(); // read next list value

} print (sumLoan); // print value