Java Programming

java has five types of keywords

those are:

1.system package

2.utilities package

3.networking package

4.Abstract Window Tool package

5.applet package

It is cleared in the same manner as hard copy information is cleard and it needs to be cleared for unlimited access by the Public Affairs Office.
it is cleared in the same manner as hard copy information is cleared

it needs to be cleard for unlimited access by the public affairs office

Yes, via a static up-cast. Up-casting to a base class is always safe so there's no need to dynamically cast (dynamic casting is only a requirement when down-casting, but even then that's usually a sign of a poorly-designed virtual interface).

Consider the following classes:

class A{};

class B : public class A{};

If we create an instance of B we can then point at that instance using a derived class pointer:

B b;

B* pb = &b;

To "convert" pb to a base class pointer we statically cast it like so:

A* pa = (A*) pb;

Or, more simply, we can just point at the derivative's address:

A* pa = &b;

Note that we don't actually convert anything. Although pa points to the base class, the actual instance we're pointing at is still a derived class. This is what enables us to pass pointers and references to derived classes into functions that actually expect pointers or references to base classes. Even though those functions can have no prior knowledge of what derivatives it might receive in the future, they simply don't have to. As far as the functions are concerned, you've passed a base class, not a derivative. But if you call a virtual method of the base class then the derived class method will be called instead -- and that's precisely what one expects of a derivative. This is how inheritance and polymorphism work.

If you really want to convert to a base class (completely eliminating the derived class), then you must call the base class copy constructor, passing the derived class as the argument:

B b;

A a(b);

Note that a and b are now completely separate instances and a is nothing more than the base class component of b, devoid of all its derived class components. Thus if you were to mutate a, you will not mutate b, and vice versa. The casts shown previously do not create separate instances -- there is only the one instance -- so any mutations affect all pointers to that one instance, whether they be base class pointers or derived class pointers.

You can also use the copy constructor to point at a new instance of the base class, creating the new instance on the heap rather than the stack:

A* pa = new A(b);

In order to make use of A's assignment operator, you must provide a cast operator in B:

class B : public A

{

public:

operator A(){return(A(*this));}

};

Now you can perform the following assignment:

A a;

B b;

a = b;

Note that a and b remain completely separate instances.

Lightweight framework do not have to depend on framework interfaces or abstract classes to hook or instantiate components into them.

Heavyweight frameworks on the other hand require the extension of framework classes or the implementation of framework interfaces in order to take advantage of their middleware features.This means that a lot of classes are instantiated and hooked on to your application when they may not be even required!!

Polymorphism

Polymorphism allows the programmer to treat derived class members just like their parent class' members. More precisely, Polymorphism in object-oriented programming is the ability of objects belonging to different data types to respond to method calls of methods of the same name, each one according to an appropriate type-specific behavior. One method, or an operator such as +, -, or *, can be abstractly applied in many different situations. If a Dog is commanded to speak(), this may elicit a bark(). However, if a Pig is commanded to speak(), this may elicit an oink(). They both inherit speak() from Animal, but their derived class methods override the methods of the parent class; this is Overriding Polymorphism. Overloading Polymorphism is the use of one method signature, or one operator such as "+", to perform several different functions depending on the implementation. The "+" operator, for example, may be used to perform integer addition, float addition, list concatenation, or string concatenation. Any two subclasses of Number, such as Integer and Double, are expected to add together properly in an OOP language. The language must therefore overload the addition operator, "+", to work this way. This helps improve code readability. How this is implemented varies from language to language, but most OOP languages support at least some level of overloading polymorphism. Many OOP languages also support Parametric Polymorphism, where code is written without mention of any specific type and thus can be used transparently with any number of new types. Pointers are an example of a simple polymorphic routine that can be used with many different types of objects.