import java.io.StringWriter;

public class Task040225 {
    public static void main(String[] args) {
        StringWriter writer = new StringWriter();
        writer.write("Hello");
        writer.append(" World");
        System.out.println(writer.toString().length());
    }
}

Class<String> stringClass = String.class;
Этот способ работает для любого типа, включая примитивы и массивы.

String str = "Hello";
Class<?> stringClass = str.getClass();
Этот метод доступен для всех объектов и возвращает класс их экземпляра.

Class<?> stringClass = Class.forName("java.lang.String");
Этот метод полезен, когда имя класса известно только во время выполнения.

Class<?> intClass = int.class;
System.out.println(intClass.getName()); // Вывод: int

Class<?> stringClass = String.class;
System.out.println(stringClass.getName()); // Вывод: java.lang.String

Class<?> arrayClass = int[].class;
System.out.println(arrayClass.getName()); 

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
};
Class<?> anonymousClass = runnable.getClass();
System.out.println(anonymousClass.getName()); // Вывод: com.example.Main$1

String str = "Hello";
Class<?> strClass = str.getClass(); // Получаем Class для объекта String
Class<?> intClass = int.class;      // Получаем Class для примитива int
Class<?> arrClass = String[].class; // Получаем Class для массива String[]

Class<?> strClass = String.class;
System.out.println(strClass.getName()); // Вывод: java.lang.String

System.out.println(strClass.getSimpleName()); // Вывод: String

Package pkg = strClass.getPackage();
System.out.println(pkg.getName()); // Вывод: java.lang

int modifiers = strClass.getModifiers();
System.out.println(Modifier.isPublic(modifiers)); // Вывод: true
System.out.println(Modifier.isFinal(modifiers));  // Вывод: true

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = String.class;
        System.out.println("Class Name: " + clazz.getName());
        System.out.println("Simple Name: " + clazz.getSimpleName());
        System.out.println("Package: " + clazz.getPackage().getName());
        System.out.println("Is Public: " + Modifier.isPublic(clazz.getModifiers()));
    }
}

public class Task050225 {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int z = 15;

        int result = (x > y) ? (x > z ? x : z) : (y > z ? y : z);
        System.out.println(result);
    }
}

Class<?> arrayListClass = ArrayList.class;
Class<?> superClass = arrayListClass.getSuperclass();
System.out.println(superClass.getName()); // Вывод: java.util.AbstractList

Class<?>[] interfaces = arrayListClass.getInterfaces();
for (Class<?> iface : interfaces) {
    System.out.println(iface.getName()); // Вывод: java.util.List, java.util.RandomAccess и т.д.
}

@Deprecated
class MyClass {}

Class<?> myClass = MyClass.class;
Annotation[] annotations = myClass.getAnnotations();
for (Annotation ann : annotations) {
    System.out.println(ann.annotationType().getName()); // Вывод: java.lang.Deprecated
}

Annotation[] declaredAnnotations = myClass.getDeclaredAnnotations();
for (Annotation ann : declaredAnnotations) {
    System.out.println(ann.annotationType().getName()); // Вывод: java.lang.Deprecated
}

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = ArrayList.class;
        
        // Суперкласс
        Class<?> superClass = clazz.getSuperclass();
        System.out.println("Superclass: " + superClass.getName());
        
        // Интерфейсы
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> iface : interfaces) {
            System.out.println("Interface: " + iface.getName());
        }
        
        // Аннотации
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation ann : annotations) {
            System.out.println("Annotation: " + ann.annotationType().getName());
        }
    }
}

import java.lang.reflect.Field;

class Parent {
    public String parentField = "Parent Field";
}

class Child extends Parent {
    public String childField = "Child Field";
    private int privateField = 42;
}

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = Child.class;
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println("Field: " + field.getName()); // Вывод: parentField, childField
        }
    }
}

Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields) {
    System.out.println("Declared Field: " + field.getName()); // Вывод: childField, privateField
}

Field privateField = clazz.getDeclaredField("privateField");
int modifiers = privateField.getModifiers();
System.out.println("Is Private: " + Modifier.isPrivate(modifiers)); // Вывод: true
System.out.println("Is Static: " + Modifier.isStatic(modifiers));  // Вывод: false

Class<?> fieldType = privateField.getType();
System.out.println("Field Type: " + fieldType.getName()); // Вывод: int

public class Task060225 {
    public static void main(String[] args) {
        String s = "hello";
        String sub = s.substring(1, 3);
        System.out.println(sub);
    }
}