9 na bagay tungkol sa NULL sa Java

Magkasabay ang Java at null . Halos walang Java programmer na hindi nakatagpo ng " null pointer exception " at iyon ay isang malungkot na katotohanan. Kahit na ang imbentor ng "null" na konsepto ay tinawag itong kanyang bilyong dolyar na pagkakamali, kung gayon bakit sinusuportahan ito ng Java? Ang null ay matagal nang naririto, at sa palagay ko alam ng mga tagalikha ng Java na lumilikha ito ng mas maraming problema kaysa sa nalulutas nito, kaya bakit nila ito pinagtitiyagaan. At ito ay mas ikinagulat ko dahil ang pilosopiya ng Java ay ang pasimplehin ang mga bagay-bagay, kaya naman hindi na sila nagkakamali sa mga pointer, overloading ng operator at maramihang mana, ngunit bakit null? 9 na bagay tungkol sa NULL sa Java - 1

Buweno, hindi ko talaga alam ang sagot sa tanong na iyon, ngunit ang alam ko ay gaano man karaming null ang pinupuna ng mga programmer ng Java at ng open-source na komunidad, kailangan nating mamuhay dito. Sa halip na pagsisihan ito, mas mabuting matuto pa at siguraduhing tama ang paggamit namin ng null.

Bakit dapat mong malaman ang tungkol sa null sa Java?

Dahil kung hindi mo papansinin ang null, makatitiyak ka na ang Java ay magpapahirap sa iyo nang kakila-kilabot java.lang.NullPointerExceptionat matututo ka ng iyong aralin, ngunit mas mahirap na landas ang tatahakin mo. Ang pagsulat ng crash-resistant na code ay isang sining at pahahalagahan ito ng iyong team, mga customer at user. Sa aking karanasan, ang isa sa mga pangunahing dahilan NullPointerExceptionay ang kakulangan ng kaalaman tungkol sa null sa Java. Marami sa inyo ay pamilyar na sa null, ang iba sa inyo ay matututo ng ilang luma at bagong bagay tungkol sa null na keyword. Suriin o alamin natin ang ilang mahahalagang bagay tungkol sa null sa Java.

Ano ang null sa Java

Tulad ng sinabi ko, ang null ay isang napaka, napakahalagang konsepto sa Java. Ito ay orihinal na naimbento upang ipahiwatig ang kawalan ng isang bagay, tulad ng kawalan ng isang gumagamit, isang mapagkukunan, o anupaman, ngunit naging palaisipan ang mga programmer ng Java na may maraming null pointer exception. Sa tutorial na ito, matututunan natin ang mga pangunahing katotohanan tungkol sa null na keyword sa Java, at matutunan ang ilang mga trick upang maiwasan ang problema null pointer exceptionsat mabawasan ang mga null check.

Una sa lahat, ang null ay isang keyword sa Java, tulad ng public, statico final. Ang kaso ay sensitibo, hindi ka maaaring sumulat ng null bilang Null o NULL, hindi ito makikilala ng compiler at isang error ang itatapon.
```
Object obj = NULL; // Not Ok
Object obj1 = null //Ok
```
Madalas itong nakatagpo ng mga programmer na lumipat mula sa iba pang mga programming language, ngunit kapag gumagamit ng mga modernong IDE, ang problema ay nagiging hindi gaanong mahalaga. Sa mga araw na ito, maaaring ayusin ng mga IDE tulad ng Eclipse o NetBeans ang error na ito habang nagta-type ka, ngunit sa panahon ng Notepad, Vim at Emacs, ito ay isang pangkaraniwang problema na maaaring kumain ng maraming mahalagang oras.
Так же, How каждый примитив имеет meaning по умолчанию, например, у int это 0, у boolean это false, null это meaning по умолчанию любых ссылочных типов, проще говоря, для всех an objectов. Так же, How при создании логической переменной ее meaning по умолчанию равно false, так и любые ссылочные переменные в Java по умолчанию будут равны null. Это истинно для всех типов переменных: переменной-члена or локальной переменной, переменной экземпляра or статической переменной, кроме того, компилятор будет ругаться, если Вы используете локальную переменную не проинициализировав ее.
```
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
```
Это истинно How для статических, так и для не статических an objectов, How Вы можете видеть здесь, я сделал myObj статической ссылкой, так что я могу использовать ее непосредственно в методе main, который является статическим методом и не позволяет обращаться к не статическим переменным изнутри.
Несмотря на распространенное заблуждение, null это не an object (Object) и ни тип. Это просто специальное meaning, которое может быть назначено любому ссылочному типу, и Вы можете привести null к любому типу, How показано ниже:
```
String str = null; // null can be assigned to String
Integer itr = null; // you can assign null to Integer also
Double dbl = null; // null can also be assigned to Double
String myStr = (String) null; // null can be type cast to String
Integer myItr = (Integer) null; // it can also be type casted to Integer
Double myDbl = (Double) null; // yes it's possible, no error
```
Как Вы можете видеть, приведение null к любому ссылочному типу пройдет успешно How во время компиляции, так и во время выполнения программы. В отличии от того, что многие из Вас возможно подумали, это не приведет к выбрасыванию NullPointerException.
null может быть назначен только ссылочному типу, Вы не можете назначить null примитивной переменной вроде int, double, float or boolean. Компилятор выразит Вам свое недовольство если Вы сделаете How показано ниже:
```
int i = null; // type mismatch : cannot convert from null to int
short s = null; // type mismatch : cannot convert from null to short
byte b = null: // type mismatch : cannot convert from null to byte
double d = null; //type mismatch : cannot convert from null to double

Integer itr = null; // this is ok
int j = itr; // this is also ok, but NullPointerException at runtime
```
Как Вы можете видеть, когда мы непосредственно присваиваем null примитиву, то получаем ошибку процесса компиляции, но, если присвоить null an objectу класса-обертки, а затем присвоить этот an object соответствующему примитивному типу, компилятор не отреагирует, но мы будем вознаграждены null pointer exception во время выполнения. Это происходит из-за авто упаковки (autoboxing) в Java, и мы еще встретимся с ним в следующем пункте.
Любой класс-обертка со meaningм null будет выбрасывать java.lang.NullPointerException когда Java распакует(unbox) его в примитивную переменную. Некоторые программисты делают ошибку допуская, что авто упаковка(autoboxing) позаботится о конвертации null в meaning по умолчанию для соответствующего примитивного типа, например, 0 для int, false для boolean и т.д., но это не верно, в чем можно убедиться ниже:
```
Integer iAmNull = null;
int i = iAmNull; // Remember - No Compilation Error
```
Но, когда Вы запустите данный фрагмент codeа, в консоли Вы увидите
```
Exception in thread "main" java.lang.NullPointerException
```
Это часто происходит при работе с HashMap и Integer key. Выполнение codeа, показанного ниже прервется, How только Вы его запустите.
```
import java.util.HashMap;
import java.util.Map;
/**
* An example of Autoboxing and 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 in thread "main" java.lang.NullPointerException at Test.main(Test.java:25)
```
Ang code na ito ay mukhang napakasimple at hindi nakakapinsala. Bilangin mo lang kung gaano karaming beses lumilitaw ang isang numero sa isang array, isang klasikong pamamaraan para sa paghahanap ng mga duplicate. Kinukuha ng developer ang nakaraang binilang na dami, dinadagdagan ito ng isa at ilalagay muli sa Map. Maaaring isipin niya na ang auto-boxing ang bahala sa conversion Integersa int, tulad ng ginagawa nito kapag tinawag ang pamamaraan put(), ngunit nakalimutan niya na kung hindi pa binibilang ang numero, get()babalik ang paraan na HashMapnull, hindi zero, dahil ang default na halaga ay Integer ito ay null, hindi 0, at ang auto-boxing ay magtapon null pointer exceptionkapag sinusubukang i-convert ang isang Integer sa isang variable int.
instanceofMagbabalik ng false ang operator kung ang anumang reference na variable na may value na null o null mismo ay tinukoy bilang isang parameter. Halimbawa:
```
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
```
Ito ay isang mahalagang pag-aari ng operator instanceofna ginagawang kapaki-pakinabang para sa mga uri ng pagsubok sa mga cast.

Alam mo na hindi ka makakatawag ng isang non-static na pamamaraan sa isang null reference variable, tatawag ito NullPointerException, ngunit maaaring hindi mo alam na maaari kang tumawag ng isang static na paraan sa isang null reference variable. kasi Ang mga static na pamamaraan ay gumagamit ng static na pagbubuklod, hindi nila itinatapon NullPointerException. Narito ang isang halimbawa:

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, can be called by null reference");
    }
    private void iAmNonStaticMethod(){
        System.out.println("I am NON static method, don't date to call me by null");
    }
}

Output: I am static method, can be called by null reference
Exception in thread "main" java.lang.NullPointerException
at Testing.main(Testing.java:11)

Maaari mong ipasa ang null bilang isang parameter sa isang paraan na tumatanggap ng anumang uri ng sanggunian, halimbawa:
```
public void print(Object obj)
```
matatawag na parang
```
print(null)
```
Ito ay normal mula sa punto ng view ng compiler, ngunit ang kasunod na pag-uugali ay ganap na nakasalalay sa pamamaraan. Ang isang null-safe na paraan ay hindi magtapon NullPointerException, ngunit lalabas lamang nang maganda. Kung pinapayagan ang lohika ng negosyo, inirerekumenda na magsulat ng mga null-safe na pamamaraan.

Maaari mong ihambing ang null gamit ang ==(katumbas) at !=(hindi katumbas) na mga operator, ngunit hindi mo ito magagamit sa iba pang arithmetic o lohikal na mga operator tulad ng <(mas mababa sa) o >(mas malaki kaysa). Hindi tulad ng SQL, ang Java null == nullay magbabalik ng true tulad ng ipinapakita sa ibaba:

public class Test {
	public static void main(String args[]) throws InterruptedException {
		String abc = null;
		String cde = null;
		if(abc == cde){
			System.out.println("null == null is true in Java");
		}
		if(null != null){
			System.out.println("null != null is false in Java");
		}
		// classical null check
		if(abc == null){
			// do something
		}
		// not ok, compile time error
		if(abc > null){

		}
	}
}

Output:
null == null is true in Java

Ito ay tungkol sa null sa Java. Sa pamamagitan ng pagkakaroon ng ilang karanasan sa Java programming at paggamit ng mga simpleng trick upang maiwasan ang NullPointerException, maaari mong gawing ligtas ang iyong code. kasi Ang null ay maaaring ituring bilang isang walang laman o hindi nasimulang halaga, ito ay kadalasang pinagmumulan ng pagkalito, kaya naman mahalagang idokumento ang pag-uugali ng isang pamamaraan kapag ang isang null na halaga ay input. Palaging tandaan, ang null ay ang default na halaga ng mga reference na variable, at hindi ka makakatawag ng mga instance method o ma-access ang mga variable ng instance gamit ang isang null reference sa Java.

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION