{"id":494,"date":"2020-06-10T14:57:36","date_gmt":"2020-06-10T12:57:36","guid":{"rendered":"https:\/\/arasoftware.pl\/?p=494"},"modified":"2021-10-21T10:34:00","modified_gmt":"2021-10-21T08:34:00","slug":"java-wnioskowanie-typow-zmiennych-lokalnych","status":"publish","type":"post","link":"https:\/\/arasoftware.pl\/en\/java-wnioskowanie-typow-zmiennych-lokalnych\/","title":{"rendered":"JAVA – Wnioskowanie typ\u00f3w zmiennych lokalnych"},"content":{"rendered":"Czas czytania: <\/span> 3<\/span> minut<\/span><\/span>

Od lat Java w stosunku do innych języków programowania, takich jak Scala, Kotlin, Groovy czy C# była uważana za nie co antyczną, jeśli chodzi o wnioskowanie typów oraz możliwości programowania funkcyjnego. Sytuacja nie co się zmieniła w momencie wejścia Javy w wersji 8. Twórcy Javy dodali tam Stream’y czy też wyrażenia Lambda. Jednak nadal w Javie brakowało dynamicznego typowania zmiennych, tak jak to ma miejsce we wcześniej wymienionych językach programowania. Dodatkowo warto dodać, że Kotlin, Scala i Groovy są wykonywanie na JVM, w taki sam sposób jak Java a mimo to posiadały taką funkcjonalność. <\/p>\n\n\n

W końcu z pomocą przyszła nam Java 10, która wprowadziła nowy feature — słowo kluczowe var. Dzięki niemu możemy w łatwy sposób używać wnioskowania typów zmiennych lokalnych. Ta funkcjonalność została dodana do Javy 10 w JEP 286: Local-Variable Type Inference<\/a><\/strong>. Niestety to słowo kluczowe, chociaż nie jest to tak naprawdę typowe słowo kluczowe, ale o tym później, ma też swoje ograniczenia i użycie tego mechanizmu typowania zmiennych nie jest jeszcze możliwe na tak szerokim poziomie, jak w przypadku Kotlina czy Grooviego. <\/p>\n\n\n

\n
Wnioskowanie typów – przykład użycia var<\/em>\n<\/h3>\n\n\n\n
\/\/string declaration without var keyword\nString someText = \"This is another post on AraSoftware.pl\";\n\n\/\/string declaration with var keyword\nvar someText2 = \"This is another post on AraSoftware.pl\";<\/code><\/pre>\n\n\n
Użycie var <\/em>w Javie 10 jest ograniczone do zmiennych lokalnych. Nie możemy zadeklarować pola w klasie, które będzie typu var<\/em>. Taka operacja zakończy się błędem podczas kompilacji kodu. <\/p>\n\n\n\n
public class SomeClass {\n  \n  String someField = \"some string value\";\n  var anotherField = 10; \/\/ compilation time error\n\n  public void someMethod() {\n    var localVariable = 10; \/\/ this var keyword usage is allowed\n    var var  = 10; \/\/ this is allowed but strange usage \n    \/**\n      .\n      .\n      .\n      method body\n    **\/\n  }\n}<\/code><\/pre>\n\n\n
Jak napisałem we wstępie, nie jest to typowe słowo kluczowe. Jest to jedynie rezerwacja nazwy typu. Samo zastąpienie typu zmiennej na słowo var <\/em>na pierwszy rzut oka nie przynosi jakichś znaczących usprawnień. Mimo to warto to stosować w momencie, gdy typ zmiennej lokalnej nie ma znaczenia w kontekście zrozumienia kodu przez programistę. <\/p>\n\n\n
Kolejną zaletą stosowania var<\/em> jest skracanie kodu. Możemy zastąpić typy generyczne, które często posiadają całkiem długą składnię, co znacząco utrudnia czytanie kodu.<\/p>\n\n\n\n
\/\/without var keyword usage\ntry (Stream<Post> postItem = dbConnection.executeQuery(sql)) {\n  \/\/do something with postItem variable\n}\n\n\/\/with var keyword usage\ntry (var postItem = dbConnection.executeQuery(sql)) {\n  \/\/do something with postItem variable\n}<\/code><\/pre>\n\n\n
Kolejnym ograniczeniem stosowania var <\/em>jest to, że nie można go stosować zamiennie podczas deklaracji zwracanego typu przez metodę. Tutaj musimy użyć void <\/em>lub innego typu poza var<\/em>. To samo dotyczy się do parametrów metody. Nie możemy tam używać var <\/em>ze względu na to, że kompilator na etapie kompilacji nie będzie w stanie wywnioskować jaki typ danych powinien się tam znaleźć. <\/p>\n\n\n\n
public class SomeClass {\n  \n  public var someMethod() { \/\/ not allowed var usage\n    \/\/method body\n  }\n\n  public void someMethod(var parameter) { \/\/ not allowed var usage\n    \/\/method body\n  } \n}<\/code><\/pre>\n\n\n
\n
Podsumowanie <\/h3>\n\n\n
Mechanizm wnioskowania typów zmiennych w Javie 10 nie jest idealny, ale i tak wprowadza już pewne udogodnienie dla programistów. Nie da się ukryć, że wpływa na czytelność i długość pisanego kodu. Jednak moim zdaniem pozostaje jedynie miłym dodatkiem, a nie rewolucyjnym rozwiązaniem. Ograniczenia wynikają głównie z zachowania kompatybilności wstecznej. Uważam, że jest to krok w dobrym kierunku. Mam też nadzieję, że wraz z kolejnymi wersjami Javy zostaną wprowadzone mechanizmy pozwalające nam na jeszcze więcej. <\/p>\n\n\n