Java Programming

[Eating] A Pie:

Abstraction: grouping some data and behaviors into a programming unit with semantic similarity (not randomly), e.g, class, struct

Polymorphism: different object with the same name (same name of a method, variable, but in more than 1 form)

Inheritance: the most important characteristics of an OO language (Object base language would not have this one). It allows a derived class to inherit the data and behaviors from the base class(es), as if those data and behaviors are defined within.

Encapsulation: or information hiding. Object has data members that no one outside of the same class would know what type or shape they are. It also applied to the behaviors.

Imagine you want to save the state of one or more objects. If Java didn't have serialization, you'd have to use one of the I/O classes to write out the state of the instance variables of all the objects you want to save. The worst part would be trying to reconstruct new objects that were virtually identical to the objects you were trying to save. You'd need your own protocol for the way in which you wrote and restored the state of each object, or you could end up setting variables with the wrong values. For example, imagine you stored an object that has instance variables for height and weight. At the time you save the state of the object, you could write out the height and weight as two ints in a file, but the order in which you write them is crucial. It would be all too easy to re-create the object but mix up the height and weight values-using the saved height as the value for the new object's weight and vice versa.

The purpose of Serialization is to help us achieve whatever complicated scenario we just witnessed in an easier manner.

Working with ObjectOutputStream and ObjectInputStream

The magic of basic serialization happens with just two methods: one to serialize objects and write them to a stream, and a second to read from the stream and deserialize the object.

ObjectOutputStream.writeObject() - serialize and write

ObjectInputStream.readObject() - read and deserialize

The java.io.ObjectOutputStream and java.io.ObjectInputStream classes are considered to be higher-level classes in the java.io package, and as we learned in the previous chapter that means that you'll wrap them around lower-level classes, such as java.io.FileOutputStream and java.io.FileInputStream. Here's a small program that creates an object, serializes it, and then deserializes it:

import java.io.*;

class Car implements Serializable { } // 1

public class SerializeCar {

public static void main(String[] args) {

Car c = new Car(); // 2

try {

FileOutputStream fs = new FileOutputStream("testSer.ser");

ObjectOutputStream OS = new ObjectOutputStream(fs);

OS.writeObject(c); // 3

OS.close();

} Catch (Exception e) { e.printStackTrace(); }

try {

FileInputStream fis = new FileInputStream("testSer.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

c = (Car) ois.readObject(); // 4

ois.close();

} Catch (Exception e) { e.printStackTrace(); }

}

}

Let's take a look at the key points in this example:

1. We declare that the Car class implements the Serializable interface. Serializable is a marker interface; it has no methods to implement.

2. We make a new Car object, which as we know is serializable.

3. We serialize the Car object c by invoking the writeObject() method. First, we had to put all of our I/O-related code in a try/Catch block. Next we had to create a FileOutputStream to write the object to. Then we wrapped the FileOutputStream in an ObjectOutputStream, which is the class that has the magic serialization method that we need. Remember that the invocation of writeObject() performs two tasks: it serializes the object, and then it writes the serialized object to a file.

4. We de-serialize the Car object by invoking the readObject() method. The readObject() method returns an Object, so we have to cast the deserialized object back to a Car. Again, we had to go through the typical I/O hoops to set this up.

This is a simple example of serialization in action.

Here's a simple Java method to perform the conversion from decimal to a binary string representation:
public String toBinaryString(int n) {
StringBuilder sb = new StringBuilder();
while(n != 0) {
sb.insert(0, n % 2 != 0 ? '1' : '0');
n /= 2;
}
return sb.toString();
}

The java.lang.Integer class provides a conversion helper method between decimal (integer) and binary numbers in string form called toBinaryString().

String binaryValue = Integer.toBinaryString(43) // 43-> "101011"

I am providing a succinct and easy to understand version of the program. I have run it in 3-4 compilers and it works perfect. Mind you, you should not enter a number more than 2147483647 (which is the largest number a variable can process in C!). If you do, no problem, but it will display all numbers above it, including the even numbers to be prime. So here you are:

#include

#include

main()

{

long int a,b,c;

printf("Enter the number: ");

scanf("%ld",&a);

for (b=2;b

{

c= a%b;

if (c==0)

goto cool;

}

printf("\nThe number is goddamned prime!");

goto fool;

cool: printf("\nThis ain't a prime number you dumbo!");

fool: printf("\n");

}

By the way I am not sure what your query really was. I gave the above program to check whether a number is prime or not. If you mean to generate prime numbers between 2 (which is of course the first prime number) and a given number g and also want to know the number of prime numbers between the two, well here is it:

#include

#include

main()

{

long int a=2,i=2,c,count=0,g;

printf("Prime numbers upto what number should be generated? ");

scanf("%ld",&g);

printf("\nFollowing is the list of prime numbers:\n");

while (a<=g)

{

for (i=2;i

{

c=(a%i);

if (c==0)

goto cool;

else

continue;

}

printf("\n%ld",a);

++count;

cool: ++a;

}

printf("\nTotal number of prime numbers between 2 and %ld is %ld. ",g,count);

}

For both these programs, simply copy-paste them into your compiler and have your result. Hope you got what you wanted...

System.out.print is a standard output function used in java. where System specifies the package name , out specifies the class name and print is a function in that class. This function is different from the System.out.println() since it does not place a new line after printing the variable. System.out.println("hello"); // prints hello System.out.print("hello"); //also prints hello but if you then

System.out.println("how are you"); //it continues from the last print resulting in

// hellohow are you This also calls the default toString() method of the variable you put as the parameter.

Note: not all Classes have a helpful toString() method, i.e. arrays do not have toString(), thus a nasty memory address is printed.