Java内部类

2021-09-14 23:00:35 阅读：167 来源： 互联网

标签：Java 内部 java ActionListener beep new import public

1、使用内部类访问对象状态

类：

package innerClass;

import timer.TimePrinter;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

public class TalkingClock {
    private int interval;
    private boolean beep;

    public TalkingClock(int interval, boolean beep) {
        this.interval = interval;
        this.beep = beep;
    }

    public void start() {
        ActionListener listener = new TimePrinter();
        Timer timer = new Timer(interval, listener);
        timer.start();
    }

    public class TimerPrinter implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            System.out.println("At the tone, the time is " + new Date());
            //内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域
            if (beep)
                Toolkit.getDefaultToolkit().beep();
        }
    }
}

测试：

package innerClass;

import javax.swing.*;

public class InnerClassTest {
    public static void main(String[] args) {
        TalkingClock talkingClock = new TalkingClock(1000, true);
        talkingClock.start();

        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

2、内部类的特殊语法规则

使用外围类引用的正规语法：OuterClass.this
例：if (TalkingClock.this.beep)
编写内部对象构造器：outerObject.new InnerClass(construction parameters)
例：ActionListener listener = this.new TimerPrinter();
在外围类的作用域之外引用内部类：OuterClass.InnerClass
内部类中声明的所有静态域都必须是final；

3、局部内部类

package innerClass;

import timer.TimePrinter;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

public class TalkingClock {
    private int interval;
    private boolean beep;

    public TalkingClock(int interval, boolean beep) {
        this.interval = interval;
        this.beep = beep;
    }

    public void start() {
    	//局部类不能用public或private访问说明符声明。它的作用域被限定在这个局部类的块中。
        class TimerPrinter implements ActionListener {
            public void actionPerformed(ActionEvent actionEvent) {
                System.out.println("At the tone, the time is " + new Date());
                //内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域
                if (beep)
                    Toolkit.getDefaultToolkit().beep();
            }
        }
        ActionListener listener = new TimerPrinter();
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

4、由外部方法访问变量

package innerClass;

import timer.TimePrinter;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

public class TalkingClock {

    public void start(int interval, boolean beep) {
        //局部类不仅可以访问包含它们的外部类，还可以访问局部变量（局部变量必须为final）
        class TimerPrinter implements ActionListener {
            public void actionPerformed(ActionEvent actionEvent) {
                System.out.println("At the tone, the time is " + new Date());
                //内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域
                if (beep)
                    Toolkit.getDefaultToolkit().beep();
            }
        }
        ActionListener listener = new TimerPrinter();
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

5、匿名内部类

package anonymousInnerClass;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.Timer;

public class TalkingClock {

    public void start(int interval, boolean beep) {
    	//创建一个实现ActionListener接口的类的新对象，需要实现的方法actionPerforme定义在括号{}内
        //匿名类不能有构造器，构造器参数传递给超类构造器
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("At the tone, the time is " + new Date());
                if (beep) Toolkit.getDefaultToolkit().beep();
            }
        };
        Timer timer = new Timer(interval, listener);
        timer.start();
    }
}

6、静态内部类

类：

package staticInnerClass;

public class ArrayAlg {
    //内部类不需要访问外部类对象的时候，应该使用静态内部类
    //静态内部类可以有静态域和方法
    //声明在接口中的内部类自动成为static和public
    public static class Pair {
        private double first;
        private double second;

        public Pair(double f, double s) {
            first = f;
            second = s;
        }

        public double getFirst() {
            return first;
        }

        public double getSecond() {
            return second;
        }
    }
    //一个静态方法
    public static Pair minmax(double[] values) {
        double min = Double.POSITIVE_INFINITY;
        double max = Double.NEGATIVE_INFINITY;
        for (double v: values
             ) {
            if (min > v)
                min = v;
            if (max < v)
                max = v;
        }
        return new Pair(min, max);
    }
}

测试：

package staticInnerClass;

public class StaticInnerClassTest {
    public static void main(String[] args) {
        double[] d = new double[20];
        for (int i = 0; i < d.length; i++){
            d[i] = 100 * Math.random();
        }
        ArrayAlg.Pair pair = ArrayAlg.minmax(d);
        System.out.println("min = " + pair.getFirst());
        System.out.println("max = " + pair.getSecond());
    }
}

标签：Java,内部,java,ActionListener,beep,new,import,public
来源： https://blog.csdn.net/shyshyshyshy1/article/details/120284168

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。