9 Things Close Zippo Inward Java - Hallo sahabat BEST LEARNING JAVA, Pada Artikel yang anda baca kali ini dengan judul 9 Things Close Zippo Inward Java, kami telah mempersiapkan artikel ini dengan baik untuk anda baca dan ambil informasi didalamnya. mudah-mudahan isi postingan Artikel core java, Artikel java tips, Artikel programming, yang kami tulis ini dapat anda pahami. baiklah, selamat membaca.

Judul : 9 Things Close Zippo Inward Java
link : 9 Things Close Zippo Inward Java

9 Things Close Zippo Inward Java

Java too nil are uniquely bonded. There is hardly a Java programmer, who is non troubled past times nil pointer exception, it is the most infamous fact about. Even inventor of nil concept has called it his billion dollar mistake, too then why Java kept it? Null was at that spot from long fourth dimension too I believe Java designer knows that nil creates to a greater extent than occupation than it solves, but all the same they went amongst it. It surprise me fifty-fifty to a greater extent than because Java's pattern philosophy was to simplify things, that's why they didn't bothered amongst pointers, operator overloading too multiple inheritance of implementation, they why null. Well I actually don't know the response of that question, what I know is that, doesn't thing how much nil is criticized past times Java developers too opened upward source community, nosotros receive got to alive amongst that. Instead of ruing nigh nil it's amend to larn to a greater extent than nigh it too brand certain nosotros purpose it correct. Why yous should larn nigh nil inwards Java? because If yous don't pay attending to null, Java volition brand certain that yous volition endure from dreaded java.lang.NullPointerException too yous volition larn your lesson difficult way. Robust programming is an fine art too your team, client too user volition appreciate that. In my experience, ane of the main reasons of NullPointerException are non plenty noesis nigh nil inwards Java. Many of yous already familiar amongst nil but for those, who are not, tin rank the sack larn some quondam too novel things nigh nil keyword. Let's revisit or larn some of import things nigh nil inwards Java.

What is Null inwards Java

As I said, nil is really very of import concept inwards Java. It was originally invented to announce absence of something e.g. absence of user, a resources or anything, but over the yr it has troubled Java programmer a lot amongst nasty nil pointer exception. In this tutorial, nosotros volition larn basic facts nigh nil keyword inwards Java too explore some techniques to minimize nil checks too how to avoid nasty nil pointer exceptions.

1) First thing, first,  null is a keyword inwards Java, much similar public, static or final. It's illustration sensitive, yous cannot write null as Null or NULL, compiler volition non recognize them too rank error.

Object obj = NULL; // Not Ok Object obj1 = null  //Ok
 

Programmer's which are coming from other linguistic communication receive got this problem, but purpose of modern twenty-four hr menses IDE's has made it insignificant. Now days, IDE similar Eclipse or Netbeans tin rank the sack right this mistake, field yous type code, but inwards the era of notepad, Vim too Emacs, this was a mutual final result which could easily swallow your precious time.


2) Just similar every primitive has default value e.g. int has 0, boolean has false, null is the default value of whatever reference type, loosely spoken to all object every bit well. Just similar if yous create a boolean variable, it got default value every bit false, whatever reference variable inwards Java has default value null. This is truthful for all sort of variables e.g. member variable or local variable, instance variable or static variable, except that compiler volition warn yous if yous purpose a local variable without initializing them. In social club to verify this fact, yous tin rank the sack run across value of reference variable past times creating a variable too them printing it's value, every bit shown inwards next code snippet :

private static Object myObj; public static void main(String args[]){     System.out.println("What is value of myObjc : " + myObj); }   What is value of myObjc : null

This is truthful for both static too non-static object, every bit yous tin rank the sack run across hither that I made myObj a static reference thence that I tin rank the sack purpose it straight within principal method, which is static method too doesn't allow non-static variable inside.


3) Unlike mutual misconception, null is non Object or neither a type. It's simply a particular value, which tin rank the sack survive assigned to whatever reference type too you tin rank the sack type shape nil to whatever type, every bit shown below :

String str = null; // nil tin rank the sack survive assigned to String Integer itr = null; // yous tin rank the sack assign nil to Integer also Double dbl = null;  // nil tin rank the sack too survive assigned to Double          String myStr = (String) null; // nil tin rank the sack survive type shape to String Integer myItr = (Integer) null; // it tin rank the sack too survive type casted to Integer Double myDbl = (Double) null; // aye it's possible, no error

You tin rank the sack run across type casting nil to whatever reference type is fine at both compile fourth dimension too runtime, dissimilar many of yous mightiness receive got thought, it volition too non throw NullPointerException at runtime.


4) nil tin rank the sack only survive assigned to reference type, yous cannot assign nil to primitive variables e.g. int, double, float or boolean. Compiler volition complain if yous practice so, every bit shown below.

int i = null; // type mismatch : cannot convert from nil to int short sec = null; //  type mismatch : cannot convert from nil to short byte b = null: // type mismatch : cannot convert from nil to byte double d = null; //type mismatch : cannot convert from nil to double          Integer itr = null; // this is ok int j = itr; // this is too ok, but NullPointerException at runtime

As yous tin rank the sack see, when yous straight assign nil to primitive error it's compile fourth dimension error, but if yous assign nil to a wrapper class object too and then assign that object to respective primitive type, compiler doesn't complain, but yous would survive greeted past times nil pointer exception at runtime. This happens because of autoboxing inwards Java, too nosotros volition run across it inwards side past times side point.


5) Any wrapper class amongst value nil volition throw java.lang.NullPointerException when Java unbox them into primitive values. Some programmer makes incorrect supposition that, auto boxing volition convey attention of converting null into default values for respective primitive type e.g. 0 for int, simulated for boolean etc, but that's non true, every bit seen below.

Integer iAmNull = null; int i = iAmNull; // Remember - No Compilation Error

but when yous run higher upward code snippet yous volition run across Exception inwards thread "main" java.lang.NullPointerException  in your console. This happens a lot field working amongst HashMap too Integer key values. Code similar shown below volition intermission every bit shortly every bit yous run.

import java.util.HashMap; import java.util.Map;   /**  * An illustration of Autoboxing too NullPointerExcpetion  *   * @author WINDOWS 8  */  public class Test {      public static void main(String args[]) throws InterruptedException {                Map numberAndCount = new HashMap<>();        int[] numbers = {3, 5, 7,9, 11, 13, 17, 19, 2, 3, 5, 33, 12, 5};              for(int i : numbers){          int count = numberAndCount.get(i);          numberAndCount.put(i, count++); // NullPointerException here       }            }  }  Output: Exception inwards thread "main" java.lang.NullPointerException  at Test.main(Test.java:25)

This code looks really elementary too innocuous. All yous are doing is finding how many times a lay out has appeared inwards a array, classic technique to observe duplicates inwards Java array. Developer is getting the previous count, increasing it past times ane too putting it dorsum into Map. He mightiness receive got idea that auto-boxing volition convey attention of converting Integer to int , every bit it doing field calling lay method, but he forget that when at that spot is no count be for a number, get() method of HashMap volition supply null, non null because default value of Integer is nil non 0, too auto boxing volition throw nil pointer exception field trying to convert it into an int variable. Imagine if this code is within an if loop too doesn't run inwards QA surroundings but every bit shortly every bit yous lay into production, BOOM :-)


6)instanceof operator volition supply simulated if used against whatever reference variable amongst null value or null literal itself, e.g.

Integer iAmNull = null; if(iAmNull instanceof Integer){    System.out.println("iAmNull is instance of Integer");                               }else{    System.out.println("iAmNull is NOT an instance of Integer"); }  Output : iAmNull is NOT an instance of Integer

This is an of import belongings of instanceof operation which makes it useful for type casting checks.


7) You may know that yous cannot telephone yell upward a non-static method on a reference variable amongst null value, it volition throw NullPointerException, but yous mightiness non know that, yous can call static method amongst reference variables amongst null values. Since static methods are bonded using static binding, they won't throw NPE. Here is an illustration :            

public class Testing {                 public static void main(String args[]){       Testing myObject = null;       myObject.iAmStaticMethod();       myObject.iAmNonStaticMethod();                                 }                   private static void iAmStaticMethod(){         System.out.println("I am static method, tin rank the sack survive called past times nil reference");    }                   private void iAmNonStaticMethod(){  System.out.println("I am NON static method, don't engagement to telephone yell upward me past times null");    }   }  Output: I am static method, tin rank the sack survive called past times null reference Exception inwards thread "main" java.lang.NullPointerException                at Testing.main(Testing.java:11)

8) You tin rank the sack locomote past times null to methods, which accepts whatever reference type e.g. public void print(Object obj) can survive called every bit print(null). This is Ok from compiler's indicate of view, but behaviour is alone depends upon method. Null rubber method, doesn't throw NullPointerException inwards such case, they simply locomote out gracefully. It is recommended to write nil rubber method if concern logic allows.

9) You tin rank the sack compare nil value using ==  (equal to ) operator too !=  (not equal to) operator, but cannot purpose it amongst other arithmetics or logical operator e.g. less than or greater than. Unlike inwards SQL, inwards Java null == null volition supply true, every bit shown below :

public class Test {      public static void main(String args[]) throws InterruptedException {                 String abc = null;        String cde = null;                if(abc == cde){            System.out.println("null == nil is truthful inwards Java");        }                if(null != null){            System.out.println("null != nil is simulated inwards Java");         }                // classical nil check        if(abc == null){            // practice something        }                // non ok, compile fourth dimension error        if(abc > null){                    }     } }  Output: null == null is true inwards Java

That's all nigh nil inwards Java. By some sense inwards Java coding too past times using simple tricks to avoid NullPointerExcpetion, yous tin rank the sack brand your code nil safe. Since nil tin rank the sack survive treated every bit empty or uninitialized value it's oftentimes source of confusion, that's why it's to a greater extent than of import to document behaviour of a method for nil input. Always remember, nil is default value of whatever reference variable too yous cannot telephone yell upward whatever instance method, or access an instance variable using nil reference inwards Java.


Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Demikianlah Artikel 9 Things Close Zippo Inward Java

Sekianlah artikel 9 Things Close Zippo Inward Java kali ini, mudah-mudahan bisa memberi manfaat untuk anda semua. baiklah, sampai jumpa di postingan artikel lainnya.

Anda sekarang membaca artikel 9 Things Close Zippo Inward Java dengan alamat link https://bestlearningjava.blogspot.com/2019/09/9-things-close-zippo-inward-java.html

Bagikan Artikel ini