暑假第三周总结

   在这一段时间中我主要学习数据结构有关小学期的任务，我的选题是消球游戏。这个游戏的主要需求是：

 

 然后对这一需求我进行了编写，但是实现的功能不多，就第一阶段

 

下面给大家展示我的代码

package com.ball;

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.beans.*;
import java.util.*;

//首先我是继承了一个JFrame类，继承他的原因是可以出来java自带的面板，也可以让我的面板最大化和最小化和关闭，
public class BackgroundPanel extends JFrame{
    //这个常量是让我的面板弹窗最大展示多大，多宽
    private static final Dimension SIZE = new Dimension(600,400);

    public Dimension getMinimumSize() {return SIZE;}
    public Dimension getMaximumSize() {return SIZE;}
    public Dimension getPreferredSize() {return SIZE;}
    //设置球的宽度和高度和颜色
    private int r= 20;//小球半径
    private int width = r*1;//宽度
    private int height = r*1;//高度
    private Color ballColor = Color.black;//默认小球颜色

    /**
     * 棋盘
     * 实现属性变化监听
     */
    private class Chessboard extends Observable implements PropertyChangeListener{
        private int columns, rows, cellWidth;
        private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);

        private Chessboard(int columns, int rows, int cellWidth) {
            this.columns = columns;
            this.rows = rows;
            this.cellWidth = cellWidth;

        }

        private int getColumns() {
            return columns;
        }

        private void setColumns(int columns) {
            propertyChangeSupport.firePropertyChange("columns", this.columns, columns);
            this.columns = columns;
        }

        private int getRows() {
            return rows;
        }

        private void setRows(int rows) {
            propertyChangeSupport.firePropertyChange("columns", this.rows, rows);
            this.rows = rows;
        }

        private int getCellWidth() {
            return cellWidth;
        }

        private void setCellWidth(int cellWidth) {
            this.cellWidth = cellWidth;
        }

        public void propertyChange(PropertyChangeEvent evt) {
            switch (evt.getPropertyName()) {
                case "columns":
                case "rows":
                case "cellWidth":
                    if (!evt.getOldValue().equals(evt.getNewValue())) {
                        setChanged();
                        notifyObservers(this);
                    }
                    break;
            }
        }
    }

    /**
     * 画笔
     */
    private interface Brush {
        void paint(Graphics g);

        Component getCompoment();
    }

    abstract private class ChessboardBrush implements Brush, Observer {
        private Chessboard chessboard;

        private ChessboardBrush(Chessboard chessboard) {
            this.chessboard = chessboard;
        }

        public void paint(Graphics g) {
            if (chessboard == null) return;

            Graphics2D g2 = (Graphics2D) g.create();
            //背景白色
            g2.setColor(Color.WHITE);
            g2.fillRect(0,0, getCompoment().getWidth(), getCompoment().getHeight());

            //整体偏移坐标系
            g2.translate(100,100);

            g2.setColor(Color.BLACK);

            //绘制行线
            for (int r = 0; r <= chessboard.getRows(); r ++)
                g2.drawLine(0, r * chessboard.getCellWidth(), chessboard.getColumns() * chessboard.getCellWidth(), r * chessboard.getCellWidth());

            //绘制竖线
            for (int c = 0; c <= chessboard.getColumns(); c++)
                g2.drawLine(c * chessboard.getCellWidth(), 0, chessboard.getCellWidth() * c , chessboard.getRows() * chessboard.getCellWidth());
            //调用颜色
            g2.setColor(ballColor);
            //球形摆放的位置
            g2.fillOval(2,5,width,height);
            g2.setColor(ballColor);
            g2.fillOval(215,215,width,height);
            g2.dispose();
        }

        public void update(Observable o, Object arg) {
            if (arg instanceof Chessboard)
                chessboard = (Chessboard)arg;
        }
    }

    /*画布*/
    private class Canvas extends JComponent{
        private Brush getBrush() {
            return brush;
        }

        private void setBrush(Brush brush) {
            this.brush = brush;
        }

        private Brush brush;

        private Canvas() {
            super();
        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            if(isVisible() && brush != null)
                brush.paint(g);
        }

        public Border getBorder() {
            return BorderFactory.createLineBorder(Color.BLUE,2);
        }
    }


    private Canvas canvas;
    private ChessboardBrush brush;
    private Chessboard chessboard;

    //一个构造方法用来调用其他的方法
    private BackgroundPanel() {
        super();
        init();
        addListeners();
        doLay();
//        this.setContentPane(getJContentPanel());
    }

    //设置棋盘的高度有多少格子和宽度多少格子
    private void init(){
        chessboard = new Chessboard(19,19,30);
        canvas = new Canvas();
        brush = new ChessboardBrush(chessboard) {

            public Component getCompoment() {
                return canvas;
            }
        };
        canvas.setBrush(brush);

        chessboard.addObserver(brush);
    }

    private void addListeners(){

    }


    private void doLay(){
        Container container = getContentPane();
        container.add(canvas, BorderLayout.CENTER);
        pack();
        setVisible(true);
    }

    public static void main(String... args) {
        System.setProperty("swing.defaultlaf","com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
        SwingUtilities.invokeLater(BackgroundPanel::new);
    }
}