How is strict typing manifested in Java?

Strict typing in Java manifests in the following:

1. Explicit type declaration: It is necessary to explicitly specify the type of a variable, the return type of a method, and parameters.

   // Explicit declaration of int type for variable count
   int count = 10;
   
   // Explicit declaration of String type for method return value
   public String getName() {
       return "Java";
   }
   

2. Type checking at compile time: The Java compiler checks the compatibility of operation types and prevents mismatches that could lead to runtime errors.

   // Compilation error: cannot assign String to an int variable
   // int number = "hello"; 
   
   // Compilation error: cannot call a method with incompatible parameter types
   // String message = "world";
   // System.out.println(123 + message); // Works due to string concatenation
   // But this will not compile:
   // int result = "hello" * 5; 
   

3. Need for type casting: To convert a variable from one type to another explicitly.

   // Converting double to int with loss of precision
   double pi = 3.14;
   int integerPart = (int) pi; // Explicit cast
   
   // Converting objects of different types in an inheritance hierarchy
   // Object obj = "String value";
   // String str = (String) obj; // Explicit cast
   

4. Restrictions on implicit conversions: Implicit conversions occur only for "widening" conversions (e.g., from int to long), where there is no data loss. Reverse conversions require explicit casting.

Strict typing increases code reliability by detecting errors early in the development stage (compile time), reducing the number of errors during runtime.