1, జులై 2015, బుధవారం

budjet phones

వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

16, మార్చి 2015, సోమవారం

Sony VPL-CX21 Operating Instructions Manual: Messages List

వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

9, మార్చి 2015, సోమవారం

JAVA SITES IN TELUGU

All Java sites and Java related technologies sites. Java interview questions sites,jsf sites, core java sites,hibernate sites,struts sites,web services sites etc..
HIBERNATE SITES:
www.hibernate.org
www.roseindia.net/hibernate/index.shtml
www.developersbook.com/
www.mkyong.com/tutorials/hibernate-tutorials/
www.docs.jboss.org/hibernate/core/3.5/reference/en/html/tutorial.html
www.laliluna.de/.../struts-1-hibernate-integration-tutorial-en.html
www.javabeat.net/tutorials/19-what-is-hibernate.html
www.hibernatetutorial.com/
www.myeclipseide.com/documentation/quickstarts/hibernate
http://www.vaannila.com/hibernate/hibernate-tutorial/hibernate-tutorial.htm
www.viralpatel.net/.../tutorial-struts2-hibernate-example-eclipse.html
www.facestutorials.icefaces.org/tutorial/hibernate-tutorial.html
www.laliluna.de/articles/first-hibernate-example-tutorial.html
www.java-samples.com/showtutoriallist.php?...Hibernate...1
http://www.skill-guru.com/blog/2009/08/05/first-hibernate-tutorial-%E2%80%93get-hands-on-experience/
http://www.lulu.com/items/volume_62/1087000/1087191/3/print/Hibernate-Spring-Maven-Eclipse-Tutorial.pdf
http://en.wikipedia.org/wiki/Hibernate_(Java)
http://www.javabeat.net/articles/hibernate/1/
 
JAVA FORUMS:
 
WEB SERVICES SITES:
http://download.oracle.com/docs/cd/E17802_01/webservices/webservices/docs/1.6/tutorial/doc/index.html
www.developers.net/node/view/165
www.w3schools.com/webservices/default.asp
Comments
You do not have permission to add comments.
వీరిచే పోస్ట్ చేయబడింది వద్ద 1 కామెంట్‌:

19, ఫిబ్రవరి 2015, గురువారం

Assertion:

Assertion is a statement in java. It can be used to test your assumptions about the program.
While executing assertion, it is believed to be true. If it fails, JVM will throw an error named AssertionError. It is mainly used for testing purpose.

Advantage of Assertion:

It provides an effective way to detect and correct programming errors.

Syntax of using Assertion:

There are two ways to use assertion. First way is:
  1. assert expression;  
and second way is:
  1. assert expression1 : expression2;  

Simple Example of Assertion in java:

  1. import java.util.Scanner;  
  2.     
  3. class AssertionExample{  
  4.  public static void main( String args[] ){  
  5.   
  6.   Scanner scanner = new Scanner( System.in );  
  7.   System.out.print("Enter ur age ");  
  8.     
  9.   int value = scanner.nextInt();  
  10.   assert value>=18:" Not valid";  
  11.   
  12.   System.out.println("value is "+value);  
  13.  }   
  14. }  

If you use assertion, It will not run simply because assertion is disabled by default. To enable the assertion, -ea or -enableassertions switch of java must be used.
Compile it by: javac AssertionExample.java
Run it by: java -ea AssertionExample
Output: Enter ur age 11
Exception in thread "main" java.lang.AssertionError: Not valid at AssertionExample.main(AssertionExample.java:10)
 

Where not to use Assertion:

There are some situations where assertion should be avoid to use. They are:
  1. According to Sun Specification, assertion should not be used to check arguments in the public methods because it should result in appropriate runtime exception e.g. IllegalArgumentException, NullPointerException etc.
  2. Do not use assertion, if you don't want any error in any situation.
వీరిచే పోస్ట్ చేయబడింది వద్ద 1 కామెంట్‌:

17, ఫిబ్రవరి 2015, మంగళవారం








వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

THIS IS THE PROGRAM WHICH WILL EXPLAIN ABOUT THE PROPERTIES CLASS IN JAVA.UTIL PACKAGE



import java.util.*;
public class Proper{
public static void main(String args[])
{
Properties p= System.getProperties();
p.list(System.out);
String course=System.getProperty("ramu");
System.out.println("NOW USER DEFINED PROPERTY IS STARTED");
if(course.equals("dayina@chirala"))
System.out.println(course);
else
System.out.println("UNKNOWN");
}
}


execution 
D:\Threads>java -Dramu=dayina@chirala Proper
-- listing properties --
PROPERTIENAME= VALUE
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=C:\Program Files\Java\jre1.8.0_31\bin
java.vm.version=25.31-b07
java.vm.vendor=Oracle Corporation
java.vendor.url=http://java.oracle.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
ramu=dayina@chirala
NOW USER DEFINED PROPERTY IS STARTED
dayina@chirala
వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

A SIMPLE EXAMPLE ABOUT GENERICS IN JAVA EXPLAINS ABOUT TYPE SAFETY, TYPE CASTING AND POLYMORPHISM



import java.util.*;
public class Generics{

public static void main(String args[])
{

//generic version of ArrayList
ArrayList<String> l=new ArrayList<String>();
List<String> l2=new ArrayList<String>();
l2.add("list reference");
Collection<String> l3=new ArrayList<String>();
l3.add("collection reference");


//ArrayList<int> l1=new ArrayList<int>();
//List<Object> l4=new ArrayList<String>();
l.add("ramu");
l.add("dayina");
l.add("10");  //CE Gene.java:11: cannot find symbol l.add(10);//CEsymbol:   method add(int)  location: class ArrayList<String>1 error

System.out.println(l);
System.out.println(l2);

System.out.println(l3);

 //Collection(I)list(I) are the parent interfaces so they can hold the child references 
List<Integer> l5=new ArrayList<Integer>();
l5.add(100);
List<Integer> l6=new LinkedList<Integer>();
l6.add(101);
List<Integer> l7=new Vector<Integer>();
l7.add(102);
List<Integer> l8=new Stack<Integer>();
l8.add(103);
System.out.println(l5);System.out.println(l6);System.out.println(l7);System.out.println(l8);

}}


D:\Threads>javac Generics.java
 D:\Threads>java Generics
[ramu, dayina, 10]
[list reference]
[collection reference]
[100]
[101]
[102]
[103]
వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

SIMPLE EXAMPLE ABOUT JAVA.LANG.OBJECT



class Student
{
int sno;
String sname;
Student(int sno,String sname)
{
this.sno=sno;
this.sname=sname;}

/*public String toString()
{ return "STUDENT ID IS  "+sno+"\n"+"SNAME IS "+sname; }*/
}
public class TestObject
{
public static void main(String ramu[])
{
Student s=new Student(100,"ramu@dayina");
System.out.println(s);
}}


Output:- before overriding toString() method jvm executing object class toString() by default
D:\Threads>java TestObject
Student@1db9742   ->   classname@hashcode

After defining by the user toString()
D:\Threads>java TestObject
STUDENT ID IS  100
SNAME IS ramu@dayina
వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:

16, ఫిబ్రవరి 2015, సోమవారం

JAVA GENERIC CLASS 1.40 MIN LECTURE


Generic Class
What Are Generics
The term generics means parameterized types. Using generics, it is possible to create a single class that works with different types of data. A class, interface, or method that operates on a parameterized type is called generic.
A Simple Generics Example

// T is a type parameter that will be replaced by a real type
// when an object of type Gen is created.
class Gen<T> {
  T ob; // declare an object of type T
  Gen(T o) {
    ob = o;
  }
  // Return ob.
  T getob() {
    return ob;
  }
  // Show type of T.
  void showType() {
    System.out.println("Type of T is " + ob.getClass().getName());
  }
}

public class Main {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    iOb.showType();
    int v = iOb.getob();
    System.out.println("value: " + v);
    Gen<String> strOb = new Gen<String>("Generics Test");
    strOb.showType();
    String str = strOb.getob();
    System.out.println("value: " + str);
  }
}
 
T is the name of a type parameter. T is used to declare an object. Generics work only with objects Generic types differ based on their type arguments
A Generic Class with Two Type Parameters
You can declare more than one type parameter in a generic type.

// A simple generic class with two type parameters: T and V.
class TwoGen<T, V> {
  T ob1;
  V ob2;
  TwoGen(T o1, V o2) {
    ob1 = o1;
    ob2 = o2;
  }
  void showTypes() {
    System.out.println("Type of T is " + ob1.getClass().getName());
    System.out.println("Type of V is " + ob2.getClass().getName());
  }

  T getob1() {
    return ob1;
  }

  V getob2() {
    return ob2;
  }
}

public class Main {
  public static void main(String args[]) {
    TwoGen<Integer, String> tgObj = new TwoGen<Integer, String>(88, "Generics");
    tgObj.showTypes();
    int v = tgObj.getob1();
    System.out.println("value: " + v);
    String str = tgObj.getob2();
    System.out.println("value: " + str);
  }
}
 
Here is the syntax for declaring a generic class:

class className<type-param-list> {}
 
Here is the syntax for declaring a reference to a generic class:

className<type-arg-list> varName = new className<type-arg-list>(cons-arg-list);
 
The following code declares and uses a Queue<E> generic type.

class Queue<E> {
  private E[] elements;
  private int head=0, tail=0;

  Queue(int size) {
    elements = (E[]) new Object[size];
  }

  void insert(E element) throws QueueFullException {
    if (isFull())
      throw new QueueFullException();
    elements[tail] = element;
    tail = (tail + 1) % elements.length;
  }

  E remove() throws QueueEmptyException {
    if (isEmpty()){
      throw new QueueEmptyException();
    }
    E element = elements[head];
    head = (head + 1) % elements.length;
    return element;
  }

  boolean isEmpty() {
    return head == tail;
  }

  boolean isFull() {
    return (tail + 1) % elements.length == head;
  }
}
class QueueEmptyException extends Exception {
}

class QueueFullException extends Exception {
}
public class Main{
  public static void main(String[] args) throws QueueFullException, QueueEmptyException {
    Queue<String> queue = new Queue<String>(6);
    System.out.println("Empty: " + queue.isEmpty());
    System.out.println("Full: " + queue.isFull());
    queue.insert("A");
    queue.insert("B");
    queue.insert("C");
    queue.insert("D");
    queue.insert("E");
    System.out.println("Empty: " + queue.isEmpty());
    System.out.println("Full: " + queue.isFull());
    System.out.println("Removing " + queue.remove());
    System.out.println("Empty: " + queue.isEmpty());
    System.out.println("Full: " + queue.isFull());
    System.out.println("Adding F");
    queue.insert("F");
    while (!queue.isEmpty()){
      System.out.println("Removing " + queue.remove());
    }
     
    System.out.println("Empty: " + queue.isEmpty());
    System.out.println("Full: " + queue.isFull());
  }
}
 
Output:

Empty: true
Full: false
Empty: false
Full: true
Removing A
Empty: false
Full: false
Adding F
Removing B
Removing C
Removing D
Removing E
Removing F
Empty: true
Full: false

Generic Bounded Types

When specifying a type parameter, you can create an upper bound from which all type arguments must be derived. This is accomplished through the use of an extends clause when specifying the type parameter:
 
<T extends superClassName>
 
This specifies that T can only be replaced by superClassName, or subclasses of superClassName. Thus, superclass defines an inclusive, upper limit.
 
class Calculator<T extends Number> {
  T[] nums;
  Calculator(T[] o) {
    nums = o;
  }
  double average() {
    double sum = 0.0;
    for (int i = 0; i < nums.length; i++){
      sum += nums[i].doubleValue();
    }
    return sum / nums.length;
  }
}
public class Main {
  public static void main(String args[]) {
    Integer inums[] = { 1, 2, 3, 4, 5 };
    Calculator<Integer> iob = new Calculator<Integer>(inums);
    double v = iob.average();
    System.out.println("iob average is " + v);
    Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    Calculator<Double> dob = new Calculator<Double>(dnums);
    double w = dob.average();
    System.out.println("dob average is " + w);
  }
}
 
In addition to using a class type as a bound, you can also use an interface type. You can specify multiple interfaces as bounds.
A bound can include both a class type and one or more interfaces. In this case, the class type must be specified first.
When a bound includes an interface type, only type arguments that implement that interface are legal.
When specifying a bound that has a class and an interface, or multiple interfaces, use the & operator to connect them.
For example,
 
class Gen<T extends MyClass & MyInterface> {}
 
Any type argument passed to T must be a subclass of MyClass and implement MyInterface.

Generic Wildcard Arguments

To create a generic method, you use the wildcard argument. The wildcard argument is specified by the ?, and it represents an unknown type.
 
class Calculator<T extends Number> {
  T[] nums;
  Calculator(T[] o) {
    nums = o;
  }
  double average() {
    double sum = 0.0;
    for (int i = 0; i < nums.length; i++){
      sum += nums[i].doubleValue();
    }
    return sum / nums.length;
  }
}
public class Main {
  boolean sameAvg(Calculator<?> ob) {
    if (1.2 == ob.average())
      return true;
    return false;
  }
 
  public static void main(String args[]) {
  }
}
 
Calculator<?> matches any Stats object, allowing any two Stats objects to have their averages compared.
The following program demonstrates this:
 
class Calculator<T extends Number> {
  T[] nums;
  Calculator(T[] o) {
    nums = o;
  }
  double average() {
    double sum = 0.0;
    for (int i = 0; i < nums.length; i++)
      sum += nums[i].doubleValue();
    return sum / nums.length;
  }
  boolean sameAvg(Calculator<?> ob) {
    if (average() == ob.average())
      return true;
    return false;
  }
}
public class Main {
  public static void main(String args[]) {
    Integer inums[] = { 1, 2, 3, 4, 5 };
    Calculator<Integer> iob = new Calculator<Integer>(inums);
 
    Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    Calculator<Double> dob = new Calculator<Double>(dnums);
 
    if (iob.sameAvg(dob))
      System.out.println("are the same.");
    else
      System.out.println("differ.");
  }
}
 

Generic Bounded Wildcards

Wildcard arguments can be bounded in the same way that a type parameter can be bounded. A bounded wildcard is important when creating a generic type that will operate on a class hierarchy.
A bounded wildcard specifies either an upper bound or a lower bound for the type argument.
 
class TwoD {
  int x, y;
  TwoD(int a, int b) {
    x = a;
    y = b;
  }
}
 
// Three-dimensional coordinates.
class ThreeD extends TwoD {
  int z;
 
  ThreeD(int a, int b, int c) {
    super(a, b);
    z = c;
  }
}
class Map<T extends TwoD> {
  T[] coords;
 
  Map(T[] o) {
    coords = o;
  }
}
 
public class Main {
  static void showXY(Map<?> c) {
    for (int i = 0; i < c.coords.length; i++){
      System.out.println(c.coords[i].x + " " + c.coords[i].y);
    }      
  }
  static void showXYZ(Map<? extends ThreeD> c) {
    for (int i = 0; i < c.coords.length; i++){
      System.out.println(c.coords[i].x + " " + c.coords[i].y + " "
          + c.coords[i].z);
    }
  }
  public static void main(String args[]) {
    TwoD td[] = { new TwoD(0, 0), new TwoD(-1, -2) };
    Map<TwoD> map = new Map<TwoD>(td);
    System.out.println("Contents of tdlocs.");
 
    showXY(map);
  }
}
 
In general, to establish an upper bound for a wildcard, use the following type of wildcard expression:
 
<? extends superclass>
 
superclass is the name of the class that serves as the upper bound. This is an inclusive clause.
You can specify a lower bound for a wildcard by adding a super clause to a wildcard declaration.
 
<? super subclass>
 
In this case, only classes that are superclasses of subclass are acceptable arguments. This is an exclusive clause, because it will not match the class specified by subclass.

Generic Method

It is possible to create a generic method that is enclosed within a non-generic class.
 
public class Main {
  static <T, V extends T> boolean isIn(T x, V[] y) {
    for (int i = 0; i < y.length; i++) {
      if (x.equals(y[i])) {
        return true;
      }
    }
    return false;
  }
 
  public static void main(String args[]) {
    Integer nums[] = { 1, 2, 3, 4, 5 };
    if (isIn(2, nums)){
      System.out.println("2 is in nums");
    }
    String strs[] = { "one", "two", "three", "four", "five" };
    if (isIn("two", strs)){
      System.out.println("two is in strs");
    }
  }
}
 
The following code declares a copyList() generic method.
 
import java.util.ArrayList;
import java.util.List;
 
public class Main {
  public static void main(String[] args) {
    List<String> ls = new ArrayList<String>();
    ls.add("A");
    ls.add("B");
    ls.add("C");
    List<String> lsCopy = new ArrayList<String>();
    copyList(ls, lsCopy);
    List<Integer> lc = new ArrayList<Integer>();
    lc.add(0);
    lc.add(5);
    List<Integer> lcCopy = new ArrayList<Integer>();
    copyList(lc, lcCopy);
  }
 
  static <T> void copyList(List<T> src, List<T> dest) {
    for (int i = 0; i < src.size(); i++)
      dest.add(src.get(i));
  }
 
}
 

Generic Constructors

It is possible for constructors to be generic, even if their class is not. For example, consider the following short program:
 
class MyClass {
  private double val;
 
  <T extends Number> MyClass(T arg) {
    val = arg.doubleValue();
  }
 
  void showval() {
    System.out.println("val: " + val);
  }
}
 
public class Main {
  public static void main(String args[]) {
    MyClass test = new MyClass(100);
    MyClass test2 = new MyClass(123.5F);
    test.showval();
    test2.showval();
  }
}
 

Generic Interfaces

Generic interfaces are specified like generic classes.
 
interface MinMax<T extends Comparable<T>> {
  T max();
}
class MyClass<T extends Comparable<T>> implements MinMax<T> {
  T[] vals;
  MyClass(T[] o) {
    vals = o;
  }
  public T max() {
    T v = vals[0];
    for (int i = 1; i < vals.length; i++) {
      if (vals[i].compareTo(v) > 0) {
        v = vals[i];
      }
    }
    return v;
  }
}
 
public class Main {
  public static void main(String args[]) {
    Integer inums[] = { 3, 6, 2, 8, 6 };
    Character chs[] = { 'b', 'r', 'p', 'w' };
    MyClass<Integer> a = new MyClass<Integer>(inums);
    MyClass<Character> b = new MyClass<Character>(chs);
    System.out.println(a.max());
    System.out.println(b.max());
  }
}
 
In general, if a class implements a generic interface, then that class must also be generic.
If a class implements a specific type of generic interface, such as shown here:
 
class MyClass implements MinMax<Integer> { // OK
 
then the implementing class does not need to be generic.
Here is the generalized syntax for a generic interface:
 
interface interface-name<type-param-list> { // ...
 
type-param-list is a comma-separated list of type parameters. When a generic interface is implemented, you must specify the type arguments, as shown here:
 
class class-name<type-param-list> 
   implements interface-name<type-arg-list> {
 

Raw Types and Legacy Code

To handle the transition to generics, Java allows a generic class to be used without any type arguments.
Here is an example that shows a raw type in action:
 
class MyClass<T> {
  T ob;
  MyClass(T o) {
    ob = o;
  }
  T getob() {
    return ob;
  }
}
public class Main {
  public static void main(String args[]) {
    MyClass raw = new MyClass(new Double(98.6));
    double d = (Double) raw.getob();
    System.out.println("value: " + d);
  }
}
 

Generic Class Hierarchies

A generic class can act as a superclass or be a subclass. In a generic hierarchy, any type arguments needed by a generic superclass must be passed up the hierarchy by all subclasses.
Using a Generic Superclass
 
class MyClass<T> {
  T ob;
  MyClass(T o) {
    ob = o;
  }
  T getob() {
    return ob;
  }
}
class MySubclass<T, V> extends MyClass<T> {
  V ob2;
 
  MySubclass(T o, V o2) {
    super(o);
    ob2 = o2;
  }
 
  V getob2() {
    return ob2;
  }
}
public class Main {
  public static void main(String args[]) {
    MySubclass<String, Integer> x = new MySubclass<String, Integer>("Value is: ", 99);
    System.out.print(x.getob());
    System.out.println(x.getob2());
  }
}
 
A Generic Subclass
It is perfectly acceptable for a non-generic class to be the superclass of a generic subclass.
 
class MyClass {
  int num;
 
  MyClass(int i) {
    num = i;
  }
 
  int getnum() {
    return num;
  }
}
class MySubclass<T> extends MyClass {
  T ob;
  MySubclass(T o, int i) {
    super(i);
    ob = o;
  }
  T getob() {
    return ob;
  }
}
public class Main {
  public static void main(String args[]) {
     MySubclass<String> w = new MySubclass<String>("Hello", 4);
    System.out.print(w.getob() + " ");
    System.out.println(w.getnum());
  }
}
 

Run-Time Type Comparisons Within a Generic Hierarchy

The instanceof operator can be applied to objects of generic classes.
 
class Gen<T> {
  T ob;
 
  Gen(T o) {
    ob = o;
  }
  T getob() {
    return ob;
  }
}
class Gen2<T> extends Gen<T> {
  Gen2(T o) {
    super(o);
  }
}
 
public class Main {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    Gen2<Integer> iOb2 = new Gen2<Integer>(99);
    Gen2<String> strOb2 = new Gen2<String>("Generics Test");
    System.out.println("iOb2 is instance of Gen2"+(iOb2 instanceof Gen2<?>));
    System.out.println("iOb2 is instance of Gen"+(iOb2 instanceof Gen<?>));
    System.out.println("strOb2 is instance of Gen2"+(strOb2 instanceof Gen2<?>));
    System.out.println("strOb2 is instance of Gen"+(strOb2 instanceof Gen<?>));
    System.out.println("iOb is instance of Gen2"+(iOb instanceof Gen2<?>));
    System.out.println("iOb is instance of Gen"+(iOb instanceof Gen<?>));
  }
}
 

Casting

You can cast one instance of a generic class into another only if the two are compatible and their type arguments are the same.
For example, assuming the foregoing program, this cast is legal:
 
class Gen<T> {
  T ob;
 
  Gen(T o) {
    ob = o;
  }
  T getob() {
    return ob;
  }
}
class Gen2<T> extends Gen<T> {
  Gen2(T o) {
    super(o);
  }
}
 
public class Main {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    Gen2<Integer> iOb2 = new Gen2<Integer>(99);
    Gen2<String> strOb2 = new Gen2<String>("Generics Test");
    iOb = (Gen<Integer>) iOb2;
  }
}
 
because iOb2 is an instance of Gen<Integer>. But, this cast:
 
class Gen<T> {
  T ob;
 
  Gen(T o) {
    ob = o;
  }
  T getob() {
    return ob;
  }
}
class Gen2<T> extends Gen<T> {
  Gen2(T o) {
    super(o);
  }
}
 
public class Main {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    Gen2<Integer> iOb2 = new Gen2<Integer>(99);
    Gen2<String> strOb2 = new Gen2<String>("Generics Test");
    //iOb = (Gen<Long>) iOb2;//wrong
  }
}
 
is not legal because iOb2 is not an instance of Gen<Long>.

Overriding Methods in a Generic Class

A method in a generic class can be overridden like any other method.
 
class Gen<T> {
  T obj;
  Gen(T o) {
    obj = o;
  }
  T getob() {
    System.out.print("Gen's getob(): ");
    return obj;
  }
}
class Gen2<T> extends Gen<T> {
  Gen2(T o) {
    super(o);
  }
  T getob() {
    System.out.print("Gen2's getob(): ");
    return obj;
  }
}
public class Main {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    Gen2<String> strOb2 = new Gen2<String>("Generics Test");
    System.out.println(iOb.getob());
    System.out.println(strOb2.getob());
  }
}
 

Generic Restrictions

Type Parameters Can't Be Instantiated

It is not possible to create an instance of a type parameter. For example, consider this class:
 
// Can't create an instance of T. 
class Gen<T> {
  T ob;
 
  Gen() {
    ob = new T(); // Illegal!!!
  }
}
 

Restrictions on Static Members

No static member can use a type parameter declared by the enclosing class. For example, all of the static members of this class are illegal:
 
class Wrong<T> {
  // Wrong, no static variables of type T.
  static T ob;
 
  // Wrong, no static method can use T.
  static T getob() {
    return ob;
  }
 
  // Wrong, no static method can access object of type T.
  static void showob() {
    System.out.println(ob);
  }
}
  You can declare static generic methods with their own type parameters.

Generic Array Restrictions

You cannot instantiate an array whose base type is a type parameter. You cannot create an array of type specific generic references.
The following short program shows both situations:
 
class MyClass<T extends Number> {
  T ob;
  T vals[];
 
  MyClass(T o, T[] nums) {
    ob = o;
    vals = nums;
  }
}
public class Main {
  public static void main(String args[]) {
    Integer n[] = { 1 };
    MyClass<Integer> iOb = new MyClass<Integer>(50, n);
    // Can't create an array of type-specific generic references.
    // Gen<Integer> gens[] = new Gen<Integer>[10]; 
    MyClass<?> gens[] = new MyClass<?>[10]; // OK
  }
}
 


వీరిచే పోస్ట్ చేయబడింది వద్ద కామెంట్‌లు లేవు:
దీనికి సబ్‌స్క్రయిబ్ చేయి: పోస్ట్‌లు (Atom)