kkk

--------------------------
Post Title 'OOC Assignment-4 Answers'
Post by user 'Adusumilli-Uday-Kumar'
Post encryped with secure 256-bit MD5 Encryption
Post accesable only VIA link
Post will Expire on '3-OCT-2017'
--------------------------



Q1.

"Write once, run anywhere" (WORA), is a slogan created by Sun Microsystems to illustrate the cross-platform benefits of the Java language. Ideally, this means Java can be developed on any device, compiled into a standard bytecode and be expected to run on any device equipped with a Java virtual machine (JVM).

This means a programmer can develop code on a PC and can expect it to run on Java enabled cell phones, as well as on routers and mainframes equipped with Java, without any adjustments. This is intended to save software developers the effort of writing a different version of their software for each platform or operating system they intend to deploy on.



Q2.

*) JVM

JVM (Java Virtual Machine) is an abstract machine. It is a specification that provides runtime environment in which java bytecode can be executed.  JVMs are available for many hardware and software platforms. JVM, JRE and JDK are platform dependent because configuration of each OS differs. But,  Java is platform independent.
The JVM performs following main tasks:
Loads code
Verifies code
Executes code
Provides runtime environment

*) JDK

It is a bundle of software that you can use to develop Java based applications. It's the full featured Software Development Kit for Java, including JRE, and the compilers and tools (like JavaDoc, and Java Debugger) to create and compile programs. The JDK is a superset of the JRE, and contains everything that is in the JRE, plus tools such as the compilers and debuggers necessary for developing applets and applications. It includes the JRE, set of API classes, Java compiler, Webstart and additional files needed to write Java applets and applications.



Q3.

The key considerations were summed up by the Java team in the following list of buzzwords:
• Simple
• Secure
• Portable
• Object-oriented
• Robust
• Multithreaded
• Architecture-neutral
• Interpreted
• High performance
• Distributed
• Dynamic

- Security
Java was able to acheive a high level of security by confining an applet to the Java execution environment and not allowing it access to other parts of the computer. The ability to download applets with confidence that no harm will be done and that no security will be breached is considered by many to be the single most innovative aspect of Java.

- Portability
Output of a Java compiler is Non Executable Code i.e Bytecode. Bytecode is executed by Java run-time system, which is called the Java Virtual Machine (JVM). Once JVM is installed for particular system then any java program can run on it. Internal details of JVM will differ from platform to platform but still all understand the Same Java Bytecode.

- Simple
Java was designed to be easy for the professional programmer to learn and use effectively. If you already understand the basic concepts of object-oriented programming, learning Java will be even easier. Best of all, if you are an experienced C   programmer, moving to Java will require very  little effort. Because Java inherits the C/C   syntax and many of the object-oriented features of C  , most programmers have little trouble learning Java.

- Object-Oriented
Object-Oriented Programming is a methodology or paradigm to design a program using classes and objects. It simplifies the software development and maintenance. The object model in Java is simple and easy to extend, while primitive types, such as integers, are kept as high-performance nonobjects.

- Robust
In today's world, programs will need to execute reliably in a variety of systems. Thus, the ability to create robust programs was given a high  priority in the design of Java. To gain reliability, Java restricts you in a few key areas to force you to find your mistakes early in program  development. At the same time, Java frees you from having to worry about many of the most common causes of programming errors. Because Java is a  strictly typed language, it checks your code at compile time. However, it also checks your code at run time. Many hard-to-track-down bugs that often turn up in hard-to-reproduce run-time situations are simply impossible to create in Java. Knowing that what you have written will behave in a  predictable way under diverse conditions is a key feature of Java.

- Multithreaded
Java supports multithreaded programming, which allows you to write programs that do many things simultaneously. The Java run-time system
comes with an elegant yet sophisticated solution for multiprocess synchronization. Java’s easy-to-use approach to multithreading allows you to think about the specific behavior of your program, not the multitasking subsystem.

- Architecture-Neutral
A central issue for the Java designers was that of code longevity and portability. Operating system upgrades, processor upgrades, and changes in core system resources can all combine to make a program malfunction. The Java designers made several hard decisions in the Java language and the Java Virtual Machine in an attempt to alter this situation. Their goal was “write once; run anywhere, any time, forever.” To a great extent, this goal was accomplished.

- Interpreted and High Performance
Most previous attempts at cross-platform solutions have done so at the expense of performance. The Java bytecode was carefully designed so that it would be easy to translate directly into native machine code for very high performance by using a just-in-time compiler. Java run-time systems that provide this feature lose none of the benefits of the platform-independent code.

- Distributed
Java is designed for the distributed environment of the Internet because it handles TCP/IP protocols. In fact, accessing a resource using a URL is not much different from accessing a file. Java also supports Remote Method Invocation (RMI). This feature enables a program to invoke methods across a  network.

- Dynamic
Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve accesses to objects at run time. This makes it possible to dynamically link code in a safe and expedient manner. This is crucial to the robustness of the Java environment, in which small fragments of bytecode may be dynamically updated on a running system.



Q4.

All object-oriented programming languages provide mechanisms that help you implement the object-oriented model.

*) Encapsulation
Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. The power of encapsulated code is that everyone knows how to access it and thus can use it regardless of the implementation details—and without fear of unexpected side effects.
In Java, the basis of encapsulation is the class. The data defined by the class are referred to as member variables or instance variables. The code that operates on that data is referred to as member methods or just methods. The behavior and interface of a class are defined by the methods that operate on its instance data.
Since the purpose of a class is to encapsulate complexity, there are mechanisms for hiding the complexity of the implementation inside the class. Each method or variable in a class may be marked private or public. The public interface of a class represents everything that external users of the class need to know, or may know. The private methods and data can only be accessed by code that is a member of the class. Therefore, any other code that
is not a member of the class cannot access a private method or variable. Since the private members of a class may only be accessed by other parts of your program through the class public methods, you can ensure that no improper actions take place.

*) Inheritance
Inheritance is the process by which one object acquires the properties of another object. This is important because it supports the concept of hierarchical classification. Most knowledge is made manageable by hierarchical (that is, top-down) classifications.
Without the use of hierarchies, each object would need to define all of its characteristics explicitly. However, by use of inheritance, an object need only define those qualities that make it unique within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance mechanism that makes it possible for one object to be a specific instance of a more general case.
Inheritance interacts with encapsulation as well. If a given class encapsulates some attributes, then any subclass will have the same attributes plus any that it adds as part of its specialization. A new subclass inherits all of the attributes of all of its ancestors. It does not have unpredictable interactions with the majority of the rest of the code in the system.

*) Polymorphism
Polymorphism is a feature that allows one interface to be used for a general class of actions. The specific action is determined by the exact nature
of the situation. This means that it is possible to design a generic interface to a group of related activities. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. It is the compiler’s job to select the specific action (that is, method) as it applies to each situation. You, the programmer, do not need to make this selection manually. You need only remember and utilize the general interface.

Polymorphism, Encapsulation, and Inheritance Work Together....
When properly applied, polymorphism, encapsulation, and inheritance combine to produce a programming environment that supports the development of far more robust and scalables programs than does the process-oriented model.
- A well-designed hierarchy of classes is the basis for reusing the code in which you have invested time and effort developing and testing.
- Encapsulation allows you to migrate your implementations over time without breaking the code that depends on the public interface of your classes.
- Polymorphism allows you to create clean, sensible, readable, and resilient code.



Q5.

Condiser compiling and running a short sample program....
----
// Call this file "Example.java".
class Example {
public static void main(String args[]) {
System.out.println("Hello World");
}
}
----

*) Basics of the Program
In Java, a source file is officially called a compilation unit. It is a text file that contains one or more class definitions. The Java compiler requires that a source file use the .java filename extension.
As you can see by looking at the program, the name of the class defined by the program is also Example. This is not a coincidence. In Java, all code must reside inside a class. By convention, the name of that class should match the name of the file that holds the program. You should also make sure that the capitalization of the filename matches the class name.
When Java source code is compiled, each individual class is put into its own output file named after the class and using the .class extension. This is why it is a good idea to give your Java source files the same name as the class they contain—the name of the source file will match the name of the .class file. When you execute java as just shown, you are actually specifying the name of the class that you want to execute. It will automatically search for a file by that name that has the .class extension. If it finds the file, it will execute the code contained in the specified class.

*) Compiling the Program
To compile the Example program, execute the compiler, javac, specifying the name of the
source file on the command line, as shown....
----
C:\>javac Example.java
----
The javac compiler creates a file called Example.class that contains the bytecode version
of the program. As discussed earlier, the Java bytecode is the intermediate representation of
your program that contains instructions the Java Virtual Machine will execute. Thus, the
output of javac is not code that can be directly executed.

*) Running the Program
To actually run the program, you must use the Java application launcher, called java.
To do so, pass the class name Example as a command-line argument, as shown....
----
C:\>java Example
----

*) Output of the Program
When the program is run, the following output is displayed....
----
Hello World
----



Q6.

Here's a program that demostrates initialization and assignment of different integer and floating point variables....
----
public class HelloWorld{
     public static void main(String []args){
// initializations
	int a = 2147483647 ; // variable of type integer
	byte b = 127 ; // variable of type byte
	short c = 32767 ; // variable of type short
	long d = 2147483647 ; // variable of type long
	float e = 12.233; // variable of type float
	double f = 21474833.648; // variable of type double


        System.out.println("\n The max value that an integer type variable can hold is = "  a   "\n The max value that an byte type variable can hold is = "  b   "\n The max value that an short type variable can hold is = "  c   "\n The max value that an long type variable can hold is = "  d   "\n The max value that an float type variable can hold is = "  e   "\n The max value that an double type variable can hold is = "  f);
     }
}
----



Q7.

output of the given program is....
----
1
67
----



Q8.

We get this error....
----
incompatible types: possible lossy conversion from int to byte
----
it can be avoided by making b an integer data type as such...
int b =50 ; b = b*2 ;



Q9.

The following is the outpput of the code....
----
 -1
 50
 -1
 50
 -1
 50
----
If we add another 'int b' outside the for loop, then we'll get an error for defining the variable 'b' mltiple times.



Q10.

Assigning a value of one type to a variable of another type is known as Type Casting.
In Java, type casting is classified into two types,

1) Widening Casting(Implicit)
Automatic Type casting take place when, the two types are compatible or when the target type is larger than the source type.

2) Narrowing Casting(Explicitly done)
When you are assigning a larger type value to a variable of smaller type, then you need to perform explicit type casting.

Example....
----
public class Test
{
    public static void main(String[] args)
    {
      int i = 100;
      long l = i; //no explicit type casting required, as long is a bigger data type than int
      float f = l; //no explicit type casting required, as float is a bigger data type than int
      double da = 100.04;
      long la = (long)da; //explicit type casting required, as long is a smaller data type than double
      int ia = (int)da; //explicit type casting required, as int is a smaller data type than double
    }

}
----