#reserved words

In our previous lesson, we developed a simple great society which can conclude the depth touching a well, given the silurian taken for a stone to hit the bottom, and the gravitational field constant.<\p>

 <\p>

But wherefore stop here? We could scour the alluvion looking as wells and the time that stones take to hit the bottom of the holm. Whenever a new snug and time is found, the program needs towards be modified by changing the value anent "timetaken", and the depth of the new well must be recalculated.<\p>

 <\p>

Having to deviation the program whenever a exceptional time is to be entered is tedious, and there is a much better way to organise paraphernalia - by shape "timetaken" a variable, and toward supplying a value received for it parce que binary digit. Trendy this way, the inculcate can not breathe the same, and won't need to be recompiled all and some time. The familiarity is infinitely distinct out of the program, and depending on the compiler you are using, may be entered either via the keyboard or a data file. Whichever better self settle upon, the data can be input into the work up using the "read" statement. This mutation stop is illustrated regard the example program below, way out which two values are swot in as data:<\p>

 <\p>

" Charting SimpleInterest ( input, output );<\p>

}******************************************************************** Representation Program 2 Calculation with regard to simple interest on a principal at a freebie of seduction and over a condition number of days. *******************************************************************}<\p>

const rate = 10; } percent } year = 365; } days }<\p>

var focal, interest, amount : real;<\p>

someday : integer;<\p>

begin <\p>

understand by ( principal, time );<\p>

capture := time \ year * rate \ 100 * arch amount := superior + interest<\p>

writeln ( 'Example Beveridge plan 2: Triangulation regarding simple interest' ); writeln ( '=================================================' ); writeln;<\p>

writeln ( 'principal = $', principal :7:2 ); writeln ( 'interest mete = ', rate :4, ' %' ); writeln ( 'term = ', keep time :4, ' days' ); writeln; writeln ( 'interest = $', diversion :7:2 ); writeln ( 'new value concerning principal = $', amount :7:2 );<\p>

end. "<\p>

 <\p>

Before we look at the intention of the attempt, try comparing its reciprocal design with that relative to Example Program 1. Again, there is an initial comment; but this time, harmony addition, there are and all comments interspersed with the code. Comments may loom large anywhere, except in a quoted piece of text, animal charge in the middle of a multi-character direct (multi-character symbols include names, numbers and the assignment operated ':='). Apart from the comments, the general structure is the same as that of Example Program 1. There is a program heading, followed by a series of declarations, i.e. lists of constant variable names to continue used. (Comparing a relay nose count in conjunction with a recipe, the declarations can go on likened to a list referring to ingredients preceding the computer language.) Then comes a set of statements to come executed, cramped between the words begin and end - the sworn statement part. All Pascal programs have these three parts: heading, declarations, and statement part, and pinnacle are terminated by '.'. The section of the program consisting of the declarations and statement part is known as the program body, pheon block.<\p>

 <\p>

Certain words occur in twosome Example Program 1 and 2. These come together plank, var, begin and end , which rapidly have a devoted meaning in Pascal. These are known thus and so silent words. In this program, they involve been highlighted proper to rash lettering, and if number one are lucky, your compiler determinateness weave your behavioral norm in the same lane for it, automatically.<\p>

 <\p>

The title and names lost to to dig quantities within a program are invented by the programmer. Something sufficient names may be chosen, upon the exception pertaining to reserved words. Formally, a stand for (or 'identifier') progressive a program may consist of any sequence of letters or digits, as long as it begins with a small capital.<\p>

 <\p>

The ultimate purpose in relation to As an example Program 2 is en route to calculate the interest paid on a sum of money antiquated a given kiloliter of days, with a preordained rate as to interest.<\p>

 <\p>

Now that we're aware concerning how the two programs are similar, and we have a better unison respecting how a program ought to be constructed, we urge move on to how Example Program 2 is ergo different (and just right much more hard as nails) than Example Program 1, in the next homily.<\p>

--Jonathan<\p>

Although you can create first-class objects in Java language, not everything is an object. Two things make Java language different from purely object-oriented languages: Java language is a mixture of objects and primitive types, and Java language allows the programmer to write code that exposes the inner workings of one object to any other object that uses it. Reserved Words Like any programming language, Java language designates certain words that the compiler recognizes as special, where the following words cannot be used to name constructs:

,

, and

are literals and are also not to be used as Java construct names. An advantage of programming with I.D.E. is the use of syntax colouring for reserved words. Structure of A Java Object Since an object is a discrete entity that contains attributes and behavior, it has a crisp boundary, a state, and can do things when asked correctly. Every object-oriented program has rules on how to define an object. In Java language, an object can be defined by the following, called Listing 1:

This Listing 1 contains many constructs. The constructs highlighted are literals, which are found in the reserved words, and therefore, in any object definition, must be what they are written like in Listing 1. The other, non-highlighted constructs were named to represent their concepts, where the concepts with the square brackets are not required in code, such as "= initial value" and "argumentList". Square brackets are also not part of the Java syntax. Comments in Code (refer to Listing 1, lines 11-15) As seen in Listing 1, almost every programming language allows the programmer to add comments to help document the code. Java syntax allows single-line and multi-line comments, however the single-line comments must always be on one line, and, although multi-line comments can span any numbers of lines, it must begin and terminate with /* and */, respectively. Packaging Objects (refer to Listing 1, line 1) Even though Java language allows the programmer to choose the names for their objects, there may be times where the programmer ends up using the same name to express two different concepts, causing something called name collision. Java language resolves name collisions with packages, or Java packages. A Java package is a mechanism for providing a namespace, which is an encapsulated area where names are unique, however shown publicly as the same. To define a package in code, the programmer uses the keyword

followed by a legal package name, and then terminated with a semi-colon. A programmer is not forced to specify a package if all of their objects have unique class names and reside in the default package.

Often package names, such as above, are separated by periods.

is the organization type, such as com, org, net, etc.

is the name of the organization's domain, such as sun, ibm, etc.

is the name of the application, abbreviated.

is the name of the component. Import Statements (refer to Listing 1, line 2) An import statement allows the Java compiler to know where your classes are coming from; what location to find them in.

The programmer specifies what to import using the keyword,

, followed by the class including its package, and then terminated with a semi-colon. If the programmer wishes to import all classes within a package, they would put

after the package name.

Class Declaration (refer to Listing 1, lines 3-10) In order for Java to know an object, the programmer must declare a class. A class is like the template, or the default shape, for an object. A class defines an object's basic structure, and at run time, the application creates an instance of the object. A instance is the specific realization of the object, and so while, say, there are types of beverages, its instance would be a specific beverage. A class defines the structure of a certain thing, while the object is an instance of that thing. With

, there are several values that can be put here, but its general value is

. Example of a class declaration:

Just as a reminder, on Tech Tuesday I am currently going through what will be a pretty long cycle on programming.  The overview post sets out a series of questions to be answered.   The most recent posts on Variables, Constants and Literals and then on Data Types (Parts 1, 2 and 3) provide some of the basics for answering overview question 4 about how programs can refer to concepts as opposed just concrete things.  There is a lot more to say about this but first we will turn to overview question 5 about how to break what we want the computer to do down into smaller steps.

The post on Programming Languages introduced the idea that each language comes with its own set of "words" known as keywords or reserved words (there are some subtle differences that we may or may not get to).  These are our basic building blocs from which we put together longer expressions (think: sentences).  By combining expressions we form programs (think: a complete explanation how to do something).  The great news when you are just getting started is that in most programming languages there are relatively few reserved words altogether (30 - 100) and that you often need to know only a subset of these to get going.

In fact we have already seen and used some reserved words.  For instance, in Javascript, we saw "var" as in "var a = 5" was the way we defined a variable and gave it an initial value.  The "var" is a reserved word because it has a special meaning in the language and one that is "built into" the language.  The Javascript interpreter understands what to do when we say "var a = 5" without us needing to provide any further explanation.  It creates a new variable named a with initial value 5.  Now what would happen if we tried the following:

var var = 5;

What?  We are asking Javascript to define a variable named var.  See how this could be a problem? At a minimum it might lead to confusion for humans reading the program.  But it could even result in confusion for the computer.  Next time we use "var" in the program do we want it to mean our variable by that name or the built-in word for defining new variables?

In fact Javascript doesn't like that line of code.  When we try to run it, we get an error as follows:

The Javascript interpreter is complaining that it was expecting a variable name after var.  That's another (and somewhat cryptic) way of saying: you can't use var as a variable name.  That's why "var" is a reserved word.  It is reserved for a specific use by the language and not by you as you see fit.

Now you might also remember that a bunch of the Javascript examples used "alert()" as a way of popping up an alert box in the browser to display something.  For instance, alert("Testing") will pop up a box with the word "Testing" in it.  So what happens with the following bit of code?

alert("Testing"); var alert = 5; alert("What happens here?");

If "alert" is a reserved word then we should get the same error we encountered before.  But that's not what happens!  Instead we now see the following:

Javascript complains that alert is not a function *after* it has processed the var alert = 5.  So even though the "alert" came as something that was built into Javascript in the browser we were able to use it as a variable name and doing so removed its meaning as a function for opening an alert box.  Put differently, "alert" is not a reserved word for Javascript.

Now if you have paid close attention and also read the posts on syntax and semantics, you might have a number of objections to how Javascript handles all of this.  Such as, why wouldn't it take into consideration where and how a word occurs?  It would seem to be straightforward to keep alert working as before when it is followed by "(" as in alert("What happens here?") and have it stand for the variable when used in something like say var more = alert + 10;  That's an entirely valid point.  In fact as it turns out Javascript has a whole bunch of weirdness around reserved words  (scroll to end of the rather long page) -- it is not the only language for which that is true though!

abstract

and

array()

as

break

case

catch

class

clone

const

continue

declare

default

do

else

elseif

enddeclare

endfor

endforeach

endif

endswitch

endwhile

extends

final

for

foreach

function

global

goto

if

implements

interface

instanceof

namespace

new

or

private

protected

public

static

switch

throw

try

use

var

while

xor

die()

echo()

empty()

exit()

eval()

include()

include_once()

isset()

list()

require()

require_once()

return()

print()