Java Programming

A default value is the one that has been considered the most appropriate on several

systems, methods, programs. Obviously it is the parameter which works better, otherwise it wouldn't be set as a standard value. To set something "by default" is the same as to choose a value, a configuration more convenient for that purpose.

The computer desktop encyclopedia says

In object technology, to create an object of a specific class

(1) A single copy of a running program. Multiple instances of a program mean that the program has been loaded into memory several times. (2) In object technology, a member of a class; for example, "Lassie" is an instance of the class "dog." When an instance is created, the initial values of its instance variables are assigned.

If you're talking about "traditional" AI programming languages like LISP and Prolog, the essential difference boils down to the language's ruling metaphor.

Most standard programming languages operate on a principle of sequential and/or branching instruction execution.

OTOH, the LISt Processing language (LIST) encourages its programmers to view everything (all solutions to programming problems) in the form of one or many lists.

Prolog is perhaps the furthest evolution to date away from the standard, sequential-instruction programming model: in Prolog, the programmer does not explicitly spell out the sequence of operations (a.k.a., "procedure," hence "procedural languages") needed to solve a problem; instead, the problem is simply declared (hence, "declarative language"), and the language itself (or rather the engine implementing it) seeks out the solution.

Nowadays, though, you'll find AI being implemented in any number of standard procedural languages -- C++, Java, even scripting languages like Perl and Python.

In an abstract class some methods could be abstract meaning a sub-class must provide the actual implementation code or non-abstract in those cases the functionality is common to all or most of the sub-classes. With respect to the non-abstract classes, some sub-classes could override those as needed unless they're defined final.

Example of such classes found in the core J2SE API include:

java.awt.Component, java.awt.geom.Point2D, java.io.InputStream, java.io.Reader, java.util.AbstractCollection, and many others.

Take java.util.AbstractCollection as a typical example. It provides placeholders for abstract methods iterator() and size(), and provides the concrete methods clear(), contains(), isEmpty(), etc. which use the former abstract methods to perform a generic function as defined in the specific implementation of a sub-class. The abstract class defers the details of the specific implementation to its sub-classes. The class java.util.HashSet extends AbstractCollection and defines the non-abstract implementation code for both iterator() and size() methods.

The primitive data types in Java are:

• int: integer value from -232 to 232
• float
• double
• long: integer value from -264 to 264
• byte: integer value from -128 to 128
• char: character
• short: integer value from -32768 to 32768
• boolean: true or false value
• String (not actually a primitive data type)

Single Inheritance

In "single inheritance," a common form of inheritance, classes have only one base class. Consider the relationship illustrated in the following figure. Simple Single-Inheritance Graph

Note the progression from general to specific in the figure. Another common attribute found in the design of most class hierarchies is that the derived class has a "kind of" relationship with the base class. In the figure, a Book is a kind of a PrintedDocument, and a PaperbackBook is a kind of a book.

One other item of note in the figure: Book is both a derived class (from PrintedDocument) and a base class (PaperbackBook is derived from Book). A skeletal declaration of such a class hierarchy is shown in the following example:
Copy Code // deriv_SingleInheritance.cpp // compile with: /LD class PrintedDocument {}; // Book is derived from PrintedDocument. class Book : public PrintedDocument {}; // PaperbackBook is derived from Book. class PaperbackBook : public Book {};

PrintedDocument is considered a "direct base" class to Book; it is an "indirect base" class to PaperbackBook. The difference is that a direct base class appears in the base list of a class declaration and an indirect base does not.

The base class from which each class is derived is declared before the declaration of the derived class. It is not sufficient to provide a forward-referencing declaration for a base class; it must be a complete declaration.

In the preceding example, the access specifier public is used. The meaning of public, protected, and private inheritance is described in Member-Access Control.

A class can serve as the base class for many specific classes, as illustrated in the following figure. Sample of Directed Acyclic Graph

In the diagram shown above, called a "directed acyclic graph" (or "DAG"), some of the classes are base classes for more than one derived class. However, the reverse is not true: there is only one direct base class for any given derived class. The graph in the figure depicts a "single inheritance" structure. Note:

Directed acyclic graphs are not unique to single inheritance. They are also used to depict multiple-inheritance graphs. This topic is covered in Multiple Inheritance.

In inheritance, the derived class contains the members of the base class plus any new members you add. As a result, a derived class can refer to members of the base class (unless those members are redefined in the derived class). The scope-resolution operator (::) can be used to refer to members of direct or indirect base classes when those members have been redefined in the derived class. Consider this example:
Copy Code

// deriv_SingleInheritance2.cpp // compile with: /EHsc /c #include using namespace std; class Document { public: char *Name; // Document name. void PrintNameOf(); // Print name. }; // Implementation of PrintNameOf function from class Document. void Document::PrintNameOf() { cout << Name << endl; } class Book : public Document { public: Book( char *name, long pagecount ); private: long PageCount; }; // Constructor from class Book. Book::Book( char *name, long pagecount ) { Name = new char[ strlen( name ) + 1 ]; strcpy_s( Name, strlen(Name), name ); PageCount = pagecount; };

Note that the constructor for Book, (Book::Book), has access to the data member, Name. In a program, an object of type Book can be created and used as follows:
Copy Code

// Create a new object of type Book. This invokes the // constructor Book::Book. Book LibraryBook( "Programming Windows, 2nd Ed", 944 ); ... // Use PrintNameOf function inherited from class Document. LibraryBook.PrintNameOf();

As the preceding example demonstrates, class-member and inherited data and functions are used identically. If the implementation for class Book calls for a reimplementation of the PrintNameOf function, the function that belongs to the Document class can be called only by using the scope-resolution (::) operator:
Copy Code

// deriv_SingleInheritance3.cpp // compile with: /EHsc /LD #include using namespace std; class Document { public: char *Name; // Document name. void PrintNameOf() {} // Print name. }; class Book : public Document { Book( char *name, long pagecount ); void PrintNameOf(); long PageCount; }; void Book::PrintNameOf() { cout << "Name of book: "; Document::PrintNameOf(); }

Pointers and references to derived classes can be implicitly converted to pointers and references to their base classes if there is an accessible, unambiguous base class. The following code demonstrates this concept using pointers (the same principle applies to references):
Copy Code

// deriv_SingleInheritance4.cpp // compile with: /W3 struct Document { char *Name; void PrintNameOf() {} }; class PaperbackBook : public Document {}; int main() { Document * DocLib[10]; // Library of ten documents. for (int i = 0 ; i < 10 ; i++) DocLib[i] = new Document; }

In the preceding example, different types are created. However, because these types are all derived from the Document class, there is an implicit conversion to Document *. As a result, DocLib is a "heterogeneous list" (a list in which not all objects are of the same type) containing different kinds of objects.

Because the Document class has a PrintNameOf function, it can print the name of each book in the library, although it may omit some of the information specific to the type of document (page count for Book, number of bytes for HelpFile, and so on). Note:

Forcing the base class to implement a function such as PrintNameOf is often not the best design. Virtual Functions offers other design alternatives.

By:- Deb