Java Programming

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

James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991. Java was originally designed for interactive television, but it was too advanced for the digital cable television industry at the time. The language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green later, and was later renamed Java, from Java coffee, said to be consumed in large quantities by the language's creators. Gosling aimed to implement avirtual machine and a language that had a familiar C/C++ style of notation.

Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run Anywhere" (WORA), providing no-cost run-times on popularplatforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998-1999), new versions had multiple configurations built for different types of platforms. For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.

In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a de factostandard, controlled through the Java Community Process. At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the compiler, utility programs, and header files.

On November 13, 2006, Sun released much of Java as free and open source software, (FOSS), under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the copyright.

Sun's vice-president Rich Green said that Sun's ideal role with regards to Java was as an "evangelist." Following Oracle Corporation's acquisition of Sun Microsystems in 2009-2010, Oracle has described itself as the "steward of Java technology with a relentless commitment to fostering a community of participation and transparency". This did not hold Oracle, however, from filing a lawsuit against Google shortly after that for using Java inside the Android SDK (see Google section below). Java software runs on laptops to data centers, game consoles to scientific supercomputers. There are 930 million Java Runtime Environment downloads each year and 3 billion mobile phones run Java.[21] On April 2, 2010, James Gosling resigned from Oracle.

By default, operator new() allocates memory on the free store (the heap). The standard defines four global operators:

The global operator new() has three standard implementations defined in :

1. void* operator new (std::size_t size);
2. void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) noexcept;
3. void* operator new (std::size_t size, void* ptr) noexcept;

The first implementation allocates size bytes on the free store and returns a generic pointer (void*) to the first byte of the allocation. If the allocation fails for any reason, a std::bad_alloc exception is thrown. This operator is therefore known as a throwing allocation.

The second is the same as the first but does not throw an exception. If the allocation fails for any reason, nullptr is returned instead. this is known as a nothrow allocation.

The third version is used when (raw) memory has already been allocated and simply returns the given ptr argument. The memory referred to by ptr need not be allocated on the heap. This version is known as placement.

In all three cases, the allocated memory is simply raw, uninitialised memory (similar to what we would expect when invoking the standard global malloc() function in C).

In addition, the standard also defines global operator new[]() (also in ):

1. void* operator new[] (std::size_t size);
2. void* operator new[] (std::size_t size, const std::nothrow_t& nothrow_value) noexcept;
3. void* operator new[] (std::size_t size, void* ptr) noexcept;

These versions are used when we wish to allocate an array of objects and have similar behaviours to the "normal" global operators.

Note that all these operators are defined implicitly; we do not need to explicitly include the header to use them.

In order to physically construct an object via global operator new (), the object's class must define a static member operator new (). Given that it would be tedious to do this for every class that we define, this is done implicitly for us. Thus when we invoke the following:

T* ptr = new T {args...};

T* ptr = new T[N] {args...};

we are actually invoking the following:

T* ptr = T::operator new (args...);

T* ptr = T::operator new[] (N, args...);

The (implicit) static member operator new() and operator new[]() are implementation-defined, but will generally be defined as follows:

T* T::operator new (args...) {

T* ptr = ::new (sizeof (T)); // invoke the global operator (may throw)

// initialise the memory from args...

return ptr;

}

T* T::operator new[] (std::size_t N, args...) {

T* ptr = ::new[] (N * sizeof (T)); // invoke the global operator (may throw)

// initialise the memory for each N from args...

return ptr;

}

Now we can see where the std::size_t argument passed to global operator new() actually comes from.

Given that T::operator new() is a member function, it can be overloaded on a class-by-class basis if we wish to provide our own memory management facility. We can also overload the global operator new(), however this is not recommended because there's no way of knowing how other classes we have no control over might be affected, particularly those which provide their own member operator new() overloads and which expect the default behaviour of the global operator new(). Overloading global operator new() is not for the feint-hearted, thus it is recommended you use a tried-and-tested library for global memory management rather than attempting to write your own from scratch.

A number of well-tested open-source Matrix Java libraries are available. Best to find and use one that's been around for a while since most of the bugs have been worked out. If you need to write your own it's still worth-while to examine the APIs of those libraries first.

JAMA is a free Java library for basic linear algebra and matrix operations developed as a straightforward public-domain reference implementation by MathWorks and NIST.

Example of Use. The following simple example solves a 3x3 linear system Ax=b and computes the norm of the residual.

double[][] array = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}};

Matrix A = new Matrix(array);

Matrix b = Matrix.random(3,1);

Matrix x = A.solve(b);

Matrix Residual = A.times(x).minus(b);

double rnorm = Residual.normInf();

Java allows us to perform 'dynamic initialization' of variables too.

What this means is that you can initialize variables using expressions (as will be seen in the example).

In the program, we have a int variable 'root' which has an initial defined value of 10. We then create another variable 'square' of the same data-type, which will store the square of root.

//This program displays dynamic initialization in java

publicclassExample

{

publicstaticvoidmain(String args[])

{

introot=10; //root has a constant value assigned

intsquare=root*root; //notice that square has "root*root" assigned to it

//if u change the value of root,

//the value of square changes accordingly

//after each compilation

//display the values of square and root

System.out.println("Root= " +root + " Square= "+square);

}

}