Notes to Java core technology Volume 1 Chapter 6 interface and internal classes anonymous internal classes and static internal classes

6.4.6 anonymous inner class

Suppose that when using variables, you can directly new a new object without naming it again. This local inner class that cannot afford the name of a class is called an anonymous inner class.

The writing method is: new interface name () {overwrite method () {method content}}

public class Main {

    public static void main(String[] args) throws CloneNotSupportedException, InterruptedException {
        Main solution = new Main();
        Date d = new Date();
       
        ActionListener tp = new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("the time is"+d);
                Toolkit.getDefaultToolkit().beep();
            }
        };
        Timer t = new Timer(10000,tp);
        t.start();
        JOptionPane.showMessageDialog(null,"Quit program?");
        System.exit(0);
    }
}

Objects created anonymously are usually put directly into the pass parameter, such as:

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException, InterruptedException {
        Main solution = new Main();
        Date d = new Date();

        Timer t = new Timer(10000,new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("the time is"+d);
                Toolkit.getDefaultToolkit().beep();
            }
        });
        t.start();
        JOptionPane.showMessageDialog(null,"Quit program?");
        System.exit(0);
    }
}

6.4.7 static internal class

Static inner class is to add a static to the inner class of the member. It means that the external class needs to reference the internal class variables or methods, and the internal class does not need to reference the external class variables and methods. Most of the internal classes used at ordinary times basically use static internal classes. For example, if there are multiple goods in an order, we will ask what goods are in the order, but if there is no order, do these goods still exist? It still exists. It can be found that whether the order exists or not, its associated internal class still exists. At this time, the method of static internal class can be selected.

import java.util.ArrayList;
import java.util.List;

public class Order {
    private List<Product> products;
    private int id;
    public Order(int id){
        this.id = id;
        products = new ArrayList<>();
    }
    public void addProduct(Product product){
        products.add(product);
    }

    public List<Product> getProductList(){
        return products;
    }

    public static class Product{
        String name;
        int cnt;
        public Product(String name, int cnt){
            this.name = name;
            this.cnt = cnt;
        }

        @Override
        public String toString() {
            return "Product{" +
                    "name='" + name + '\'' +
                    ", cnt=" + cnt +
                    '}';
        }
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException, InterruptedException {
        Main solution = new Main();
        Order.Product p = new Order.Product("Bean curd",1);
        Order.Product p2 = new Order.Product("Shallot",5);
        Order o = new Order(1);
        o.addProduct(p);
        o.addProduct(p2);
        System.out.println(o.getProductList());
    }
}