使用内部类和闭包

内部类

　　在Java中创建类时，也就定义了类的属性和行为。属性是用来存放数据的类和实例变量，行为是使用存放的数据来执行任务的方法。

　　类中还可以包含由属性和行为组成的其他东西：内部类。

　　内部类是包含在一个封闭类中的辅助类。

　　在Java中包含内部类的原因有3个。

　　1.当辅助类只能被另外一个类使用时，就可以在那个类中定义辅助类。

　　2.这可以使得辅助类能够访问private 方法和变量；而这些方法和变量是不能被单独的类所访问的。

　　3.当在另一个类中使用辅助类时，可以让辅助类距离类足够近。

　　与其他类一样，可以使用class关键字来创建内部类，但是它是在所属类的内部声明的。通常类的内部是放置类和实例变量的地方。

　　内部类的结构与其他类一样，但是位置是在封闭类的“{” 和“}”内部。创建内部类需要外部类的对象，然后这个外部类对象调用new操作符。

import java.net.*;

public class Catalog {
    class HomePage {
        String owner;
        URL address;
        String category = "none";
        
        public HomePage(String inOwner, String inAddress)
            throws MalformedURLException {
            owner = inOwner;
            address = new URL(inAddress);
        }
        
        public HomePage(String inOwner, String inAddress, String inCategory) 
            throws MalformedURLException {
                this(inOwner, inAddress);
                category = inCategory;
        }
        
    }
    public Catalog() {
        Catalog.HomePage[] catalog = new Catalog.HomePage[5];
        try {
            catalog[0] = new HomePage("Mark Evanier",
                    "http://www.newsfromme.com", "commic books");
            catalog[1] = new HomePage("Jeff Rients",
                    "http://jrients.blogspot.com", "gaming");
            catalog[2] = new HomePage("Rogers Cadenhead",
                    "http://workbench.cadenhead.org", "programming");
            catalog[3] = new HomePage("Juan Cole", 
                    "http://www.juancole.com", "politics");
            catalog[4] = new HomePage("Rafe Colburn",
                    "http://www.rc3.org");
            for (int i = 0; i < catalog.length; i++) {
                System.out.println(catalog[i].owner + ": " + 
                        catalog[i].address + " -- " + 
                        catalog[i].category);
            }
        } catch (MalformedURLException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
    
    public static void main(String[] arguments) {
        new Catalog();
    }
}

匿名内部类

　在Java编程中经常执行的一个任务是创建一个只使用一次使用一次且用途简单的类。一种特殊的内部类可以完美地实现该目的。

　 匿名内部类是没有名字，而且声明与创建是在同时进行的类。

　要使用匿名内部类，要使用new关键字以及“{”和“}”内部的类定义来替换对对象的引用，其中new关键字会调用构造函数。

　匿名内部类可以执行正常助手做不到的事情：该问keyLabel实例变量。该变量属于KeyViewer类。内部类可以访问所属类的方法和变量。

　　匿名内部类不能定义构告函数，因此相较于非匿名的内部类，其限制更多。

　　匿名内部类是Java语言中的一个复杂特性，在查看程序的源代码时会很难理解，但是它可以让程序更为简洁，有经验的Java程序员会经常使用匿名内部类。

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

public class NewKeyViewer extends JFrame {
    JTextField keyText = new JTextField(80);
    JLabel keyLabel = new JLabel("Press any key in the text field.");
    
    public NewKeyViewer() {
        super("NewKeyViewer");
        setLookAndFeel();
        setSize(350, 100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        keyText.addKeyListener(new KeyAdapter() {
            public void keyTyped(KeyEvent input) {
                char key = input.getKeyChar();
                keyLabel.setText("You pressed " + key);
            }
        });
        
        BorderLayout bord = new BorderLayout();
        setLayout(bord);
        add(keyLabel, BorderLayout.NORTH);
        add(keyText, BorderLayout.CENTER);
        setVisible(true);
    }
    private void setLookAndFeel() {
        try {
            UIManager.setLookAndFeel(
                    "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch (Exception exc) {
            
        }
    }
    
    public static void main(String[] arguments) {
        new NewKeyViewer();
    }
}

闭包

　　闭包也称为lambda表达式，在其他条件满足的情况下，它是可以只使用一个 -> 操作符创建带有单个参数的对象。

　　Runnable runner = () - > {System.out.println("Run!");};

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class NewColorFrame extends JFrame {
    JButton red, green, blue;
    
    public NewColorFrame() {
        super("NewColorFrame");
        setLookAndFeel();
        setSize(322, 122);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        FlowLayout flo = new FlowLayout();
        setLayout(flo);
        red = new JButton("Red");
        add(red);
        green = new JButton("Green");
        add(green);
        blue = new JButton("Blue");
        add(blue);
        //begin lambda expression
        ActionListener act = (event) -> {
                if (event.getSource() == red) {
                    getContentPane().setBackground(Color.RED);
                }
                if (event.getSource() == green) {
                    getContentPane().setBackground(Color.GREEN);
                }
                if (event.getSource() == blue) {
                    getContentPane().setBackground(Color.BLUE);
                }
        };
        //end lambda expression
        red.addActionListener(act);
        green.addActionListener(act);
        blue.addActionListener(act);
        setVisible(true);
    }
    
    private void setLookAndFeel() {
        try {
            UIManager.setLookAndFeel(
                    "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch (Exception e) {
            //ignore error
        }
    }
    
    public static void main(String[] arguments) {
        new NewColorFrame();
    }
}

　　lambda表达式支持函数式编程。函数式编程是软件设计中的一种方法，直到现在才开始被Java程序员使用。

　　lambda表达式的一个效果是缩短了代码。一个表达式就可以创建一个对象并实现一个接口。这一新特性可以让代码更简洁