Что можно определить внутри класса

Что можно определить внутри класса

Внутри класса можно определить множество различных элементов. Это важное понимание структуры класса в Java и того, что считается вложенным членом класса.

1. Переменные (полях / Fields)

Переменные хранят состояние объекта:

public class Container {
    // Instance variables (члены объекта)
    private String name;
    protected int age;
    public double salary;
    
    // Static variables (переменные класса)
    public static final String VERSION = "1.0";
    private static int instanceCount = 0;
    
    // Различные типы данных
    private List<String> items;
    private Map<String, Integer> data;
    private int[] numbers;
    private User[] users;
    
    // Инициализаторы
    private String initialized = "value";
}

2. Конструкторы

Методы инициализации объекта:

public class Person {
    private String name;
    private int age;
    
    // Конструктор 1
    public Person() {
        this("Unknown", 0);
    }
    
    // Конструктор 2 с параметрами
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Можно вызвать другой конструктор через this()
    public Person(String name) {
        this(name, 18);
    }
}

3. Методы (Methods)

Операции над объектом:

public class Calculator {
    // Instance методы
    public int add(int a, int b) {
        return a + b;
    }
    
    // Методы могут быть разных уровней доступа
    private void helperMethod() {
        // Приватный вспомогательный метод
    }
    
    protected void inheritableMethod() {
        // Доступен для подклассов
    }
    
    // Static методы
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    // Методы с разными return типами
    public void noReturn() { }
    public int returnInt() { return 42; }
    public String returnString() { return "hello"; }
    public List<?> returnList() { return new ArrayList<>(); }
    
    // Методы с разным количеством параметров
    public void noParams() { }
    public void oneParam(int x) { }
    public void manyParams(int a, String b, double c) { }
    
    // Varargs
    public void variableArgs(int... numbers) {
        for (int num : numbers) {
            System.out.println(num);
        }
    }
}

4. Вложенные классы (Nested Classes)

Классы определённые внутри других классов:

public class OuterClass {
    
    // Статический вложенный класс
    public static class StaticNestedClass {
        public void display() {
            System.out.println("Static nested class");
        }
    }
    
    // Внутренний класс (non-static nested class)
    public class InnerClass {
        // Имеет доступ к членам внешнего класса
        public void showOuter() {
            System.out.println("Outer: " + outerField);
        }
    }
    
    // Локальный класс (внутри метода)
    public void createLocalClass() {
        class LocalClass {
            void greet() {
                System.out.println("Hello from local class");
            }
        }
        LocalClass local = new LocalClass();
        local.greet();
    }
    
    // Анонимный класс
    public Runnable createAnonymous() {
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous class");
            }
        };
    }
    
    private String outerField = "outer";
}

5. Интерфейсы (Interfaces)

Можно определить вложенный интерфейс:

public class DataProcessor {
    // Вложенный интерфейс
    public interface Processor {
        void process(String data);
    }
    
    // Использование вложенного интерфейса
    private Processor processor;
    
    public void setProcessor(Processor proc) {
        this.processor = proc;
    }
    
    // Реализация вложенного интерфейса анонимным классом
    public void setupDefault() {
        this.processor = new Processor() {
            @Override
            public void process(String data) {
                System.out.println("Processing: " + data);
            }
        };
    }
}

6. Enums (Перечисления)

Вложенные enum типы:

public class Status {
    // Вложенный enum
    public enum State {
        PENDING,
        ACTIVE,
        COMPLETED,
        FAILED
    }
    
    // Enum с методами
    public enum Priority {
        LOW(1),
        MEDIUM(2),
        HIGH(3);
        
        private final int level;
        
        Priority(int level) {
            this.level = level;
        }
        
        public int getLevel() {
            return level;
        }
    }
    
    private State currentState = State.PENDING;
    private Priority taskPriority = Priority.MEDIUM;
}

7. Инициализаторы (Initializers)

Блоки кода для инициализации:

public class Database {
    // Instance инициализатор
    {
        System.out.println("Instance initializer");
        connect();
    }
    
    // Static инициализатор
    static {
        System.out.println("Static initializer");
        loadDriver();
    }
    
    private void connect() {
        System.out.println("Connecting...");
    }
    
    private static void loadDriver() {
        System.out.println("Loading driver...");
    }
}

8. Аннотации

Можно использовать различные аннотации:

public class AnnotatedClass {
    @Deprecated
    public void oldMethod() { }
    
    @Override
    public String toString() {
        return super.toString();
    }
    
    @SuppressWarnings("unchecked")
    public List getRawList() {
        return new ArrayList();
    }
    
    @FunctionalInterface
    public interface MyFunctional {
        void execute();
    }
}

9. Generic типы (Type Parameters)

public class Container<T> {
    // Можно использовать generic type параметр
    private T value;
    
    public void setValue(T val) {
        this.value = val;
    }
    
    public T getValue() {
        return value;
    }
    
    // Даже вложенные generics
    public class InnerGeneric<U> {
        public void process(T outer, U inner) {
            System.out.println("T: " + outer + ", U: " + inner);
        }
    }
}

10. Экземплярные блоки инициализации (Instance blocks)

public class ComplexInitialization {
    private List<String> items;
    
    // Инициализация в блоке
    {
        items = new ArrayList<>();
        items.add("initial");
        System.out.println("Initializing list");
    }
    
    // Конструктор может дополнить инициализацию
    public ComplexInitialization(String... args) {
        items.addAll(Arrays.asList(args));
    }
}

Порядок инициализации элементов класса

public class InitializationOrder {
    // 1. Static переменные инициализируются первыми
    static {
        System.out.println("1. Static initializer");
    }
    
    static String staticField = "static";
    
    // 2. Instance переменные инициализируются при создании объекта
    String instanceField = "instance";
    
    // 3. Instance инициализатор
    {
        System.out.println("2. Instance initializer");
    }
    
    // 4. Конструктор вызывается последним
    public InitializationOrder() {
        System.out.println("3. Constructor");
    }
}

Полный пример класса со всеми элементами

public class CompleteExample<T> {
    // Статические переменные
    private static int totalCount = 0;
    
    // Instance переменные
    private T value;
    private String name;
    
    // Вложенный enum
    public enum Type {
        TYPE_A, TYPE_B
    }
    
    // Вложенный интерфейс
    public interface Handler {
        void handle(T value);
    }
    
    // Static инициализатор
    static {
        System.out.println("Static init");
    }
    
    // Instance инициализатор
    {
        totalCount++;
    }
    
    // Конструктор
    public CompleteExample(T value, String name) {
        this.value = value;
        this.name = name;
    }
    
    // Методы
    public T getValue() {
        return value;
    }
    
    public static int getTotalCount() {
        return totalCount;
    }
    
    // Вложенный статический класс
    public static class Builder<T> {
        private T value;
        private String name;
        
        public CompleteExample<T> build() {
            return new CompleteExample<>(value, name);
        }
    }
}

Резюме

Внутри класса можно определить:

1. Переменные: instance и static
2. Конструкторы: несколько перегруженных
3. Методы: instance и static
4. Вложенные классы: статические и обычные
5. Интерфейсы: вложенные интерфейсы
6. Enums: перечисления
7. Инициализаторы: static и instance блоки
8. Аннотации: использование и определение
9. Generic типы: type parameters
10. Локальные и анонимные классы: в методах

Это делает Java класс очень гибким и мощным инструментом для структурирования кода.