public void Down(){ boolean flag=false; for(int y=0;y<4;y++){ for(int x=3;x>=0;x--){ for(int x1=x-1;x1>=0;x1--){ if(card[x1][y].getText()!=""){ int num = Integer.parseInt(card[x1][y].getText().toString()); if(card[x][y].getText()==""){ card[x][y].setText(num+""); card[x1][y].setText(""); x++; flag=true; break; }else if(equals(card[x][y],card[x1][y])){ num*=2; card[x][y].setText(num+""); card[x1][y].setText(""); int score = Integer.parseInt(tvScore.getText().toString()); score+=num; tvScore.setText(score+""); flag=true; break; }else{ break; } } } } } if(flag) { RandNum(); StopGame(); } }

这是一个2048小游戏的下移函数。这个函数的作用是将所有的数字卡片向下移动，当两个相邻的卡片数字相同时，它们会合并成一个新的卡片，数字为原来两个卡片数字的和。同时，每次移动和合并都会增加分数。

具体实现方式是，从第一列开始，从下往上遍历每个格子，找到它上面第一个不为空的格子（即其上面有数字的格子），如果这个格子和它自己数字相同，则将两个格子合并，并更新分数；否则，将这个格子移动到上面第一个空格子的位置。每次操作后，如果有格子发生了移动或合并，就随机生成一个新的数字卡片，并检查游戏是否结束。

相关问题

java做一个图案锁屏

要实现图案锁屏，需要以下步骤：

1. 创建一个画板，用于绘制图案锁屏的界面。

public class LockPatternView extends View {
    private Paint paint;
    private int width, height;
    private int radius;
    private int cellSize;
    private int paddingTop, paddingLeft;
    private Point[][] cellPoints;
    private boolean[][] cellChecked;
    private List<Point> selectedPoints;
    private OnPatternChangedListener listener;
    // 构造函数
    public LockPatternView(Context context) {
        this(context, null);
    }
    public LockPatternView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
    public LockPatternView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        cellPoints = new Point[3][3];
        cellChecked = new boolean[3][3];
        selectedPoints = new ArrayList<>();
    }
    // 测量大小
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
        width = height = Math.min(widthSize, heightSize);
        radius = width / 10;
        cellSize = radius * 2 + radius / 3;
        paddingLeft = (width - cellSize * 3) / 2;
        paddingTop = (height - cellSize * 3) / 2;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                int x = paddingLeft + j * cellSize + cellSize / 2;
                int y = paddingTop + i * cellSize + cellSize / 2;
                cellPoints[i][j] = new Point(x, y);
            }
        }
        setMeasuredDimension(width, height);
    }
    // 绘制图案锁屏界面
    @Override
    protected void onDraw(Canvas canvas) {
        // 绘制九个点
        paint.setColor(Color.WHITE);
        paint.setStyle(Paint.Style.FILL);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                canvas.drawCircle(cellPoints[i][j].x, cellPoints[i][j].y, radius, paint);
            }
        }
        // 绘制连线
        if (selectedPoints.size() > 0) {
            Path path = new Path();
            Point startPoint = selectedPoints.get(0);
            path.moveTo(startPoint.x, startPoint.y);
            for (int i = 1; i < selectedPoints.size(); i++) {
                Point endPoint = selectedPoints.get(i);
                path.lineTo(endPoint.x, endPoint.y);
            }
            if (listener != null) {
                listener.onPatternChanging(selectedPoints);
            }
            canvas.drawPath(path, paint);
        }
    }
}

2. 处理手势操作，响应用户的手势操作，并根据用户的操作更新界面。

public class LockPatternView extends View {
    // ...
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int action = event.getAction();
        int x = (int) event.getX();
        int y = (int) event.getY();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                reset();
                Point point = checkPoint(x, y);
                if (point != null) {
                    cellChecked[point.x][point.y] = true;
                    selectedPoints.add(point);
                }
                break;
            case MotionEvent.ACTION_MOVE:
                Point movePoint = checkPoint(x, y);
                if (movePoint != null && !cellChecked[movePoint.x][movePoint.y]) {
                    cellChecked[movePoint.x][movePoint.y] = true;
                    selectedPoints.add(movePoint);
                }
                break;
            case MotionEvent.ACTION_UP:
                if (selectedPoints.size() >= 2) {
                    if (listener != null) {
                        listener.onPatternChanged(selectedPoints);
                    }
                }
                break;
        }
        invalidate();
        return true;
    }
    private Point checkPoint(int x, int y) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (cellPoints[i][j].x - x < radius && cellPoints[i][j].y - y < radius
                        && x - cellPoints[i][j].x < radius && y - cellPoints[i][j].y < radius
                        && !cellChecked[i][j]) {
                    return new Point(i, j);
                }
            }
        }
        return null;
    }
    private void reset() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                cellChecked[i][j] = false;
            }
        }
        selectedPoints.clear();
    }
}

3. 定义接口，用于监听图案锁屏的变化。

public interface OnPatternChangedListener {
    void onPatternChanging(List<Point> points);
    void onPatternChanged(List<Point> points);
}

4. 在Activity中使用LockPatternView，处理图案锁屏的变化。

public class MainActivity extends AppCompatActivity implements LockPatternView.OnPatternChangedListener {
    private LockPatternView lockPatternView;
    private TextView tvTips;
    private List<Point> patternList;
    private boolean isSetPattern;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        lockPatternView = findViewById(R.id.lock_pattern_view);
        tvTips = findViewById(R.id.tv_tips);
        lockPatternView.setOnPatternChangedListener(this);
        patternList = new ArrayList<>();
        isSetPattern = false;
    }
    @Override
    public void onPatternChanging(List<Point> points) {
        // 图案正在改变，可以更新界面提示用户
        tvTips.setText("请继续输入手势");
    }
    @Override
    public void onPatternChanged(List<Point> points) {
        // 图案已经改变，可以根据业务逻辑进行处理
        if (isSetPattern) {
            // 设置图案锁屏
            if (patternList.size() == 0) {
                // 第一次设置图案锁屏
                patternList.addAll(points);
                tvTips.setText("请再次输入手势");
            } else {
                // 第二次设置图案锁屏
                if (points.equals(patternList)) {
                    // 两次输入的图案相同，保存图案并提示用户设置成功
                    savePattern(points);
                    tvTips.setText("设置成功");
                } else {
                    // 两次输入的图案不同，提示用户重新设置
                    tvTips.setText("两次输入不一致，请重新设置");
                }
                patternList.clear();
            }
        } else {
            // 验证图案锁屏
            if (verifyPattern(points)) {
                // 验证通过，跳转到主界面
                Intent intent = new Intent(this, HomeActivity.class);
                startActivity(intent);
                finish();
            } else {
                // 验证失败，提示用户重新输入
                tvTips.setText("手势不正确，请重新输入");
            }
        }
    }
    private void savePattern(List<Point> points) {
        // 保存图案
    }
    private boolean verifyPattern(List<Point> points) {
        // 验证图案
        return false;
    }
}

这样，一个简单的图案锁屏就实现了。需要注意的是，这里只是实现了一个简单的图案锁屏，实际应用中还需要考虑诸如密码长度、密码强度等因素。

android project 贪吃蛇小项目源码

贪吃蛇小项目是一个经典的游戏，适合初学者来学习Android开发。下面是一个简单的贪吃蛇小项目源码：

MainActivity.java:

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 设置全屏
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        // 设置游戏画面
        setContentView(new GameView(this));
    }
}

GameView.java:

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

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

public class GameView extends SurfaceView implements SurfaceHolder.Callback {

    private MainThread thread;
    private Snake snake;
    private Point food;
    private int score;

    public GameView(Context context) {
        super(context);
        getHolder().addCallback(this);
        thread = new MainThread(getHolder(), this);
        setFocusable(true);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        snake = new Snake();
        food = new Point();
        score = 0;
        thread.setRunning(true);
        thread.start();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        boolean retry = true;
        while (retry) {
            try {
                thread.setRunning(false);
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            retry = false;
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            snake.updateDirection(event.getX(), event.getY());
        }
        return true;
    }

    public void update() {
        snake.move();
        checkCollision();
    }

    private void checkCollision() {
        if (snake.checkSelfCollision() || snake.checkWallCollision(getWidth(), getHeight())) {
            thread.setRunning(false);
        }
        if (snake.getHead().equals(food)) {
            food = createFood();
            snake.grow();
            score += 10;
        }
    }

    private Point createFood() {
        List<Point> snakePositions = snake.getPositions();
        Point newFood = new Point();
        while (true) {
            newFood.x = (int) Math.floor(Math.random() * (getWidth() - Snake.BLOCK_SIZE));
            newFood.y = (int) Math.floor(Math.random() * (getHeight() - Snake.BLOCK_SIZE));
            for (Point snakePosition : snakePositions) {
                if (!newFood.equals(snakePosition)) {
                    return newFood;
                }
            }
        }
    }

    @Override
    public void draw(Canvas canvas) {
        super.draw(canvas);

        if (canvas != null) {
            // 清空画面
            canvas.drawColor(Color.BLACK);

            // 绘制蛇
            snake.draw(canvas);

            // 绘制食物
            Paint paint = new Paint();
            paint.setColor(Color.RED);
            canvas.drawRect(food.x, food.y, food.x + Snake.BLOCK_SIZE, food.y + Snake.BLOCK_SIZE, paint);

            // 绘制分数
            Paint scorePaint = new Paint();
            scorePaint.setColor(Color.WHITE);
            scorePaint.setTextSize(40);
            canvas.drawText("Score: " + score, 10, 50, scorePaint);
        }
    }
}

Snake.java:

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;

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

public class Snake {

    public static final int BLOCK_SIZE = 40;
    private static final int SPEED = 10;

    private List<Point> positions;
    private int direction;

    public Snake() {
        direction = 1;
        positions = new ArrayList<>();
        positions.add(new Point(0, 0));
        positions.add(new Point(BLOCK_SIZE, 0));
        positions.add(new Point(BLOCK_SIZE * 2, 0));
        positions.add(new Point(BLOCK_SIZE * 3, 0));
        positions.add(new Point(BLOCK_SIZE * 4, 0));
    }

    public void updateDirection(float x, float y) {
        if (Math.abs(x - getHead().x) > Math.abs(y - getHead().y)) {
            if (x < getHead().x) {
                direction = 0;
            } else {
                direction = 2;
            }
        } else {
            if (y < getHead().y) {
                direction = 1;
            } else {
                direction = 3;
            }
        }
    }

    public void move() {
        Point newHead = new Point(getHead().x, getHead().y);
        switch (direction) {
            case 0:
                newHead.x -= BLOCK_SIZE;
                break;
            case 1:
                newHead.y -= BLOCK_SIZE;
                break;
            case 2:
                newHead.x += BLOCK_SIZE;
                break;
            case 3:
                newHead.y += BLOCK_SIZE;
                break;
        }
        positions.add(0, newHead);
        positions.remove(positions.size() - 1);
    }

    public void grow() {
        Point newTail = new Point(getTail().x, getTail().y);
        positions.add(newTail);
    }

    public boolean checkSelfCollision() {
        for (int i = 1; i < positions.size(); i++) {
            if (getHead().equals(positions.get(i))) {
                return true;
            }
        }
        return false;
    }

    public boolean checkWallCollision(int screenWidth, int screenHeight) {
        if (getHead().x < 0 || getHead().y < 0 || getHead().x >= screenWidth || getHead().y >= screenHeight) {
            return true;
        }
        return false;
    }

    public Point getHead() {
        return positions.get(0);
    }

    public Point getTail() {
        return positions.get(positions.size() - 1);
    }

    public List<Point> getPositions() {
        return positions;
    }

    public void draw(Canvas canvas) {
        Paint paint = new Paint();
        paint.setColor(Color.WHITE);
        for (Point position : positions) {
            canvas.drawRect(position.x, position.y, position.x + BLOCK_SIZE, position.y + BLOCK_SIZE, paint);
        }
    }
}

MainThread.java:

import android.graphics.Canvas;
import android.view.SurfaceHolder;

public class MainThread extends Thread {

    private final SurfaceHolder surfaceHolder;
    private GameView gameView;
    private boolean running;
    private Canvas canvas;

    public MainThread(SurfaceHolder surfaceHolder, GameView gameView) {
        this.surfaceHolder = surfaceHolder;
        this.gameView = gameView;
        this.running = false;
    }

    public void setRunning(boolean running) {
        this.running = running;
    }

    @Override
    public void run() {
        while (running) {
            canvas = null;
            try {
                // 锁定画布并更新游戏状态
                canvas = this.surfaceHolder.lockCanvas();
                synchronized (surfaceHolder) {
                    this.gameView.update();
                    this.gameView.draw(canvas);
                }
            } finally {
                if (canvas != null) {
                    // 解锁画布并提交更改
                    surfaceHolder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }
}

这个源码中，主要的类是`MainActivity`、`GameView`、`Snake`和`MainThread`，其中`MainActivity`是整个游戏的入口类，`GameView`是游戏的主要视图类，`Snake`是贪吃蛇的逻辑实现类，`MainThread`是游戏的主线程类。

在`MainActivity`中，我们设置全屏并将游戏视图设置为`GameView`。`GameView`中，我们维护了贪吃蛇的状态和画面，并监听用户的触摸事件，更新游戏状态并绘制画面。`Snake`中，我们实现了贪吃蛇的逻辑，包括移动、吃食物和检测碰撞等操作。`MainThread`中，我们使用主线程循环更新游戏状态和绘制画面。

这个贪吃蛇小项目源码是一个简单的示例，供初学者参考学习。你可以根据自己的需求进行拓展和修改。希望对你有所帮助！