Что использовал: Java или Kotlin

Опыт с Java и Kotlin

В моей карьере я работал в основном с Java, как с основным языком для backend разработки. Также имею практический опыт с Kotlin, особенно в контексте Android приложений и некоторых backend проектов.

Почему Java для большинства проектов

Я выбирал Java для большинства enterprise приложений потому что:

// Java: стабильность, огромная экосистема, множество frameworks
@RestController
@RequestMapping("/api/users")
@Slf4j
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        log.info("Fetching user with id: {}", id);
        return userService.findById(id)
            .map(ResponseEntity::ok)
            .orElseGet(() -> ResponseEntity.notFound().build());
    }
}

Плюсы Java:

• Зрелая экосистема (Spring, Hibernate, JUnit)
• Большое сообщество и простота найти документацию
• Стабильность - изменения между версиями хорошо протестированы
• Лучшая поддержка старого кода
• Множество инструментов для профилирования и отладки

Kotlin для Android и modern projects

Для Android приложений и некоторых новых проектов я использовал Kotlin.

// Kotlin: более лаконичный синтаксис
@RestController
@RequestMapping("/api/users")
class UserController(private val userService: UserService) {
    @GetMapping("/{id}")
    fun getUser(@PathVariable id: Long): ResponseEntity<UserDto> {
        logger.info { "Fetching user with id: $id" }
        return userService.findById(id)
            ?.let { ResponseEntity.ok(it) }
            ?: ResponseEntity.notFound().build()
    }
}

Плюсы Kotlin:

• Более лаконичный синтаксис
• Null-safety встроен в язык
• Extension functions для удобства
• Data classes для моделей
• Coroutines для асинхронного кода

Сравнение основных различий

1. Null-safety

// Java - всегда риск NullPointerException
User user = userRepository.findById(1L).orElse(null);
if (user != null) {
    String email = user.getEmail();
    if (email != null) {
        System.out.println(email);
    }
}

// Kotlin - null-safety встроен
val user: User? = userRepository.findById(1L).orElse(null)
val email: String? = user?.email  // Safe call
user?.let { u -> println(u.email) }  // Only if not null

2. Синтаксис функций

// Java
public UserDto mapToDto(User user) {
    return new UserDto(
        user.getId(),
        user.getName(),
        user.getEmail()
    );
}

// Kotlin
fun mapToDto(user: User) = UserDto(
    user.id,
    user.name,
    user.email
)

3. Data classes

// Java - много boilerplate
public class UserDto {
    private Long id;
    private String name;
    private String email;

    public UserDto(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public boolean equals(Object o) { /* ... */ }

    @Override
    public int hashCode() { /* ... */ }
}

// Kotlin - все автоматически
data class UserDto(
    val id: Long,
    val name: String,
    val email: String
)
// equals, hashCode, toString, copy - все сгенерировано

4. Extension Functions

// Kotlin - можно добавить функцию к существующему классу
fun String.isValidEmail(): Boolean = 
    this.contains("@") && this.contains(".")

val email = "john@example.com"
if (email.isValidEmail()) {
    // ...
}

5. Coroutines для асинхронности

// Kotlin с Coroutines
@GetMapping("/users/{id}")
suspend fun getUser(@PathVariable id: Long): UserDto =
    userService.findByIdAsync(id)

@Service
class UserService(private val userRepository: UserRepository) {
    suspend fun findByIdAsync(id: Long): User =
        withContext(Dispatchers.IO) {
            userRepository.findById(id)
        }
}

Мой выбор в разных контекстах

Java используется когда:

• Legacy проект, который нужно поддерживать
• Команда знает только Java
• Нужна максимальная совместимость
• Enterprise приложение с консервативным стеком

// Классический Spring Boot приложение
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Kotlin используется когда:

• Новый проект, где можно выбирать технологию
• Android разработка
• Команда готова учить Kotlin
• Нужна лаконичность и null-safety

// Kotlin + Spring Boot
@SpringBootApplication
fun main(args: Array<String>) {
    runApplication<Application>(*args)
}

@RestController
@RequestMapping("/api")
class ApiController {
    @GetMapping("/status")
    fun getStatus() = mapOf("status" to "OK")
}

Взаимодействие Java и Kotlin

Одно из больших преимуществ Kotlin - полная совместимость с Java на уровне JVM.

// Kotlin сервис
@Service
class UserService(private val userRepository: UserRepository) {
    fun findById(id: Long): UserDto? =
        userRepository.findById(id)
            ?.let { mapToDto(it) }
}

private fun mapToDto(user: User) = UserDto(
    user.id,
    user.name,
    user.email
)

// Java контроллер может использовать Kotlin сервис
@RestController
public class UserController {
    private final UserService userService;  // Kotlin сервис

    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        UserDto user = userService.findById(id);
        return user != null ? ResponseEntity.ok(user) 
                            : ResponseEntity.notFound().build();
    }
}

Рекомендация

Я рекомендую:

1. Для стабильности и зрелости - Java 17+ (LTS версии)
2. Для новых проектов и удобства - Kotlin
3. Для Android - Kotlin (это официальный язык Google)

В идеальном мире я бы выбрал Kotlin для новых проектов из-за его современности и безопасности, но Java остается отличным выбором для большинства enterprise приложений благодаря огромной экосистеме и стабильности.

Мой опыт позволяет мне быстро переключаться между обоими языками и выбирать правильный инструмент для задачи.