Understanding New JScript .NET Statements

JScript .NET is a fully object oriented programming language,
since it provides direct support, through the class statement, for creating your own
types that encapsulate data, and behavior. This week's article
takes an in-depth look at several JScript .NET statements:

class

const

enum

package

import

Understanding objects and classes

Objects and classes act as placeholders to represent everything
from tangible things to immaterial things like ideas and
concepts. Objects and classes exist, in part, to manage
complexity during the design, implementation, and maintenance
phases of a solution's lifecycle. Since objects and classes
have the same role, why not just have a class or an object -
why two things?

An object is different from a class very subtle but important
ways:

An object is an instance of a class

Objects exist in the context of an active system

An object can be active - acting on its own and having its own
thread of execution - or it can be passive - waiting for some
other entity to tell it what to do. An object requires system
resources, such as memory or disk space, and there can be more
than one instance of the same object.

Think of a class as a template for an object. A class is a
static (unchanging) representation of a potential
object - a class doesn't directly represent an object. When
your code creates an instance of an object, what it is really
doing is instantiating an object of the type that the class
specifies. As soon as the object comes into existence, the
class that it is based on is no longer important (unless you
want to determine what type the object is or want to change its
type).

The class illustrates a minimal implementation having a
constructor and several member variables. Variables that are
part of a class, that is, variables that you declare inside of
a class are referred to as member variables since they are
members (or parts) of the class they reside in. You can access
a class's member variables through the class - the member
variables typically do not exist unless an instance of the
class's object exists (unless you declare a static variable, in which case the
variable is accessible without an instance of the class's
object).

Member functions, like member variables, are functions that
appear within a class declaration and are also accessible
through the class's object. There is one type of member
function that plays a special role in the class object's
lifetime: the constructor. A constructor's role is to
(usually) set the initial state of a new object. When you
create an instance of a new object, the underlying system calls
the object's constructor before any other code can access the
object - giving the object the opportunity to initialize
itself. Constructors have the same name as their class, as
shown in the previous listing. Constructors don't have any
limitations on what they can do while they initialize a new
object - except that you cannot return a value from a
constructor (the return type is implicitly void). A class can have more than one
constructor, as I'll demonstrate shortly.

Use a class like you would any other type by declaring a
variable that refers to the object and create an instance of
it. For example, you could create an instance of a kitchenAppliance and refer to its member
variables using the following code:

Sometimes it's awkward to create a class and then initialize
it, especially if you need to do that throughout your code. A
class can have more than one constructor to make it easier to
create and initialize a new object. For example, take a look at
the following code:

The listing illustrates a cubicDimentions class with two
constructors. The first constructor takes three arguments that
are quantity types and the
second takes six arguments made up of float and unit types. The listing also
demonstrates, near the bottom, how the second constructor makes
it easier to create an instance of a cubicDimentions object. It is easier to
create an cubicDimentions
object by using simple float
and unit types instead of
having to create a new quantity type for each measurement. The
JScript .NET compiler determines which constructor your code
refers to based on the types of the parameters you pass to it.

Understanding Static class members

The static modifier allows you to create member variables and
functions that you can directly refer to without an instance of
the class object. Static members are useful in cases where a
class acts as a helper - operating on other objects to perform
some operation. For example, the kitchen appliances sample code
includes a class called converter that converts from one unit of
measure to another, as shown in the following listing:

The class has a single static member function that converts
from one quantity (a type
that represents an numeric measure and a unit of measurement)
to another quantity based on
their respective, underlying units of measure (units). The convert member function operates on
existing objects and does not need to maintain any of its own
data internally, making it a good candidate for being static. When a member function is
static, you can simply refer to it directly, as shown:

The listing calls the convert method directly through the
converter class without
having an instance of the class object on hand. You can refer
to static member variables in the same way.

Understanding the const statement

The const statement allows
you to declare a variable that has an unchanging value. const variables are useful when
you use a value throughout your code and work to make it easier
to maintain and understand your code. For example, you could
use a constant variable to specify the conversion ratio between
miles and kilometers, as shown in the following listing:

The listing shows an enumeration called appliances defining several types, bound
to an integer type. The kitchenAppliance declares a type variable, that represents the type
of kitchen appliance, that's bound to the appliances enumeration. Using this
technique allows the compiler to confirm, at compile time, that
the value you assign to the type variable is valid and makes your
code easier to read.

Understanding the package statement

A package allows you do
create logical groupings of your code - the groups are formally
referred to as namespaces. A package is useful in
cases where there are name collisions between your
code and some other class or third party library. For example,
the following listing groups two classes into a package (or
namespaces) to avoid name collisions with existing classes from
other libraries:

Understanding the import statement

The import statement makes
members of other namespaces (or packages) available for you to
use in your code. The import
statement allows the JScript .NET compiler to resolve
references to other namespaces and allows the Common Language
Runtime to ensure that libraries that your applications rely on
are available before your code executes. The following listing
demonstrates how to use the import statement to gain access to the
the System.Data and System.Text namespaces:

import System.Data;
import System.Text;

Summary

This article introduced and explained some of the newer
statements available in JScript .NET, their benefits, and how
to use them. The next three upcoming articles in this series
look at applying JScript .NET and the .NET Framework to
practical applications in the form of ASP.NET sites, Web
Services, and Windows Forms applications.