software - java verify




जावा की छिपी हुई विशेषताएं (20)

Enums में विधियों और रचनाकारों की अनुमति मुझे आश्चर्यचकित कर दिया। उदाहरण के लिए:

enum Cats {
  FELIX(2), SHEEBA(3), RUFUS(7);

  private int mAge;
  Cats(int age) {
    mAge = age;
  }
  public int getAge() {
    return mAge;
   }
}

आपके पास "निरंतर विशिष्ट वर्ग निकाय" भी हो सकता है जो विशिष्ट एनम मान को विधियों को ओवरराइड करने की अनुमति देता है।

here अधिक दस्तावेज।

सी # की छिपी हुई विशेषताओं को पढ़ने के बाद मुझे आश्चर्य हुआ, जावा की कुछ छिपी हुई विशेषताएं क्या हैं?


अंत में ब्लॉक में नियंत्रण का स्थानांतरण किसी भी अपवाद को फेंक देता है। निम्न कोड RuntimeException फेंक नहीं देता है - यह खो गया है।

public static void doSomething() {
    try {
      //Normally you would have code that doesn't explicitly appear 
      //to throw exceptions so it would be harder to see the problem.
      throw new RuntimeException();
    } finally {
      return;
    }
  }

http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html


आप एक अज्ञात सबक्लास को परिभाषित कर सकते हैं और सीधे उस पर एक विधि को कॉल कर सकते हैं भले ही यह कोई इंटरफेस लागू न करे।

new Object() {
  void foo(String s) {
    System.out.println(s);
  }
}.foo("Hello");

आप एक इंटरफ़ेस को लागू करने के लिए enums का उपयोग कर सकते हैं।

public interface Room {
   public Room north();
   public Room south();
   public Room east();
   public Room west();
}

public enum Rooms implements Room {
   FIRST {
      public Room north() {
         return SECOND;
      }
   },
   SECOND {
      public Room south() {
         return FIRST;
      }
   }

   public Room north() { return null; }
   public Room south() { return null; }
   public Room east() { return null; }
   public Room west() { return null; }
}

संपादित करें: साल बाद ....

मैं इस सुविधा का उपयोग यहां करता हूं

public enum AffinityStrategies implements AffinityStrategy {

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

एक इंटरफेस का उपयोग करके, डेवलपर्स अपनी रणनीतियों को परिभाषित कर सकते हैं। एक enum का उपयोग करना मतलब है कि मैं एक संग्रह (पांच में से) को परिभाषित कर सकते हैं।


एक आंतरिक वर्ग से कक्षा रखने के फ़ील्ड / विधियों तक पहुंचने के लिए इस कीवर्ड का उपयोग करना। नीचे, बल्कि प्रदूषित उदाहरण, हम गुमनाम आंतरिक कक्षा से कंटेनर वर्ग के क्रमबद्ध क्षेत्र का उपयोग करना चाहते हैं। इस.sortAscending की बजाय ContainerClass.this.sortAscending का उपयोग करना चाल करता है।

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}

किसी ने इस तरह से लागू होने के उदाहरण का उल्लेख नहीं किया है कि शून्य की जांच आवश्यक नहीं है।

के बजाय:

if( null != aObject && aObject instanceof String )
{
    ...
}

महज प्रयोग करें:

if( aObject instanceof String )
{
    ...
}

जावा 1.5 के रूप में, जावा अब परिवर्तनीय धैर्य के कार्यों को लिखने के लिए एक बहुत साफ सिंटैक्स है। तो, सिर्फ एक सरणी पास करने के बजाय, अब आप निम्न कार्य कर सकते हैं

public void foo(String... bars) {
   for (String bar: bars)
      System.out.println(bar);
}

सलाखों को स्वचालित रूप से निर्दिष्ट प्रकार की सरणी में परिवर्तित कर दिया जाता है। एक बड़ी जीत नहीं, लेकिन फिर भी एक जीत।


जावा 6 के बाद से क्लासपाथ जंगली कार्ड।

java -classpath ./lib/* so.Main

के बजाय

java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main

http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html देखें


जेडीके 1.6_07 + में VisualVM (bin / jvisualvm.exe) नामक एक ऐप शामिल है जो कई टूल के शीर्ष पर एक अच्छा जीयूआई है। यह जेकोनसोल से अधिक व्यापक लगता है।


जेनेरिक तरीकों के लिए प्रकार पैराम को स्पष्ट रूप से निर्दिष्ट किया जा सकता है:

Collections.<String,Integer>emptyMap()

मुझे लगता है कि जावा की एक और "अनदेखी" विशेषता जेवीएम है। यह शायद सबसे अच्छा वीएम उपलब्ध है। और यह बहुत सारी रोचक और उपयोगी भाषाओं का समर्थन करता है (ज्योथन, जेआरबी, स्कैला, ग्रोवी)। वे सभी भाषाएं आसानी से और निर्बाध रूप से सहयोग कर सकती हैं।

यदि आप एक नई भाषा तैयार करते हैं (जैसे स्कैला-केस में) तो आपके पास तुरंत मौजूद सभी मौजूदा पुस्तकालय उपलब्ध हैं और इसलिए आपकी भाषा बहुत शुरुआत से "उपयोगी" है।

उन सभी भाषाओं में हॉटस्पॉट अनुकूलन का उपयोग किया जाता है। वीएम बहुत अच्छी तरह से निगरानी और डिबगबल है।


मेरा पसंदीदा: मानक थ्रेड के लिए सभी थ्रेड स्टैक निशान डंप करें।

विंडोज़: CTRL - अपने जावा cmd / कंसोल विंडो में तोड़ें

यूनिक्स: kill -3 PID


यह बिल्कुल "छिपी हुई विशेषताएं" नहीं है और बहुत उपयोगी नहीं है, लेकिन कुछ मामलों में बेहद दिलचस्प हो सकता है:
क्लास sun.misc.Unsafe - आपको जावा में प्रत्यक्ष मेमोरी प्रबंधन को लागू करने की अनुमति देगा (यदि आप बहुत कोशिश करते हैं तो आप इसके साथ जावा कोड को स्वयं संशोधित भी लिख सकते हैं):

public class UnsafeUtil {

    public static Unsafe unsafe;
    private static long fieldOffset;
    private static UnsafeUtil instance = new UnsafeUtil();

    private Object obj;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);

            unsafe = (Unsafe)f.get(null);
            fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

वास्तव में एक सुविधा नहीं है, लेकिन कुछ मनोरंजक चाल मैंने हाल ही में कुछ वेब पेज में खोजा है:

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

एक वैध जावा प्रोग्राम है (हालांकि यह एक चेतावनी उत्पन्न करता है)। यदि आप नहीं देखते हैं, तो ग्रेगरी का जवाब देखें! ;-) ठीक है, यहां पर प्रकाश डाला गया वाक्यविन्यास भी एक संकेत देता है!


गतिशील प्रॉक्सी (1.3 में जोड़ा गया) आपको एक इंटरफ़ेस के अनुरूप रनटाइम पर एक नया प्रकार परिभाषित करने की अनुमति देता है। यह एक आश्चर्यजनक संख्या में काम में आ गया है।


asList में asList विधि varargs, जेनेरिक तरीकों और autoboxing का एक अच्छा संयोजन की अनुमति देता है:

List<Integer> ints = Arrays.asList(1,2,3);

अंतिम प्रारंभिक स्थगित किया जा सकता है।

यह सुनिश्चित करता है कि तर्क वापसी मूल्यों के जटिल प्रवाह के साथ भी हमेशा सेट किया जाता है। एक मामले को याद करना और दुर्घटना से शून्य वापस करना बहुत आसान है। यह वापस शून्य असंभव नहीं बनाता है, बस स्पष्ट है कि यह उद्देश्य पर है:

public Object getElementAt(int index) {
    final Object element;
    if (index == 0) {
         element = "Result 1";
    } else if (index == 1) {
         element = "Result 2";
    } else {
         element = "Result 3";
    }
    return element;
}

Language-level assert keyword.


The addition of the for-each loop construct in 1.5. I <3 it.

// For each Object, instantiated as foo, in myCollection
for(Object foo: myCollection) {
  System.out.println(foo.toString());
}

And can be used in nested instances:

for (Suit suit : suits)
  for (Rank rank : ranks)
    sortedDeck.add(new Card(suit, rank));

The for-each construct is also applicable to arrays, where it hides the index variable rather than the iterator. The following method returns the sum of the values in an int array:

// Returns the sum of the elements of a
int sum(int[] a) {
  int result = 0;
  for (int i : a)
    result += i;
  return result;
}

Link to the Sun documentation


प्रकार पैरामीटर भिन्नता में संयुक्त संघ:

public class Baz<T extends Foo & Bar> {}

उदाहरण के लिए, यदि आप पैरामीटर लेना चाहते हैं जो तुलनात्मक और संग्रह दोनों है:

public static <A, B extends Collection<A> & Comparable<B>>
boolean foo(B b1, B b2, A a) {
   return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a);
}

यह प्रदत्त विधि सत्य लौटाती है यदि दो दिए गए संग्रह बराबर हैं या उनमें से किसी एक को दिया गया तत्व है, अन्यथा झूठी। ध्यान देने योग्य बिंदु यह है कि आप बी 1 और बी 2 के तर्कों पर तुलनात्मक और संग्रह दोनों के तरीकों का आह्वान कर सकते हैं।





java