Testing tamil content

இறைவன் மறப்பற்றுச் சோதி வடிவில் 

பிரகாசமுடையவனாய் நிற்பான் அவன். “தொந்தத்தசி” (துவம் - இரண்டு, அற:

தத் -தானான, இறைவன்: அசி - இருக்கிறான்) பிரிவற எல்லாவற்றுள்ளும்

இறைவன் சொந்தம் எனக் கலந்திருக்கிறான் என்பது தத்துவம். “வுரழர வாயவ” 

அவன் அதுவாக எந்த மறப்பும் இன்றி நின்மலனாய் இருக்கிறான் என்பது 

பொருளாகும். உலகில் விளங்கும் இறைவனைக் குறித்த சிந்தனைகளில் 

மேற்கூறிய கருத்துக்கள் மெய்ப்பொருளியலில் (Pரடைழளழிரல) மிக

முக்கியமாகக் கருதப் பெறுகின்றது. 

வித்திலிருந்து முளையா அல்லது முளையிலிருந்து வித்தா போன்ற 

இத்தன்மைகள் செயல் நிலையில் பொருள்கட்குள் புகுகின்றன. இத்தன்மைகள் 

எல்லாம் கடவுளுக்கே உரியன ஆகின்றபோது கடவுளே செயலாற்றுகிறவரும் 

நிமித்த காரணனும் இயற்கை உண்மையும் ஆகின்றார். சித்தர்களின் 

கருத்துப்படி பொருட்களின் உண்மை நிலையிலிருந்து செயல்படும் 

தன்மைகளில் குணங்களாயும் இருப்பாயும் அப்பொருளில் இல்லை. 

அப்பொருள் ஆவதை ஏற்பவர் கடவுளாக இருக்கிறார். அவ்வாறு இருப்பவர் 

ஒருவரே. அவருக்கு குணங்கள் உள்ளன. மறப்பற்றிருக்கும் நின்மலன் என்பது 

அவருக்கே உரிய குணங்களுள் ஒன்றாகும். அவரே செயற்தலைவர் ஆவார். 

வானும் விண்ணும் அவருக்கே உரியன. அவரே மறப்பற்றுப் பிரகாசம் 

உடையவராய் எங்கும் தானாகி, எல்லாவற்றுள்ளும் அதிகாரம் உடையவரும் 

நின்மலனும் இறைவனும் தலைவனும் ஆகின்றார்.

பெரிய புராணத்தில் அவரைப்பற்றிக் கூறும் பிட்டுக்கு மண் சுமந்த 

காதையில், அரசன் பிரம்பால் அடிக்க, அவர் அடி வாங்கி, எவ்வுயிரு 

எவ்வுலகு எத்துறைக்கெல்லாம் அவ்வடி கொடுத்த அருள்நிறை நாயகர் 

இறைவனாய் இருந்ததைக் கண்டு நாம் உணரலாம். ஔவையார் வகுத்த 

செந்தமிழ் வேதம் விளைத்த ஏதமில் ஔவைக்குறள் வாக்கால் நின்மலனாய் 

எங்கும் தானாகி நின்றது வாழியவே 

Marker Interface in java

Marker interfaces are also called "tag" interfaces since they tag all the derived classes into a category based on their purpose. For example, all classes that implement the Cloneable interface can be cloned (i.e., the clone() method can be called on them). The Java compiler checks to make sure that if the clone() method is called on a class and the class implements the Cloneable interface. For example, consider the following call to the clone() method on an object o:

SomeObject o = new SomeObject();
SomeObject ref = (SomeObject)(o.clone());

If the class SomeObject does not implement the interface Cloneable (and Cloneable is not implemented by any of the superclasses that SomeObject inherits from), the compiler will mark this line as an error. This is because the clone() method may only be called by objects of type "Cloneable." Hence, even though Cloneable is an empty interface, it serves an important purpose.

other marker interfaces are

- java.io.Serializable
- java.util.EventListener
- java.util.RandomAccess

Volatile in Java

If, in the following example, one thread repeatedly calls the method one() and another thread repeatedly calls the method two():

class Test {
static int i = 0, j = 0;
static void one() { i++; j++; }
static void two() {
System.out.println("i=" + i + " j=" + j);
}
}
then method two could occasionally print a value for j that is greater than the value of i, because the example includes no synchronization and the shared values of i and j might be updated out of order.

One way to prevent this out-of-order behavior would be to declare methods one and two to be synchronized.

Another approach would be to declare i and j to be volatile:

class Test {
static volatile int i = 0, j = 0;
static void one() { i++; j++; }
static void two() {
System.out.println("i=" + i + " j=" + j);
}
}
This allows method one and method two to be executed concurrently, but guarantees that accesses to the shared values for i and j occur exactly as many times, and in exactly the same order, as they appear to occur during execution of the program text by each thread. Therefore, the shared value for j is never greater than that for i, because each update to i must be reflected in the shared value for i before the update to j occurs

Static Import

It helps to import all the static members of a class into our class
For e.g. If u want to import all static members of Math class,Then
u can give the import statement like the following:

import static Java.Lang.Math.*;

Basic need of this type of import is u can directly call those static methods without using their class name.

for e.g: u can call absolute function in Math class as

abs(10);
No need to give like this as Math.abs(10);

Defining functions with varying parameters

Ellipsis concepts in java helps to define a function with varying parameters.Following example will help u to understand this.

public class VaryingParametersTest {
   public static void main(String args[]) {
           System.out.println(add(1, 2, 3));
           System.out.println(add(1, 2, 3, 4, 5, 6));
   }

   public static int add(int... values) {
        int sum = 0;
        for (int val : values) {
            sum = sum + val;
        }
        return sum;
   }
}

Various ways in creating the object

1.Using new operator:
      A a=new A();
2.Using Reflections:
       A a=Class.forName("A").newInstance();
3.Using clone method:
      A a=new A();
      A b=a.clone();
Class A should implements cloneable interface
4.Using ClassLoader:
      A a =cL.loadClass("A").newInstance();
   cL is instance of ClassLoader.

Test Your Skills

Which of the following statements are wrong?

1) Integer a[]=new Integer[10];

2)Object b[]=new Integer[10];

3)Object c=new Integer[10];


Just think it.Don't try it in your java editor.

Actually all statements are right.Specially I want to mention
about third statement .It is valid because Object class is a base
class for Array Class too.