3、（主动抛出异常）编写一个 Java 程序，在程序中定义一个异常类，在 main ()方法中使用 throw 语句抛出异常；4、（泛型类定义与方法的调用）编写一个 Java 程序，定义泛型类和泛型类的方法，然后创建一个泛型类对象，调用泛型类对象输出相应的结果； 5、（内部类）编写一个 Java 程序，要求在程序中定义一个 School 类，在 School 类中定义一个内部类 Student ，分别创建这两个类的对象，访问各个对象中的方法，输出各种结果； 6、( Lambda 表达式）编写一个 Java 程序，用 Lambda 表达式实现接口中的方法

3. 主动抛出异常

下面是一个简单的示例代码，定义了一个自定义异常类 `MyException`，在 `main()` 方法中使用 `throw` 关键字抛出异常：

public class ExceptionDemo {

    public static void main(String[] args) {
        try {
            throw new MyException("抛出自定义异常");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }

    static class MyException extends Exception {
        public MyException(String message) {
            super(message);
        }
    }
}

4. 泛型类定义与方法的调用

下面是一个简单的泛型类 `MyGenericClass` 的示例代码，包含了一个泛型方法 `printArray()`，可以输出数组中的元素：

public class GenericDemo {
    public static void main(String[] args) {
        Integer[] intArray = { 1, 2, 3 };
        String[] strArray = { "a", "b", "c" };

        MyGenericClass<Integer> intClass = new MyGenericClass<>(intArray);
        MyGenericClass<String> strClass = new MyGenericClass<>(strArray);

        intClass.printArray();
        strClass.printArray();
    }
}

class MyGenericClass<T> {
    private T[] array;

    public MyGenericClass(T[] array) {
        this.array = array;
    }

    public void printArray() {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在 `main()` 方法中创建了一个 `MyGenericClass` 的泛型对象，分别传入了 `Integer` 和 `String` 类型的数组，并调用了泛型方法 `printArray()`，输出了数组中的元素。

5. 内部类

下面是一个简单的示例代码，定义了一个 `School` 类和一个 `Student` 内部类，创建了一个 `School` 对象和一个 `Student` 对象，并访问了它们的方法：

public class InnerClassDemo {

    public static void main(String[] args) {
        School school = new School();
        School.Student student = school.new Student("小明");
        student.study();
    }

    static class School {
        class Student {
            private String name;

            public Student(String name) {
                this.name = name;
            }

            public void study() {
                System.out.println(name + "在学习");
            }
        }
    }
}

在 `main()` 方法中创建了一个 `School` 对象和一个 `Student` 对象，并调用了 `Student` 内部类中的 `study()` 方法，输出了 `小明在学习`。

6. Lambda 表达式

下面是一个简单的示例代码，定义了一个接口 `MyInterface`，并使用 Lambda 表达式实现了它的方法：

public class LambdaDemo {

    public static void main(String[] args) {
        MyInterface myInterface = (x, y) -> x + y;
        System.out.println(myInterface.add(1, 2));
    }

    interface MyInterface {
        int add(int x, int y);
    }
}

在 `main()` 方法中使用 Lambda 表达式实现了 `MyInterface` 接口的 `add()` 方法，输出了 `3`。