Statyczny / dynamiczny vs mocny / słaby

319

Widzę te terminy w różnych miejscach w programowaniu i mam niejasne pojęcie o ich znaczeniu. Wyszukiwanie pokazuje mi, że takie rzeczy były w rzeczywistości pytane o przepełnienie całego stosu. O ile mi wiadomo, pisanie statyczne / dynamiczne w językach subtelnie różni się od pisania silnego / słabego, ale jaka to różnica mi umyka. Różne źródła wydają się używać różnych znaczeń, a nawet terminów zamiennie. Nie mogę znaleźć czegoś, co mówi o obu tych rzeczach i właściwie wyjaśnia różnicę. Byłoby miło, gdyby ktoś mógł to jasno przeliterować tutaj dla mnie i reszty świata.

Dan Revell
źródło

Odpowiedzi:

423
  • Wpisywanie statyczne / dynamiczne dotyczy momentu uzyskania informacji o typie (w czasie kompilacji lub w czasie wykonywania)

  • Silne / słabe pisanie dotyczy tego, jak ściśle rozróżniane są typy (np. Czy język próbuje dokonać niejawnej konwersji ciągów na liczby).

Zobacz stronę wiki, aby uzyskać bardziej szczegółowe informacje.

Dario
źródło
7
Wikipedia ma wszystkie odpowiedzi. Dlaczego nie natknąłem się na to już nie wiem.
Dan Revell
31
Szkoda, że ​​wielu nie zdaje sobie sprawy, że statyczne / dynamiczne to coś innego niż mocne / słabe ... Naprawdę uratowałoby to stronniczość i dyskusję.
Dykam
10
Istnieją różne stopnie „słabości typu”. Mocno napisany język może próbować konwersji ciągów na liczby. Z drugiej strony, HyperTalk (język, którego używałem kilkadziesiąt lat temu) był tak słabo napisany, że "12" + "34"byłby równy "46", ale "12" + "34Q"byłby równy "1234Q"[na szczęście można by pisać, "12" & "34"gdyby ktoś chciał łączyć]. Co ciekawe, zmienne zawierające liczby zapisywały je jako zmiennoprzecinkowe podwójnej precyzji, a matematyka na takich zmiennych używała wartości zmiennoprzecinkowych bez mungowania łańcucha, ale nie było sposobu, aby zapytać, czy zmienna jest łańcuchem czy liczbą.
supercat
9
@kittylyst Nie wiem, gdzie ta odpowiedź sugeruje, że silny jest synonimem szumu
Pete
4
++ dla (z grubsza) definicji jednowierszowych.
JamesFaix
211

Odkryłeś słabość terminologii używanej przez amatorów do mówienia o językach programowania. Nie używaj terminów „mocne” i „słabe” pisanie , ponieważ nie mają one powszechnie uzgodnionego znaczenia technicznego. Natomiast wpisywanie statyczne oznacza, że ​​programy są sprawdzane przed uruchomieniem, a program może zostać odrzucony przed jego uruchomieniem. Wpisywanie dynamiczne oznacza, że ​​typy wartości są sprawdzane podczas wykonywania , a źle wpisana operacja może spowodować zatrzymanie programu lub inny sygnał błędu w czasie wykonywania . Podstawowym powodem pisania statycznego jest wykluczenie programów, które mogą mieć takie „błędy typu dynamicznego”.

Silne pisanie na ogół oznacza, że ​​nie ma luk w systemie typów, natomiast słabe pisanie oznacza, że ​​system typów może zostać obalony (unieważniając wszelkie gwarancje). Terminy są często używane nieprawidłowo, aby oznaczać pisanie statyczne i dynamiczne. Aby zobaczyć różnicę, pomyśl o C: język jest sprawdzany podczas kompilacji (pisanie statyczne), ale jest wiele luk; możesz rzucić dowolną wartość na inny typ tego samego rozmiaru - w szczególności możesz dowolnie rzutować typy wskaźników. Pascal był językiem, który miał być mocno napisany na maszynie, ale słynął z nieprzewidzianej luki: wariant zapisu bez tagu.

Implementacje silnie typowanych języków często nabierają luk w czasie, zwykle po to, aby część systemu wykonawczego mogła zostać zaimplementowana w języku wysokiego poziomu. Na przykład Objective Caml ma wywoływaną funkcję, Obj.magicktóra w czasie wykonywania po prostu zwraca swój argument, ale w czasie kompilacji konwertuje wartość dowolnego typu na dowolny inny typ. Moim ulubionym przykładem jest Modula-3, której projektanci nazwali konstrukcję rzutową LOOPHOLE.

Powiedziawszy to, nie można liczyć na to, że dwie osoby będą używać słów „silny” i „słaby” w dokładnie taki sam sposób. Więc ich unikaj.

Norman Ramsey
źródło
31
(+1) za Twoją sugestię, aby unikać terminów „silny” i „słaby”.
Nico
1
Zgadzam się, właśnie czytałem książkę Jona Skeeta i jest to ta sama odpowiedź, o której tam pisano.
Bennett Yeates
O ile mi wiadomo, Java ma również te luki, ale nadal jest uważana za język o silnym typie, więc myślę, że to nadaje większą wagę twojej radzie, aby unikać określeń „silny” i „słaby”.
doubleOrt,
74

Mówiąc prosto: w języku o typie statycznym typ jest statyczny , co oznacza, że ​​po ustawieniu zmiennej na typ NIE MOŻNA go zmienić. Wynika to z faktu, że pisanie jest powiązane ze zmienną, a nie z wartością, do której się odnosi.

Na przykład w Javie:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

Podczas gdy w języku dynamicznie typowanym typ jest dynamiczny , co oznacza, że ​​po ustawieniu zmiennej na typ, MOŻNA ją zmienić. Wynika to z faktu, że pisanie jest powiązane z wartością, a nie ze zmienną.

Na przykład w Pythonie:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

Z drugiej strony, silne / słabe pisanie w języku jest powiązane z niejawnymi konwersjami typów (częściowo zaczerpniętymi z odpowiedzi @ Dario):

Na przykład w Pythonie:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

podczas gdy w PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Wpisywanie statyczne pozwala sprawdzić poprawność typu w czasie kompilacji. Języki o typie statycznym są zwykle kompilowane, a języki o typie dynamicznym są interpretowane. Dlatego języki dynamicznie wpisywane mogą sprawdzać pisanie w czasie wykonywania.

mehmet
źródło
2
świetna odpowiedź i podziękowania za użycie konkretnych przykładów.
Julian A.
3
Dlatego PHP należy używać z dużą ostrożnością.
Ali Gajani,
1
Przykłady języków są naprawdę pomocne. Bardzo mile widziane.
J Mullen,
W tym sensie czy Java byłaby tak lekko słabo wpisana, ponieważ można łączyć nie łańcuchy z łańcuchami oraz z powodu automatycznego rozpakowywania / boksu?
Stephen Paul,
1
@StephenPaul masz rację, moja odpowiedź może być rozumiana w ten sposób i że tak nie jest. Użyłem konkatenacji dla uproszczenia, ale tak naprawdę moc / słabość dotyczy niejawnej konwersji typu samej zmiennej.
mehmet
20

Słabe pisanie oznacza, że ​​typ obiektu może się zmieniać w zależności od kontekstu. Na przykład w słabo wpisanym języku ciąg „123” może być traktowany jako liczba 123, jeśli dodasz do niego kolejny numer. Przykładami języków o słabym pisaniu są bash, awk i PHP.

Innym rodzajem słabo wpisanego języka jest C, gdzie dane pod adresem pamięci można traktować jako inny typ przez rzutowanie.

W silnie typowanym języku typ obiektu nie zmienia się - int jest zawsze int i próba użycia go jako łańcucha spowoduje błąd. Zarówno Java, jak i Python są mocno wpisane.

Różnica między pisaniem dynamicznym a statycznym polega na egzekwowaniu reguł typów. W języku o typie statycznym typ każdej zmiennej i parametru musi być zadeklarowany w źródle i jest wymuszany w czasie kompilacji. W języku dynamicznie wpisywanym typy są sprawdzane tylko wtedy, gdy są używane w czasie wykonywania. Zatem Java jest wpisywana statycznie, a Python jest wpisywany dynamicznie.

Jednak granice mogą być czasami rozmyte. Na przykład, chociaż Java jest wpisywana statycznie, za każdym razem, gdy używasz refleksji lub rzutowania (np. Podczas używania kontenerów obiektów), odkładasz sprawdzanie typu na środowisko wykonawcze.

Podobnie najbardziej silnie wpisane języki będą nadal automatycznie konwertować między liczbami całkowitymi i liczbami zmiennoprzecinkowymi (aw niektórych językach BigInts z precyzją alfabetyczną).

Dave Kirby
źródło
1
Nie mogę się zgodzić z tym zdaniem. „W języku o typie statycznym typ każdej zmiennej i parametru musi być zadeklarowany w źródle” - w SML typy zmiennych nie muszą być deklarowane (jakkolwiek są sprawdzane). Powiedzmy, że funkcja fprzyjmuje argument x( fun f(x)) [**, więc żadne typy nie są deklarowane **], a treść funkcji to x+1. Bez zadeklarowanych typów kompilator zorientuje się, że xmusi to być int. - fun f x = x + 1; val f = fn : int -> int
Filip Bartuzi,
Jeśli chodzi o C, rzutowanie nie jest sprzeczne z mocnym pisaniem, ale C pozwala także dodawać różne typy bez rzucania, np .:5 + 'c' // OK
mehmet
3
@mehmet: w C wartości znaków znajdują się w domenie całkowitej, więc ten konkretny przykład nie narusza bezpieczeństwa typu. „c” to po prostu cukier składniowy dla 99. C nie ma dedykowanego typu znaków.
Peter Lewerin
Peter Lewerin: tak, powinienem był dać lepszy przykład. Niestety minęło prawie 20 lat, odkąd nie dotknąłem C :)
mehmet
1
C nie jest słabo napisanym językiem . Tyle, że Java, C # itp. Są językami silniej typowanymi w porównaniu do C. Więcej informacji tutaj - en.wikipedia.org/wiki/Strong_and_weak_typing Jeśli sprawdzisz definicję języka „słabo” wpisanego, wówczas „słabo” napisane języki są takie, w których można wykonać dowolny typ konwersji, na przykład int może być „niejawnie” przekonwertowany lub wrzucony do łańcucha, teraz myślisz, że jest to możliwe w C, czy nie?
hagrawal
15

Dzisiaj badając ten temat natknąłem się na ten świetny artykuł http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html To wyjaśniło wiele rzeczy dla mnie i pomyślałem, że może to dodać do niektórych świetnych odpowiedzi powyżej.

Mocne i słabe pisanie:

Prawdopodobnie najczęstszym sposobem klasyfikacji systemów typów jest „silny” lub „słaby”. Jest to niefortunne, ponieważ te słowa prawie nie mają żadnego znaczenia. W ograniczonym zakresie możliwe jest porównanie dwóch języków z bardzo podobnymi systemami typów i oznaczenie jednego jako silniejszego z tych dwóch systemów. Poza tym słowa w ogóle nic nie znaczą.

Typy statyczne i dynamiczne

Jest to prawie jedyna wspólna klasyfikacja systemów typów, która ma prawdziwe znaczenie. W rzeczywistości jego znaczenie jest często niedoceniane [...] Dynamiczne i statyczne układy typu to dwie zupełnie różne rzeczy, których cele częściowo się pokrywają.

System typów statycznych to mechanizm, za pomocą którego kompilator sprawdza kod źródłowy i przypisuje etykiety (zwane „typami”) do części składni, a następnie używa ich do wnioskowania o zachowaniu programu. System typu dynamicznego jest mechanizmem, za pomocą którego kompilator generuje kod do śledzenia rodzaju danych (przypadkowo zwanych także „typem”) używanych przez program. Użycie tego samego słowa „typ” w każdym z tych dwóch systemów nie jest oczywiście całkowicie przypadkowe; ale najlepiej to rozumieć jako mające słabe znaczenie historyczne. Wielkie zamieszanie wynika z próby znalezienia poglądu na świat, w którym „typ” naprawdę oznacza to samo w obu systemach. Tak nie jest.

Typy jawne / niejawne:

Kiedy te terminy są używane, odnoszą się one do zakresu, w jakim kompilator będzie uzasadniał statyczne typy części programu. Wszystkie języki programowania mają jakąś formę wnioskowania o typach. Niektóre mają więcej niż inne. ML i Haskell mają typy niejawne, ponieważ nie są potrzebne (lub bardzo niewiele, w zależności od języka i używanych rozszerzeń) deklaracje typu. Java i Ada mają bardzo wyraźne typy, a jeden stale deklaruje typy rzeczy. Wszystkie powyższe mają (względnie w porównaniu do na przykład C i C ++) silne systemy typu statycznego.

Gonz
źródło
8

Ze Scott's Programming Language Pragmatics , wydanie trzecie, strona 291, mamy

Sprawdzanie typów to proces zapewniający, że program przestrzega reguł zgodności typów języka. Naruszenie zasad jest znane jako konflikt typów. Mówi się, że język jest silnie pisany, jeśli zabrania, w sposób, który implementacja języka może wymusić, zastosowania dowolnej operacji do dowolnego obiektu, który nie jest przeznaczony do obsługi tej operacji. Mówi się, że język jest wpisywany statycznie, jeśli jest mocno wpisany, a sprawdzanie typu można wykonać w czasie kompilacji. W najściślejszym znaczeniu tego terminu kilka języków jest wpisywanych statycznie. W praktyce termin ten jest często stosowany w językach, w których większość sprawdzania typu można wykonać w czasie kompilacji, a resztę można wykonać w czasie wykonywania.

Kilka przykładów: Ada jest silnie wpisana, a przeważnie wpisana statycznie (pewne ograniczenia typu muszą być sprawdzone w czasie wykonywania). Implementacja Pascal może również sprawdzać większość swoich typów w czasie kompilacji, chociaż język nie jest dość mocno wpisany: nieoznakowane rekordy wariantów (do omówienia w rozdziale 7.3.4) są jedyną luką. C89 jest znacznie silniej pisany niż jego wcześniejsze dialekty, ale wciąż znacznie słabiej pisany niż Pascal. Jego luki obejmują związki, podprogramy o zmiennej liczbie parametrów oraz interoperacyjność wskaźników i tablic (do omówienia w rozdziale 7.7.1). Implementacje C rzadko sprawdzają cokolwiek w czasie wykonywania.

Dynamiczne sprawdzanie typu (w czasie wykonywania) jest formą późnego wiązania i zwykle znajduje się w językach, które opóźniają inne problemy również do czasu wykonania. Lisp i Smalltalk są dynamicznie (choć mocno) wpisywane. Większość języków skryptowych jest także wpisywana dynamicznie; niektóre (np. Python i Ruby) są mocno wpisane. Języki z dynamicznym określaniem zakresu są na ogół dynamicznie wpisywane (lub wcale nie są wpisywane): jeśli kompilator nie może zidentyfikować obiektu, do którego odnosi się nazwa, zwykle nie może również określić typu obiektu.

W prostych słowach, pisanie statyczne / dynamiczne odnosi się do czasu, w którym następuje sprawdzenie typu: czas kompilacji dla pisania statycznego i czas wykonywania dla języków dynamicznych. Podobnie, silne / słabe pisanie odnosi się do tego, jak agresywny jest język w egzekwowaniu swojego systemu czcionek.

Próbowałem przetłumaczyć opis Scotta na ładny schemat, który zamieściłem poniżej.

Płaszczyzna statyczna / dynamiczna - mocna / słaba

Evan Rosica
źródło
5

Myślę, że inni koledzy zrobili dobrą robotę, esp. wyjaśniając różnicę między pisaniem statycznym a dynamicznym. Ale jeśli chodzi o mocne i słabe pisanie, należy powiedzieć, że istnieją różne interpretacje / poglądy.

Oto dwa przykłady:

  • Niektórzy twierdzą, że Haskell jest silnie napisany na maszynie, ponieważ nie wolno dokonywać żadnych konwersji typu.

  • Inni (np. Pogląd Dario) twierdzą, że język, który pozwala celowo konwertować ciąg znaków na liczbę, jest celowo słabo wpisany, ale nawet inni nazywają to po prostu pisaniem kaczych znaków.

Oba stwierdzenia podkreślają nie przeciwne skrajności systemu typów, ale zupełnie inne aspekty. Tak więc przyłączam się do poglądu pana Ramseya, aby nie używać terminów „silny” i „słaby” do rozróżnienia systemów typów.

Nico
źródło
5

Języki o typie dynamicznym v / s

  • Języki o typie statycznym to te, w których sprawdzanie typu odbywa się w czasie kompilacji, więc oznacza to również, że w językach o typie statycznym każda zmienna ma typ i nie zmienia się w trakcie przebiegu. W przeciwieństwie do tego, dynamicznie typowane języki to te, w których sprawdzanie typu odbywa się w czasie wykonywania, i nie ma sprawdzania typu w czasie kompilacji, więc oznacza to również, że w dynamicznie typowanych językach może istnieć lub nie być typ powiązany ze zmiennymi , a jeśli typ jest skojarzony, może to być typ ogólny, taki jak „var” w JS, który dobrze pasuje zarówno do ciągu, jak i liczby.
    • „Implementacje języków dynamicznie sprawdzanych typu zazwyczaj kojarzą każdy obiekt środowiska wykonawczego ze znacznikiem typu (tj. Odniesieniem do typu) zawierającym informacje o jego typie. Te informacje o typie środowiska wykonawczego (RTTI) można również wykorzystać do wdrożenia dynamicznej wysyłki, późnego wiązania, rzutowania w dół, odbicia i podobnych funkcji. ”
  • Nawet jeśli język jest wpisywany statycznie, nadal może mieć jakąś dynamicznie wpisywaną funkcję, co w zasadzie oznacza, że ​​pewne sprawdzanie typów również w czasie wykonywania. Jest to przydatne w rzutowaniu typów.
    • „Szereg przydatnych i popularnych funkcji języka programowania nie można sprawdzić statycznie, takich jak rzutowanie w dół. Dlatego wiele języków będzie miało zarówno statyczne, jak i dynamiczne sprawdzanie typu; moduł sprawdzania typu statycznego sprawdza, co może, a sprawdzanie dynamiczne weryfikuje resztę. ”
  • „Niektóre języki umożliwiają pisanie kodu, który nie jest bezpieczny dla typu. Na przykład w C programiści mogą dowolnie rzutować wartość między dowolne dwa typy o tym samym rozmiarze. ”
  • Zaletą języków „statycznych” jest to, że:
    • Ponieważ większość sprawdzania typów jest wykonywana w czasie kompilacji, więc interpreter lub środowisko wykonawcze może działać z pełną prędkością, nie martwiąc się o typy.
    • Prowadzi to do mniejszej liczby wyjątków czasu wykonywania lub błędów związanych z typem, ponieważ większość sprawdzania typu odbywa się w czasie kompilacji.
  • Zaletą języków dynamicznych jest to, że:
    • Mogą pomóc w niezwykle szybkim prototypowaniu, ponieważ deweloper nie musi rozumieć systemu typów, aby programista mógł swobodnie tworzyć zmienne i uruchamiać je, a to prowadzi do bardzo szybkiego prototypowania.
  • Lista języków wpisywanych statycznie i dynamicznie :
    • Statycznie:
      • Jawa
      • C (C jest językiem typowanym statycznie, ale mniej „silnie” typowanym w porównaniu z Javą, ponieważ pozwala na bardziej niejawną konwersję)
      • C ++
      • DO#
    • Dynamicznie:
      • PERL
      • PHP
      • Pyton
      • JavaScript
      • Rubin
  • Sprawdzanie typu jest ważną funkcją bezpieczeństwa. Załóżmy, że nie ma sprawdzania typu, a metoda akceptuje obiekt typu „BankAccount”, który ma metodę o nazwie „creditAccount (BankAccountDetails)”, teraz w czasie wykonywania, jeśli nie ma sprawdzania typu, wówczas mogę przekazać własny obiekt klasa, która ma tę samą metodę „creditAccount (BankAccountDetails)” i zostanie wykonana, biorąc pod uwagę, że mówimy o języku obiektowym, ponieważ OOP obsługuje „polimorfizm”, a tutaj omawiamy tylko „polimorfizm”. Tak więc w zasadzie język obiektowy (co w zasadzie oznacza, że ​​obsługuje „polimorfizm”), który nie ma silnego sprawdzania typu, może prowadzić do problemów bezpieczeństwa.

Języki silnie v / s słabo wpisane

  • Języki silnie typowane to te, w których niejawne konwersje są niedozwolone w przypadku utraty precyzji. Na przykład w Javie można rzutować „int na long”, ponieważ nie ma utraty precyzji, ale nie można „niejawnie” rzutować „int na long”, ponieważ nastąpiłaby utrata precyzji. Natomiast w słabo wpisanych językach dozwolone są niejawne konwersje nawet w przypadku utraty precyzji.
  • Wydaje mi się, że dynamicznie pisany język może być również silnie pisanym językiem, jeśli „w czasie wykonywania” nie pozwala na niejawne konwersje, w których występuje utrata precyzji.

Dobre dalsze odczyty

hagrawal
źródło
zacytowałeś „teraz w czasie wykonywania, jeśli nie ma sprawdzania typu, wtedy mogę przekazać obiekt mojej klasy, który ma tę samą metodę„ creditAccount (BankAccountDetails) ”- jeśli już przekroczyłeś mechanizm, który mógł zablokować ci przejście obiektu to w jaki sposób sprawdzanie typu powstrzyma cię przed wywołaniem tej metody w przypadku języka o typie statycznym?
Aseem Yadav
@AseemYadav Co rozumiesz przez „*, jeśli przekroczyłeś już mechanizm, który mógł zablokować ci przekazanie obiektu *”?
hagrawal
jak wspomniałeś, jest to ważna funkcja bezpieczeństwa, a także to, że możesz przekazać obiekt swojej klasy tą samą metodą, więc sugeruje mi, że jest to luka tylko wtedy, gdy próbujesz włamać się do kodu innej osoby i jeśli mówisz w kontekście kodu, który należy do ciebie, jest to bardziej problem z wydajnością niż ten związany z bezpieczeństwem, prawda?
Aseem Yadav,
Nie ma w tym aspektu wydajności, musisz to zobaczyć w kontekście polimorfizmu, wtedy będziesz w stanie zrozumieć aspekt bezpieczeństwa, wspomniałem o tym w tym samym akapicie.
hagrawal
1

Języki o typie statycznym zazwyczaj wymagają deklarowania typów zmiennych, które są następnie sprawdzane w czasie kompilacji w celu ograniczenia błędów. Słowo „statyczny” w „statycznie typowany” odnosi się do „statycznej analizy kodu”, która jest procesem sprawdzania kodu przed jego wykonaniem. Chociaż możliwe jest, aby język o typie statycznym mógł wywnioskować typ zmiennej z prawej strony wyrażenia lub rzeczywistych parametrów, w praktyce większość języków o typie statycznym wymaga jawnego zadeklarowania typów zmiennych.

Języki o typie dynamicznym generalnie nie wymagają deklaracji zmiennych, aby mieć typy, i wnioskują o typach zmiennych na podstawie typu obliczonego w wyniku oceny prawej strony każdej instrukcji przypisania lub rzeczywistych parametrów wywołania funkcji. Ponieważ zmienna może mieć wiele przypisań przez cały okres jej istnienia, jej typ może zmieniać się w czasie i dlatego nazywany jest „typowaniem dynamicznym”. Ponadto środowisko wykonawcze musi śledzić bieżący typ dla każdej zmiennej, więc typ jest powiązany z wartością, a nie z deklaracją zmiennej. Można to uznać za system informacji o środowisku wykonawczym (RTTI).

Elementy języków pisanych statycznie i dynamicznie można łączyć. Na przykład C # obsługuje zarówno zmienne o typie statycznym, jak i dynamicznym, a języki zorientowane obiektowo ogólnie obsługują hierarchię typów. Języki o typie statycznym zazwyczaj zapewniają różne sposoby na ominięcie sprawdzania typu, na przykład za pomocą rzutowania, odbicia i dynamicznego wywoływania.

Mocne vs. słabe pisanie odnosi się do kontinuum tego, jak bardzo język próbuje zapobiec błędom z powodu używania zmiennej tak, jakby był jednym typem, podczas gdy w rzeczywistości jest innym typem. Na przykład zarówno C, jak i Java są językami o typie statycznym, jednak Java korzysta ze znacznie silniejszego sprawdzania typów niż C. Poniższy kod C z przyjemnością się kompiluje i uruchamia, i wstawi losową wartość do zmiennej b w czasie wykonywania, najprawdopodobniej powodując pluskwa:

char *a = "123";
int b = (int)a;

Odpowiednik kodu Java spowoduje błąd kompilacji, co jest ogólnie preferowane:

String a = "123"
int b = (int)a;
Niebezpieczeństwo
źródło