import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
 * 1.新建一个LoginListener事件处理类，
 * 该类实现MouseListener鼠标事件接口，实现接口中的抽象方法。
 * 2.定义四个变量，在按下和释放方法中获取按下和释放的坐标值。
    3.定义Graphics画笔画布类的对象，调用绘制图形的方法来画图。
        我们的组件是画出来的，那么你要在哪一个组件上画图形，那你的画笔画布对象就从这个组件上获取。
    4.实例化DrawListener事件处理类的对象，对象名dl
    5.给事件源窗体对象添加addMouseListener()鼠标监听方法，指定事件处理类对象dl.

 */
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.Random;

import javax.swing.JButton;

//F3键可以看到代码
public class LoginListener implements MouseListener, ActionListener, MouseMotionListener {
    // private int c;
    int x, y;
    private int x1, y1, x2, y2, x3, y3;// x4, y4;
    int a1, a2, a3, a4, b1, b2, b3, b4;
    double X1, X2, Y1, Y2;
    double a, b, c, d, k, f;
    public int sx, sy, ex, ey;// 存储任意多边形的起始点坐标和结束点的坐标
    public int count = 0;// 记录画的是任意多边形的第几条线
    private Color color = Color.BLACK;
    private Random rand = new Random();/*
                                         * 实例化一个随机数类的对象
                                         * 之前是在for循环中定义实例化的rand,增加了时间复杂度和空间复杂度，
                                         * 每次循环都会实例化一个rand变量，所以不要再循环中定义变量；
                                         */
    public String s = "";

    public Shape[] Sh;
    public int i = 0;

    public void setSh(Shape[] sh) {
        Sh = sh;
    }

    Graphics g;// 声明一个画笔画布类的对象名

    private Graphics2D g1;// 声明一个画布类的对象；Graphics2D是Graphics的一个子类。
    BasicStroke S = new BasicStroke(10);
    BasicStroke C = new BasicStroke(1);// 方法一：实例化画笔粗细。设置画笔粗细为1.
    /*
     * 没有用到对象的属性和方法就不用传过去；
     */

    public void SetG(Graphics gra) {
        g = gra;// 把gra给g;
        g1 = (Graphics2D) gra;// 强制转型

        g1.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        // 设置设置画笔抗锯齿，使线条更加平滑。
    }

    /**
     * 当你在事件源上发生鼠标按下动作时执行的方法。
     */

    public void mousePressed(MouseEvent e) {
        // 取得鼠标按下时取得的坐标；
        x1 = e.getX();
        y1 = e.getY();

    }

    /**
     * 当你在事件源上发生鼠标释放动作时执行的方法。
     */
    public void mouseReleased(MouseEvent e) {

        x3 = e.getX();
        y3 = e.getY();

        if (s.equals("直线")) {
            g1.setColor(color);
            g1.setStroke(C);
            g1.drawLine(x1, y1, x3, y3);
            Shape shape = new Shape(x1, y1, x3, y3, Color.black, new BasicStroke(1), "直线");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

        } else if (s.equals("圆")) {
            g1.setColor(color);
            g1.setStroke(C);
            g1.drawOval(x1, y1, x3 - x1, y3 - y1);
            Shape shape = new Shape(x1, y1, x3 - x1, y3 - y1, Color.black, new BasicStroke(1), "圆");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

        } else if (s.equals("立体球")) {
            g1.setColor(color);
            g1.setStroke(C);

            // g1.drawOval(x3, y3, 50, 50);
            for (int c = 50; c > 0; c--) {

                g.fillOval(x3++, y3++, 2 * c, 2 * c); // 使用当前颜色填充外接指定矩形框的椭圆。

                Color col = g.getColor();
                int red = col.getRed();
                int blue = col.getBlue();
                int green = col.getGreen();
                red += 5;
                if (red > 255)
                    red = 255;
                blue += 5;
                if (blue > 255)
                    blue = 255;
                green += 5;
                if (green > 255)
                    green = 255;
                col = new Color(red, green, blue);
                g.setColor(col);

            } // g.setColor(color);
        } else if (s.equals("矩形")) {
            System.out.println("小：" + x1 + "    " + y1);
            g1.setColor(color);
            g1.setStroke(C);
            g1.drawRect(x1, y1, x3 - x1, y3 - y1);
            Shape shape = new Shape(x1, y1, x3 - x1, y3 - y1, Color.black, new BasicStroke(1), "矩形");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

        } else if (s.equals("任意多边形") && count == 0) {// 判断是否画任意多边形的第一条线

            g1.setColor(color);
            g1.setStroke(C);
            g1.drawLine(x1, y1, x3, y3);
            // System.out.println(" x1 "+x1 +" y1 "+y1 +" x3 "+x3 +" y3 "+y3);
            Shape shape = new Shape(x1, y1, x3, y3, Color.black, new BasicStroke(1), "任意多边形");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

            // 存储第一条线的起始点
            sx = x1;
            sy = y1;
            // 存储第一条线的结束点
            ex = x3;
            ey = y3;

            count++;// 表示第一条已经画完了
        }

    }

    /**
     * 当你的鼠标进入到事件源是行时执行的方法。
     */
    public void mouseEntered(MouseEvent e) {

    }

    /**
     * .当你的鼠标离开到事件源是行时执行的方法。
     */
    public void mouseExited(MouseEvent e) {

    }

    /**
     * 当你在事件源上发生鼠标点击动作时执行的方法。（在同一个位置上按下并释放才会执行点击）
     */

    public void mouseClicked(MouseEvent e) {

        x = e.getX();
        y = e.getY();
        // System.out.println(s);
        // System.out.println(color);
        if (s.equals("任意多边形") && count != 0) {// 判断是否已经画完任意多边形的第一条线了
            // 获取点击的坐标值

            g1.setColor(color);
            g1.setStroke(C);
            if (e.getClickCount() == 2) {// 判断是双击，图形要闭合
                // 使用x,y和ex,ey画闭合的第一条线
                // System.out.println(" ex " +ex+" ey "+ ey+" x " +x+" y "+ y);
                g1.drawLine(x, y, ex, ey);

                Shape shape = new Shape(x, y, ex, ey, Color.black, new BasicStroke(1), "任意多边形");
                Sh[i++] = shape;
                if (i == 10000) {
                    i = 0;
                }

                // 使用x,y和sx,sy画闭合图形的最后 一条线

                g1.drawLine(sx, sy, x, y);
                // System.
                // System.out.println("sx"+" "+sx +"sy " +sy +" " + x+" "+ y);
                Shape shapes = new Shape(sx, sy, x, y, Color.black, new BasicStroke(1), "任意多边形");
                Sh[i++] = shapes;
                if (i == 10000) {
                    i = 0;
                }
                // 改变count的值，好让下一次又是重新开始新的多边形
                count = 0;
            } else {// 判断不是双击，要接下来的线

                // 根据上一条线的结束点和当前点击的坐标，来绘制直线
                g1.drawLine(ex, ey, x, y);
                // System.out.println(" ex "+ex +" ey "+ ey +" x "+x +" y "+y);
                Shape shape = new Shape(ex, ey, x, y, Color.black, new BasicStroke(1), "任意多边形");
                Sh[i++] = shape;
                if (i == 10000) {
                    i = 0;
                }
                // 将当前这条线的结束赋给ex,ey,作为下一条线的起始点
                ex = x;
                ey = y;

            }

        } else if (s.equals("三角金字塔形")) {

            g1.setColor(color);
            drawsanjiaojinzita();
        }

        else if (s.equals("角")) {

            g1.setColor(color);
            drawjiao();

        } else if (s.equals("手环")) {

            g1.setColor(color);
            drawShouhuang();
        } else if (s.equals("外星飞船形")) {

            g1.setColor(color);
            drawwaixingfeichuang();

        } else if (s.equals("菱形星空")) {

            g1.setColor(color);
            drawlingxingxingkong();

        } else if (s.equals("树形")) {

            g1.setColor(color);
            drawshuxing();

        } else if (s.equals("递归正方形")) {

            g1.setColor(color);
            a1 = 90;
            a2 = 0;
            drawdigui(x1, y1, a1, a2);

        } else if (s.equals("递归三角形")) {

            g1.setColor(color);
            if (count < 3) { // 用变量控制存储四个值；
                g1.drawLine(x, y, x, y);
                if (count == 0) {
                    a1 = x;
                    b1 = y;
                    // System.out.println(a1 + " 1 " + a1);
                } else if (count == 1) {// 存储第二个值B
                    a2 = x;
                    b2 = y;

                } else if (count == 2) {// 存储第三个值C
                    a3 = x;
                    b3 = y;
                    // System.out.println(x3+" 3 "+y3);
                }

                count++;
            } else {
                /*
                 * 先是得到三个点的坐标；然后调用方法；
                 * 在方法中，先画出这个三角形，然后求得三边的三个中点值，然后画出新的三角形，
                 * 这时，要记得转换坐标，因为我们是要在这个三角形外边画三个三角形，而不是接着在它的里面画，
                 * 转换之后又会得到新的三个坐标，然后进行第一递归；
                 * 然后在第一递归回归是，画上旁边的另一个三角形；进行递归；第三次也是如此；
                 * 要在三边都画上所以转换三次坐标就可以了；
                 * 要注意的是：应该注意函数回归时带回来的值；
                 *
                 */
                a4=0;
                
                diguisanjiaoxing( a1,  b1,  a2,  b2, a3, b3, a4);
                count=0;
            }
        }
    }

    @Override // 当鼠标拖动时，在事件源上按下鼠标按键然后拖动鼠标时执行的方法。
    public void mouseDragged(MouseEvent e) {
        x2 = e.getX();
        y2 = e.getY();
        if (s.equals("画笔")) {
            /**
             * 因为在拖动过程当中会不断取点，如果起点固定则画出来的都是在一个点开始的。
             * 以上一个拖动取到的坐标作为下一段直线的起点，从而画出曲线。
             */

            g1.setColor(color);
            g1.setStroke(C);

            g1.drawLine(x1, y1, x2, y2);
            Shape shape = new Shape(x1, y1, x2, y2, Color.black, new BasicStroke(1), "任意多边形");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

            x1 = x2;// 转换坐标。
            y1 = y2;

        }
        if (s.equals("刷子")) {

            g1.setColor(color);
            g1.setStroke(S);// 要进行转换画笔，再画；设置线条的粗细。

            g1.drawLine(x1, y1, x2, y2);
            Shape shape = new Shape(x1, y1, x2, y2, Color.black, new BasicStroke(10), "刷子");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }

            x1 = x2;// 转换坐标。
            y1 = y2;

        }
        if (s.equals("橡皮擦")) {
            g1.setStroke(S);
            g1.setColor(Color.WHITE); // 设置线条的颜色为白色来绘制橡皮擦。
            g1.drawLine(x1, y1, x2, y2);
            Shape shape = new Shape(x1, y1, x2, y2, Color.WHITE, new BasicStroke(10), "橡皮擦");
            Sh[i++] = shape;
            if (i == 10000) {
                i = 0;
            }
            x1 = x2;// 转换坐标。
            y1 = y2;
            // g1.setColor(Color.black);// 在画完之后转换回一般的格式就可以不用在每个都设置。粗细也是。
            // g1.setStroke(new BasicStroke(1));// 设置粗细法二。

        }
        if (s.equals("喷枪")) {
            g1.setStroke(C);

            g1.setColor(color);
            int size = rand.nextInt(50) + 20;// 随机决定要画的点数，size的范围在20到69之间。没有“+20”时，只有0到49之间
            for (int i = 0; i < size; i++) {
                int x = rand.nextInt(8);// 在0到7之间随机取点。
                int y = rand.nextInt(8);
                g1.drawLine(x2 + x, y2 + y, x2 + x, y2 + y);// 有随机数来改变坐标，在X2，Y2附件画点。

                Shape shape = new Shape(x2 + x, y2 + y, x2 + x, y2 + y, Color.black, new BasicStroke(1), "喷枪");
                Sh[this.i++] = shape;
                if (this.i == 10000) {
                    this.i = 0;// 注意区分变量；
                }
            }

            // g1.setColor(Color.black);
            // g1.setStroke(C);

        }

    }

    public void drawsanjiaojinzita() {
        g1.setColor(Color.BLUE);
        g1.setStroke(C);

        if (count < 4) { // 用变量控制存储四个值；
            g1.drawLine(x, y, x, y);

            /*
             * 之前是写的四个并列的if语句，所以每执行一次都会调用所有的if语句，同样的增加了程序运行的时间，增加了时间复杂度；
             * 所有要加上else if；来减少程序运行的时间。所有学会减少不必要的语句；
             */
            if (count == 0) {// 存储第一个值A
                a1 = x;// 之前是写的x1=x；这样增加了空间复杂度，时间复杂度；
                b1 = y;// 改成x1=e.getY()；可以少定义一个变量；减少占用的空间；
                // System.out.println(a1 + " 1 " + a1);
            } else if (count == 1) {// 存储第二个值B
                a2 = x;
                b2 = y;
                // System.out.println(a2 + " 2 " + a2);
            } else if (count == 2) {// 存储第三个值C
                a3 = x;
                b3 = y;
                // System.out.println(x3+" 3 "+y3);
            } else if (count == 3) {// 存储第四个值P；
                a4 = x;
                b4 = y;
            }

            count++;
        }

        if (count >= 4) {
            for (int c = 0; c <= 10000; c++) {
                int s = rand.nextInt(3);// 这个不能放在for循环外边；随机数的大小；0到3；取值取0，1，2；
                if (s == 0) {// 当随机数取0时，色子面为A；
                    a4 = (a1 + a4) / 2;
                    b4 = (b1 + b4) / 2;
                } else if (s == 1) {// 当随机数取1时，色子面为B；
                    a4 = (a2 + a4) / 2;
                    b4 = (b2 + b4) / 2;
                } else {// 当随机数取2时，色子面为C。
                    a4 = (a3 + a4) / 2;
                    b4 = (b3 + b4) / 2;
                }

                g1.drawLine(a4, b4, a4, b4);

            }
            count = 0;// count值变为0，然后开始下一个图形。不然只能画一个图形；

        }

    }

    public void drawjiao() {
        double a = -2, b = -2, c = -1.2, d = 2;
        for (int n = 0; n <= 50000; n++) {
            g1.setColor(new Color(0, 128, 255));
            g1.setStroke(C);

            /*
             * 先算出值，然后再来画图； 画图时要注意，因为求出的值很小，所以需要扩大。 而强制转型时应该是求出的值整体转也就是应该加上括号(x2
             * * 100 + 350), int m = (int)x2 * 100 + 350
             * ，不加括号时是，X2转型之后，再乘以100，加上350，
             */
            X2 = (Math.sin(a * Y1) - Math.cos(b * X1));
            Y2 = (Math.sin(c * X1) - Math.cos(d * Y1));
            // int m = (int) (x2 * 100 + 350);(x2 * 100 + 350)整体强制转型；
            // int s = (int) (y2 * 100 + 350);这时是X2乘以100加上350得到的数再进行转型；
            // g.drawLine(m, s, m, s);
            g1.drawLine((int) (X2 * 100 + 300), (int) (Y2 * 100 + 300), (int) (X2 * 100 + 300), (int) (Y2 * 100 + 300));
            // 强制转型时，要注意加上括号，整体转型
            X1 = X2;
            Y1 = Y2;

        }
    }

    public void drawShouhuang() {

        g1.setColor(new Color(0, 255, 64));
        g1.setStroke(C);

        // double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
        a = 1.40;
        b = 1.56;
        c = 1.40;
        d = -6.56;
        for (int n = 0; n <= 60000; n++) {
            X2 = d * Math.sin(a * X1) - Math.sin(b * Y1);
            Y2 = c * Math.cos(a * X1) + Math.cos(b * Y1);
            g1.drawLine((int) (X2 * 50 + 500), (int) (Y2 * 50 + 200), (int) (X2 * 50 + 500), (int) (Y2 * 50 + 200));
            // 乘以的数，控制大小，整体相加改变位置；
            X1 = X2;
            Y1 = Y2;

        }

    }

    public void drawwaixingfeichuang() {
        g1.setColor(new Color(41, 225, 102));
        g1.setStroke(C);

        a = 0.4;
        b = 1;
        c = 0;

        /**
         * signum(double d):返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于
         * 0，则返回 -1.0。 abs(double a):返回 double 值的绝对值。 sqrt(double a):返回正确舍入的
         * double 值的正平方根。
         */

        for (int n = 0; n <= 100000; n++) {
            X2 = Y1 - Math.signum(X1) * Math.sqrt(Math.abs(b * X1 - c));
            Y2 = a - X1;
            g1.drawLine((int) (X2 * 150 + 500), (int) (Y2 * 150 + 200), (int) (X2 * 150 + 500), (int) (Y2 * 150 + 200));
            // 乘以的数，控制大小，整体相加改变位置；
            X1 = X2;
            Y1 = Y2;
        }
    }

    public void drawshuxing() {

        // 1.建立一个for循环，在For循环中用随机数来实现概率；

        g1.setColor(new Color(58, 235, 116));
        g1.setStroke(C);
        for (int i = 0; i < 77000; i++) {

            // 用随机数来实现概率： 能够满足条件的的随机数的点数 除以 所有的随机数 = 本次事件的概率

            int u = rand.nextInt(100);

            if (u < 10) {
                a = 0.0;
                b = 0.0;
                c = 0.0;
                d = 0.16;
                k = 0.0;
                f = 0.0;

            } // 当随机数为0到9时，执行，这时的概率为0.1；
            else if (u < 18) {
                a = 0.2;
                b = -0.26;
                c = 0.23;
                d = 0.22;
                k = 0.0;
                f = 1.6;
                // 当随机数为10到17时，执行，这时的概率为0.08；
            } else if (u < 25) {
                a = -0.15;
                b = 0.28;
                c = 0.26;
                d = 0.24;
                k = 0.0;
                f = 0.44;
                // 当随机数为18到24时，执行，这时的概率为0.08；
            } else {
                a = 0.75;
                b = 0.04;
                c = -0.04;
                d = 0.85;
                k = 0.0;
                f = 1.6;
                // 当随机数为25到99时，执行，这时的概率为0.74；
            }
            X2 = a * X1 + b * Y1 + k;
            Y2 = c * X1 + d * Y1 + f;

            // System.out.println((int)(x2*100+200));
            // System.out.println((int)(y2*100+200));

            g1.drawLine((int) (X2 * 100 + 500), (int) (Y2 * (-50) + 510), (int) (X2 * 100 + 500),
                    (int) (Y2 * (-50) + 510));// 空指针异常指的是g；
            // (int)(y2*(-50)+600);乘以的负数可以改变图形的方向；
            X1 = X2;
            Y1 = Y2;

        }

    }

    public void drawlingxingxingkong() {
        g1.setColor(Color.BLUE);
        g1.setStroke(C);
        int a = 1, b = 4, c = 60;
        // double x1 = 0, y1 = 0, x2 = 0, y2 = 0;

        for (int n = 0; n <= 60000; n++) {
            X2 = Y1 - Math.signum(X1) * Math.sqrt(Math.abs(b * X1 - c));
            Y2 = a - X1;
            g1.drawLine((int) (X2 * 3 + 600), (int) (Y2 * 3 + 400), (int) (X2 * 3 + 600), (int) (Y2 * 3 + 400));// 注意画线的值；
            // 乘以的数，控制大小，整体相加改变位置；该图形的乘数不能太大，最好控制在0-5之间
            X1 = X2;
            Y1 = Y2;
        }

    }

    public void drawdigui(int x1, int y1, int a1, int a2) {
        /*
         * 画一个正方形，改变他的坐标以及大小，来进行递归；现递推画出一个小三角形，在回归的时候再来画其他的（此时只要改变坐标就好）；
         */

        g1.drawRect(x1, y1, a1, a1);
        x1 = x1 - a1;// 改变画的位置，改变大小由当前的图形的大小来进行调整。
        y1 = y1 - a1;
        a1 = a1 / 3;// 改变正方形的大小；长和高
        a2++;
        if (a2 > 5)
            return;// 只要一个就好；
        drawdigui(x1, y1, a1, a2);// 第一次的递归；画的是左上角的第一个正方形；
        x1 = x1 + 4 * a1;// 改变x轴的坐标，大小不变，画一个向右移动的图形；
        drawdigui(x1, y1, a1, a2);
        x1 = x1 + 4 * a1;
        drawdigui(x1, y1, a1, a2);
        y1 = y1 + 4 * a1;// 改变y轴的坐标，大小不变，画一个向下移动的图形；
        drawdigui(x1, y1, a1, a2);
        x1 = x1 - 8 * a1;
        drawdigui(x1, y1, a1, a2);
        y1 = y1 + 4 * a1;
        drawdigui(x1, y1, a1, a2);
        x1 = x1 + 4 * a1;
        drawdigui(x1, y1, a1, a2);
        x1 = x1 + 4 * a1;
        drawdigui(x1, y1, a1, a2);

    }

    public void diguisanjiaoxing(int a1, int b1, int a2, int b2, int a3, int b3,int a4) {
        int c1,d1,c2,d2,c3,d3;
        g1.drawLine(a1, b1, a2, b2);
        g1.drawLine(a2, b2, a3, b3);
        g1.drawLine(a1, b1, a3, b3);
        //求出中点坐标；来画三角形；
        c1=(a2+a3)/2;
        d1=(b2+b3)/2;
        c2=(a1+a3)/2;
        d2=(b1+b3)/2;
        c3=(a2+a1)/2;
        d3=(b2+b1)/2;
        System.out.println(c1 + "    " + d1 + "    " + c2 + "    " + d2 + "    " + c3 + "    " + d3);
        g1.drawLine(c1, d1, c2, d2);
        g1.drawLine(c2, d2, c3, d3);
        g1.drawLine(c1, d1, c3, d3); 
        //转换坐标求得新三个值来画；
        a3=c3;
        b3=d3;
        a1=c1;
        b1=d1;
        a4++;
        if(a4>6)return;
        diguisanjiaoxing( a1,  b1,  a2,  b2, a3, b3,a4);
        a3=a1*2-a2;
        b3=b1*2-b2;//在回归的基础上求得新的坐标；注意带回来的值；
        a2=c2;
        b2=d2;
        diguisanjiaoxing( a1,  b1,  a2,  b2, a3, b3,a4);
        a1=a2*2-a3;
        b1=b2*2-b3;
        a3=c3;
        b3=d3;
        diguisanjiaoxing( a1,  b1,  a2,  b2, a3, b3,a4);
        
    }

    public void actionPerformed(ActionEvent e) {
        // 得到按钮上的文字；
        if (e.getActionCommand().equals("")) {
            JButton but = (JButton) e.getSource();// getSource():最初发生 Event 的对象。
            color = but.getBackground();
        } else {
            s = e.getActionCommand();
        }
        // System.out.println(s);
        // System.out.println(color);
        // getActionCommand()的方法是ActionEvent的，也就是e的。

    }

    @Override
    /*
     * 当在事件源上移动鼠标时执行的方法。
     */
    public void mouseMoved(MouseEvent e) {

    }

}

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 定义一个画图界面类，该类继承自JFrame窗体类.
 */
public class DrawFrame extends JFrame {
    /**
     * 程序入口主函数
     */
    public Shape[] Sh = new Shape[10000];// 两个方法都要用到这个属性时，属性不能定义在一个方法中；应该定义在一个类里面；
    // (刚刚是定义在了public void initUN(){}方法中；但是在paint方法中用的时候就不能用了；)

    public static void main(String[] args) {
        // 实例化窗体类的对象，调用初始化界面的方法
        DrawFrame dl = new DrawFrame();
        dl.initUN();
        // dl.setBackground(Color.WHITE);这个是错误的不能改变窗体的颜色，只能改变组件的颜色。
    }

    public void initUN() {
        setTitle("简单画图");
        setSize(1300, 700);
        setDefaultCloseOperation(3);
        setLocationRelativeTo(null);
        setLayout(new BorderLayout());//设置窗体为的布局方式边框布局（边框布局是把容器分为上北下南左西右东中间五部分。）


        /*
         * //实例化一个流失布局类的对象，布局类是针对容器的，容器上要填多个组件，那么必须要设置排列对齐方式；
         * java.awt.FlowLayout fl=new java.awt.FlowLayout();
         * jf.setLayout(fl);//设置窗体的布局方式为流式布局 //定义一个ImageIcon类，该类用来读取一个磁盘的图片文文件。
         */

        LoginListener dn = new LoginListener();
        //getContentPane().setBackground(Color.WHITE);// getContenPane为 改变窗口的颜色。
    //*******************设置窗体北边的部分***********************************/
        JPanel northPanel = new JPanel();//创建具有双缓冲和流布局的新 JPanel。 
        //利用数组存储值，再添加JButton，简化了代码
        String[] jbu = { "直线", "矩形", "圆", "任意多边形", "画笔", "刷子", "橡皮擦", "喷枪", "三角金字塔形", "角", "手环", "外星飞船形", "菱形星空",
                "树形" ,"立体球","递归正方形","递归三角形"};
        for (int i = 0; i < jbu.length; i++) {
            ImageIcon ima = new ImageIcon("E:\\hesi\\LoginDemo\\bin\\HuaTu\\" + jbu[i] + ".jpg");
          //  ImageIcon ima = new ImageIcon(this.getClass().getResource(jbu[i] + ".png"));//这个命令是把java文件和图片放在一起。避免图片消失。
            JButton but1 = new JButton(ima);// 这个是加载图片；
            but1.setPreferredSize(new Dimension(80, 80));// 设置按钮大小；
            but1.setActionCommand(jbu[i]);// 设置按钮所触发的动作命令字符串。

        //    JButton but1 = new JButton(jbu[i]);
            //but1.setPreferredSize(new Dimension(70,50));
            but1.setBackground(Color.pink);
            //this.add(but1);//错误，不应该加到窗体上；
            but1.addActionListener(dn);
            northPanel.add(but1);
        }

        this.add(northPanel, BorderLayout.NORTH);
        northPanel.setPreferredSize(new Dimension(160,160));//设置边框的大小；
           //*******************设置窗体中间的部分***********************************/
        JPanel centerPanel = new JPanel() {
            
            public void paint(Graphics g) {
                super.paint(g);// super表示调用父类中的paint方法。
                
                /*
                 * 输出数组中的值；然后画出图形；
                 */
        
                for (int i = 0; i < 10000; i++) {
                    Shape shape = Sh[i];

                    if (null != shape) {
                        
                        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_ON);
                        // 这个变量不用存，直接设置就可以了；
                        // 设置设置画笔抗锯齿，使线条更加平滑。

                        g.setColor(shape.color);
                        ((Graphics2D) g).setStroke(shape.stroke);// 如果之前画的时候没有设置这个粗细，那么在调用这里的这个就是空的；
                    //    System.out.println(shape.type);
                        //System.out.println("  x1   "+shape.x1 +"  y1   "+shape.y1   +"   x2   "+shape.x2   +"   y2   "+shape.y2);
                        if (shape.type.equals("直线") || shape.type.equals("任意多边形") || shape.type.equals("画笔")
                                || shape.type.equals("刷子") || shape.type.equals("喷枪") || shape.type.equals("橡皮擦")) {
                            g.drawLine(shape.x1, shape.y1, shape.x2, shape.y2);
                        } else if (shape.type.equals("圆")) {
                            g.drawOval(shape.x1, shape.y1, shape.x2, shape.y2);
                        } else if (shape.type.equals("矩形")) {
                            g.drawRect(shape.x1, shape.y1, shape.x2, shape.y2);
                        }

                    } else {
                        break;
                    }

                }

            }
        };
          
        centerPanel.setBackground(Color.WHITE);
        this.add(centerPanel, BorderLayout.CENTER);//添加到CENTER布局中去；
         //*******************设置窗体南边的部分***********************************/
        JPanel southPanel = new JPanel();
        //利用数组存储值，再添加JButton，简化了代码
        Color[] Col = { Color.blue, Color.GREEN, Color.PINK, Color.ORANGE, Color.RED, Color.YELLOW, Color.WHITE,
                new Color(148, 65, 154), new Color(29, 136, 167), new Color(0, 255, 64) };

        for (int i = 0; i < Col.length; i++) {
            JButton but2 = new JButton();
            but2.setBackground(Col[i]);
            but2.setPreferredSize(new Dimension(40, 50));
            but2.addActionListener(dn);
            southPanel.add(but2);
        }
        
        this.add(southPanel, BorderLayout.SOUTH);

        setVisible(true);
        dn.setSh(Sh);// 对象.方法名(参数)；
        centerPanel.addMouseListener(dn);// 给事件源窗体对象添加addMouseListener()鼠标监听方法,指定事件处理类对象.
        centerPanel.addMouseMotionListener(dn);//给centerPanel加上监听方法，是在centerPanel上面画画；
  
        // 获取窗体上画笔画布对象(注意：必须要在窗体可见之后才能获取画笔画布对象，否则获取的是null)
        //Graphics  g=getGraphics();
        dn.SetG(centerPanel.getGraphics());
        //dn.SetG(g);

    }
}

package HuaTu;

import java.awt.Color;
import java.awt.Stroke;

public class Shape {
    public int x1, x2, y1, y2;
    public Color color;
    public String type;
    public Stroke stroke;

    public Shape() {

    }

    public Shape(int x1, int y1, int x2, int y2, Color color, Stroke stroke, String type) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
        this.color = color;
        this.stroke = stroke;// 之前少了这一个，造成了变量为空的情况；
        this.type = type;

    }

}