java源代码 不能执行

那恐怕是代码有问题。要知道我们帮别人写代码是很少验证的。你把问题再发过来，看有人能帮助你吗。

坚守“ 做人真诚 · 做事靠谱 · 口碑至上 · 高效敬业 ”的价值观，专业网站建设服务10余年为成都成都搬家公司小微创业公司专业提供成都企业网站定制营销网站建设商城网站建设手机网站建设小程序网站建设网站改版，从内容策划、视觉设计、底层架构、网页布局、功能开发迭代于一体的高端网站建设服务。

求JAVA源代码！！紧急~~~

只能给你第一个：

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class JNotePadUI extends JFrame {

private JMenuItem menuOpen;

private JMenuItem menuSave;

private JMenuItem menuSaveAs;

private JMenuItem menuClose;

private JMenu editMenu;

private JMenuItem menuCut;

private JMenuItem menuCopy;

private JMenuItem menuPaste;

private JMenuItem menuAbout;

private JTextArea textArea;

private JLabel stateBar;

private JFileChooser fileChooser;

private JPopupMenu popUpMenu;

public JNotePadUI() {

super("新建文本文件");

setUpUIComponent();

setUpEventListener();

setVisible(true);

}

private void setUpUIComponent() {

setSize(640, 480);

// 菜单栏

JMenuBar menuBar = new JMenuBar();

// 设置「文件」菜单

JMenu fileMenu = new JMenu("文件");

menuOpen = new JMenuItem("打开");

// 快捷键设置

menuOpen.setAccelerator(

KeyStroke.getKeyStroke(

KeyEvent.VK_O,

InputEvent.CTRL_MASK));

menuSave = new JMenuItem("保存");

menuSave.setAccelerator(

KeyStroke.getKeyStroke(

KeyEvent.VK_S,

InputEvent.CTRL_MASK));

menuSaveAs = new JMenuItem("另存为");

menuClose = new JMenuItem("关闭");

menuClose.setAccelerator(

KeyStroke.getKeyStroke(

KeyEvent.VK_Q,

InputEvent.CTRL_MASK));

fileMenu.add(menuOpen);

fileMenu.addSeparator(); // 分隔线

fileMenu.add(menuSave);

fileMenu.add(menuSaveAs);

fileMenu.addSeparator(); // 分隔线

fileMenu.add(menuClose);

// 设置「编辑」菜单

JMenu editMenu = new JMenu("编辑");

menuCut = new JMenuItem("剪切");

menuCut.setAccelerator(

KeyStroke.getKeyStroke(KeyEvent.VK_X,

InputEvent.CTRL_MASK));

menuCopy = new JMenuItem("复制");

menuCopy.setAccelerator(

KeyStroke.getKeyStroke(KeyEvent.VK_C,

InputEvent.CTRL_MASK));

menuPaste = new JMenuItem("粘贴");

menuPaste.setAccelerator(

KeyStroke.getKeyStroke(KeyEvent.VK_V,

InputEvent.CTRL_MASK));

editMenu.add(menuCut);

editMenu.add(menuCopy);

editMenu.add(menuPaste);

// 设置「关于」菜单

JMenu aboutMenu = new JMenu("关于");

menuAbout = new JMenuItem("关于JNotePad");

aboutMenu.add(menuAbout);

menuBar.add(fileMenu);

menuBar.add(editMenu);

menuBar.add(aboutMenu);

setJMenuBar(menuBar);

// 文字编辑区域

textArea = new JTextArea();

textArea.setFont(new Font("宋体", Font.PLAIN, 16));

textArea.setLineWrap(true);

JScrollPane panel = new JScrollPane(textArea,

ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,

ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);

Container contentPane = getContentPane();

contentPane.add(panel, BorderLayout.CENTER);

// 状态栏

stateBar = new JLabel("未修改");

stateBar.setHorizontalAlignment(SwingConstants.LEFT);

stateBar.setBorder(

BorderFactory.createEtchedBorder());

contentPane.add(stateBar, BorderLayout.SOUTH);

popUpMenu = editMenu.getPopupMenu();

fileChooser = new JFileChooser();

}

private void setUpEventListener() {

// 按下窗口关闭钮事件处理

addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

closeFile();

}

}

);

// 菜单 - 打开

menuOpen.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

openFile();

}

}

);

// 菜单 - 保存

menuSave.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

saveFile();

}

}

);

// 菜单 - 另存为

menuSaveAs.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

saveFileAs();

}

}

);

// 菜单 - 关闭文件

menuClose.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

closeFile();

}

}

);

// 菜单 - 剪切

menuCut.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

cut();

}

}

);

// 菜单 - 复制

menuCopy.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

copy();

}

}

);

// 菜单 - 粘贴

menuPaste.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

paste();

}

}

);

// 菜单 - 关于

menuAbout.addActionListener(

new ActionListener() {

public void actionPerformed(ActionEvent e) {

// 显示对话框

JOptionPane.showOptionDialog(null,

"程序名称:\n JNotePad \n" +

"程序设计:\n ???\n" +

"简介:\n 一个简单的文字编辑器\n",

"关于JNotePad",

JOptionPane.DEFAULT_OPTION,

JOptionPane.INFORMATION_MESSAGE,

null, null, null);

}

}

);

// 编辑区键盘事件

textArea.addKeyListener(

new KeyAdapter() {

public void keyTyped(KeyEvent e) {

processTextArea();

}

}

);

// 编辑区鼠标事件

textArea.addMouseListener(

new MouseAdapter() {

public void mouseReleased(MouseEvent e) {

if(e.getButton() == MouseEvent.BUTTON3)

popUpMenu.show(editMenu, e.getX(), e.getY());

}

public void mouseClicked(MouseEvent e) {

if(e.getButton() == MouseEvent.BUTTON1)

popUpMenu.setVisible(false);

}

}

);

}

private void openFile() {

if(isCurrentFileSaved()) { // 文件是否为保存状态

open(); // 打开

}

else {

// 显示对话框

int option = JOptionPane.showConfirmDialog(

null, "文件已修改，是否保存？",

"保存文件？", JOptionPane.YES_NO_OPTION,

JOptionPane.WARNING_MESSAGE, null);

switch(option) {

// 确认文件保存

case JOptionPane.YES_OPTION:

saveFile(); // 保存文件

break;

// 放弃文件保存

case JOptionPane.NO_OPTION:

open();

break;

}

}

}

private boolean isCurrentFileSaved() {

if(stateBar.getText().equals("未修改")) {

return true;

}

else {

return false;

}

}

private void open() {

// fileChooser 是 JFileChooser 的实例

// 显示文件选取的对话框

int option = fileChooser.showDialog(null, null);

// 使用者按下确认键

if(option == JFileChooser.APPROVE_OPTION) {

/*

TODO: 添加读取文件的代码

*/

}

}

private void saveFile() {

/*

TODO: 添加保存文件的代码

*/

}

private void saveFileAs() {

/*

TODO: 添加另存为的代码

*/

}

private void closeFile() {

// 是否已保存文件

if(isCurrentFileSaved()) {

// 释放窗口资源，而后关闭程序

dispose();

}

else {

int option = JOptionPane.showConfirmDialog(

null, "文件已修改，是否保存？",

"保存文件？", JOptionPane.YES_NO_OPTION,

JOptionPane.WARNING_MESSAGE, null);

switch(option) {

case JOptionPane.YES_OPTION:

saveFile();

break;

case JOptionPane.NO_OPTION:

dispose();

}

}

}

private void cut() {

textArea.cut();

stateBar.setText("已修改");

popUpMenu.setVisible(false);

}

private void copy() {

textArea.copy();

popUpMenu.setVisible(false);

}

private void paste() {

textArea.paste();

stateBar.setText("已修改");

popUpMenu.setVisible(false);

}

private void processTextArea() {

stateBar.setText("已修改");

}

public static void main(String[] args) {

new JNotePadUI();

}

}

求java源代码

BS 架构很好做啊！就是单表 select \ insert update delete 操作, 这个功能很好写的，你说的这些代码，有些还可以用工具生成

java的源代码隐藏问题

你要的功能其实是Java代码混淆，如果要了解Java编译成exe，可以看“参考资料”。

下面一段文字摘自《Java 手机/PDA 程序设计入门》一书，可以做为混淆器性能的大致观点：

笔者没用过DashO，所以无法对其作出个人评价。所以现在仅说明笔者曾用过的产品。以笔者的个人观点，如果就混淆的程度来说，ZKM最好，JAX中等，RetroGuard和ProGuard最差，一分钱一分货，这是千古不变的道理。如果就功能性而言，ZKM和JAX都不错，不过，JAX是IBM所开发的产品，因此也继承了大部分IBM产品的最大特色，就是“功能超强，可是不易使用”，可能光是要看完JAX的设定文件就是一个很大的问题。

下面分别介绍几种具有代表性的混淆器，对它们的产品性能进行对比。我们使用不同混淆器对同一段java代码进行混淆，分别列出混淆后代码反编译的结果，并给出使用的一些直接体会。

原始java代码：

public class SimpleBean implements Serializable {

private String[] name = {"name0","name1","name2","name3"};

private List myList = null;

public void SimpleBean() {

myList = new ArrayList(4);

}

public void init_public() {

myList.add("name");

for(int i= 1; i 4; i++){

init_private(i);

}

}

private void init_private(int j) {

myList.add(name[j]);

}

private void writeObject(java.io.ObjectOutputStream out)

throws IOException {

}

}

一、ProGuard 4.5.1

ProGuard是一款免费的Java类文件压缩器、优化器和混淆器。它能发现并删除无用类、字段（field）、方法和属性值（attribute）。它也能优化字节码并删除无用的指令。最后，它使用简单无意义的名字来重命名你的类名、字段名和方法名。经过以上操作的jar文件 会变得更小，并很难进行逆向工程。eclipse已经把Proguard集成在一起了。它支持脚本控制，可以使用GUI界面，字符串不加密，支持 J2ME。

类似功能的开源混淆器：

RetroGuard yGuard（RetroGuard的一个升级版本） JODE

Jad反编译混淆后class得到的代码：

public class SimpleBean

implements Serializable

{

public SimpleBean()

{

a_java_util_List_fld = null;

}

public void SimpleBean()

{

a_java_util_List_fld = new ArrayList(4);

}

public void init_public()

{

a_java_util_List_fld.add("name");

for(int i = 1; i 4; i++)

{

int j = i;

SimpleBean simplebean = this;

a_java_util_List_fld.add(simplebean.a_java_lang_String_array1d_fld[j]);

}

}

private String a_java_lang_String_array1d_fld[] = {

"name0", "name1", "name2", "name3"

};

private List a_java_util_List_fld;

}

优点：

1、对内部private方法的调用进行了内联，但基本达不到混淆效果；

2、使用文档详尽，混淆选项配置文件的编写示例多；

3、混淆选项粒度较细，可以使用GUI界面，支持本地方法的保护等；

4、支持j2me，可以集成到Eclipse；

5、开源。

缺点：

1、符号混淆的命名具有提示性，字符串未加密，没有其它的混淆措施；

2、混淆主要针对Xlet、Midlet等应用，混淆库文件时配置文件将会很复杂。

二、Jocky

Jocky是金蝶中间件技术领袖袁红岗先生的个人作品（旧有名称JOC)。原本是方便Apusic 应用服务器的开发，现在开放出来，供大家自由使用。Jocky混淆编译器是在Sun JDK中提供的Java编译器(javac)的基础上完成的，修改了其中的代码生成过程，对编译器生成的中间代码进行混淆，最后再生成class文件，这样编译和混淆只需要一个步骤就可以完成。也就是说，它是直接从源码上做文章，这是Jocky与其它混淆编译器最大的不同之处。另外可以在源程序中插入符号保留指令来控制哪些符号需要保留，将混淆过程与开发过程融合在一起，不需要单独的混淆选项配置文件。Jocky的上述特点较适合于java类库的混淆。

Jad反编译混淆后class得到的代码：

public class SimpleBean

implements Serializable

{

public SimpleBean()

{

this;

String as[] = new String[4];

as;

as[0] = "name0";

as;

JVM INSTR swap ;

1;

"name1";

JVM INSTR aastore ;

JVM INSTR dup ;

JVM INSTR swap ;

2;

"name2";

JVM INSTR aastore ;

JVM INSTR dup ;

JVM INSTR swap ;

3;

"name3";

JVM INSTR aastore ;

_$2;

_$1 = null;

return;

}

public void SimpleBean()

{

this;

JVM INSTR new #9 Class ArrayList;

JVM INSTR dup ;

JVM INSTR swap ;

4;

ArrayList();

_$1;

}

public void init_public()

{

_$1.add("name");

for(int i = 1; i 4; i++)

_$1(i);

}

private void _$1(int i)

{

_$1.add(_$2[i]);

}

private void writeObject(ObjectOutputStream objectoutputstream)

throws IOException

{

}

private String _$2[];

private List _$1;

}

优点：

1、除符号混淆外增加了数据混淆（字符数组初始化）；

2、有一些语句反编译只能得到字节码指令；

3、在Sun JDK中提供的Java编译器(javac)的基础上完成，编译和混淆一体完成，不需要先生成class文件再混淆；

4、提供了Eclipse的插件，能够直接在Eclipse中使用Jocky。

缺点：

1、混淆选项粒度较粗，使用中可能要在具体代码中添加@preserve指令来实现，工作量大；

2、没有控制流混淆。

三、Allatori 3.1_demo

Allatori属于第二代混淆器，具有全方位保护你的知识产权的能力。Allatori具有以下几种保护方式：命名混淆，流混淆，调试信息混淆，字符串编码，以及水印技术。对于教育和非商业项目来说这个混淆器是免费的。2.1版本支持war和ear文件格式，并且允许对需要混淆代码的应用程序添加有效日期。

Jad反编译混淆后class得到的代码：

public class SimpleBean

implements Serializable

{

public void init_public()

{

d.add(c.k("{u{0"));

int i = 1;

goto _L1

_L3:

H(i);

++i;

_L1:

4;

JVM INSTR icmplt 21;

goto _L2 _L3

_L2:

}

public void SimpleBean()

{

d = new ArrayList(4);

}

private void H(int a)

{

d.add(c[a]);

}

public SimpleBean()

{

d = null;

}

private void H(ObjectOutputStream objectoutputstream)

throws IOException

{

}

private String c[] = {

c.k("\177q\177te"), c.k("\177q\177td"), c.k("\177q\177tg"), c.k("\177q\177tf")

};

private List d;

}

注：c.k是为进行字符串加密额外生成的类c的静态方法。

优点：

1、设计考虑了库文件混淆的使用场景；

2、使用文档详尽，混淆选项配置文件的编写示例多；

3、除符号混淆外，还使用了两种高级的混淆手段：控制混淆（改写了for循环）和字符串加密（String数组初始化）；

4、混淆选项粒度较细，支持本地方法的保护等；

5、支持水印技术，允许对需要混淆的代码添加有效日期；

6、支持j2me；

缺点：

1、商业软件（价格附后），对教育和非商业用途免费（网站链接是）。

附：价格情况

SINGLE DEVELOPER LICENSE

1 license $290

2-5 licenses $260

6-10 licenses $230

11+ licenses $200

SITE LICENSE $3750

BUSINESS LICENSE $4850

ANNUAL SUPPORT UPDATE $45

四、Zelix KlassMaster（ZKM）

Zelix KlassMaster是一个来自Zelix Pty Ltd的商业混淆器。官方文档中关于它的混淆特性的介绍很少。它的保护功能非常强大，可以进行符号混淆和控制混淆，支持字符串的复杂加密保护，堆栈混乱，支持异常重构，支持增量混淆，支持J2ME。Zelix KlassMaster提供试用版本，可以到下载。

五、DashO Pro

DashO Pro 是由Preemptive Solutions开发的商业化的混淆器. 免费的评估版可以到下载。DashO Pro代码保护能力强大易用，方便灵活（商业软件，非开源）。该Java混淆器是Sun的选择，对于企业级应用，作为其Java开发包的一部分，Sun微系统使用DashO Pro来混淆其加密库。DashO Pro能够对ID进行重新命名，使之成为毫无意义的字符；混淆元数据；改变控制流等，所有这些操作使得java代码被混淆，难于理解。产品特点包括：

领先的Java源码保护机制；

运用专利Overload-Induction技术对包/类/方法/域进行重命名；

高级的流程控制混淆机制；

字符串加密技术；

防止反编译器生成有用的输出；

水印软件；

提高Java源码效率；

不采用类/方法/域，全面移除常数存储库；

类/方法级别的优化，以提高JIT效果；

动态加载检测到的类；

全面高效的Java源码的拓展和部署；

支持所有的JDK版本 (JSE, J2EE, J2ME, etc)包括1.5；

自动堆栈跟踪转换；

在指定路径打包或者java jars；

支持任何打包类型的Java内容——程序、库、applets程序、小服务器程序、EJB等；支持基于J2ME CLDC的架构，包括MIDP和 iAppli；

支持CLDC预检验库中的类；

可以从指定路径、Zip压缩包或者jars中提取；

支持导出100%纯粹的Java，并提供验证；

命令行接口适合集成到构建环境内；

基于XML的配置文件，易于使用；

全面准确的PDF格式用户指南。

北大青鸟java培训：程序员如何避免无效代码的问题？

对于软件编程开发程序员来说，无效代码堆积以及代码质量低是很多新手容易犯的一些错误。

下面我们就一起来了解和学习一下，减少无效代码的堆积都有哪些方法。

当曾经向往的职业变成一日又一日的无用代码堆积，多少让开发者有些心灰意冷，虽然无法保证整个产品质量，但至少可以在代码层面下点功夫。

无用代码堆积这种现象在日常软件开发中非常普遍，对于需求频繁被修改的问题，根源在于弄清楚软件开发的目的是什么，代码有没有用的终决定者应该是用户，如果一段代码具备的功能符合用户需求，具备业务价值，那么就是有用的。

在软件开发过程中，需求变更和代码修改是很正常的事情，但这个不确定性需要在一定范围内。

对此，佳的解决方案可能是迭代开发，也叫迭代增量式开发，将整个开发周期分解为若干时间段，每隔一段固定时间就对软件进行一次小迭代，每迭代几次就进行一次全面测试和大版本更新，对开发成果进行质量评审，这个过程重要的是听取终用户的意见，以便及时调整优化，避免无效需求，尤其是决策者拍脑门出来的决定。

开发之前，技术负责人务必准备好相应文档，确定好各工程师的分工，尤其是需要协同完成的部分。

另外，团队尽量抽出时间和精力进行代码Review，并以降低代码复杂度为目标，如果不同工程师之间的代码间经常互相影响，可以考虑让这类程序员负责独立开发模块，降低对整个项目的影响。

长期以来，测试在国内的重视程度并不够，一个测试团队起码应该有白盒测试、效率测试、单元测试等各类专职人员，不建议在所有功能完成之后才开始测试，好是完成一个功能就马上交给测试，测试阶段应由测试完全掌握主动权，开发必须尊重测试人员的工作。

归根结底，贵阳北大青鸟认为软件开发是一项非常复杂的工作，为了避免过程出错，很多公司已经摸索并建立了成熟且完整的代码编写规范，包括变量命名规则、层次化设计、类和接口设计，到后的代码Review都很清楚，重要的不是会写代码，而是学会解决问题，做真正有价值的事情。

跪求游戏java源代码

给你一个俄罗斯方块的把！！

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import javax.swing.*;

import javax.swing.Timer;

public class Tetris extends JFrame {

public Tetris() {

Tetrisblok a = new Tetrisblok();

addKeyListener(a);

add(a);

}

public static void main(String[] args) {

Tetris frame = new Tetris();

JMenuBar menu = new JMenuBar();

frame.setJMenuBar(menu);

JMenu game = new JMenu("游戏");

JMenuItem newgame = game.add("新游戏");

JMenuItem pause = game.add("暂停");

JMenuItem goon = game.add("继续");

JMenuItem exit = game.add("退出");

JMenu help = new JMenu("帮助");

JMenuItem about = help.add("关于");

menu.add(game);

menu.add(help);

frame.setLocationRelativeTo(null);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setSize(220, 275);

frame.setTitle("Tetris内测版");

// frame.setUndecorated(true);

frame.setVisible(true);

frame.setResizable(false);

}

}

// 创建一个俄罗斯方块类

class Tetrisblok extends JPanel implements KeyListener {

// blockType 代表方块类型

// turnState代表方块状态

private int blockType;

private int score = 0;

private int turnState;

private int x;

private int y;

private int i = 0;

int j = 0;

int flag = 0;

// 定义已经放下的方块x=0-11,y=0-21;

int[][] map = new int[13][23];

// 方块的形状 第一组代表方块类型有S、Z、L、J、I、O、T 7种 第二组 代表旋转几次 第三四组为 方块矩阵

private final int shapes[][][] = new int[][][] {

// i

{ { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },

{ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 } },

// s

{ { 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 } },

// z

{ { 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 } },

// j

{ { 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },

{ 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },

// o

{ { 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },

// l

{ { 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },

{ 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },

// t

{ { 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },

{ 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

{ 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 } } };

// 生成新方块的方法

public void newblock() {

blockType = (int) (Math.random() * 1000) % 7;

turnState = (int) (Math.random() * 1000) % 4;

x = 4;

y = 0;

if (gameover(x, y) == 1) {

newmap();

drawwall();

score = 0;

JOptionPane.showMessageDialog(null, "GAME OVER");

}

}

// 画围墙

public void drawwall() {

for (i = 0; i 12; i++) {

map[i][21] = 2;

}

for (j = 0; j 22; j++) {

map[11][j] = 2;

map[0][j] = 2;

}

}

// 初始化地图

public void newmap() {

for (i = 0; i 12; i++) {

for (j = 0; j 22; j++) {

map[i][j] = 0;

}

}

}

// 初始化构造方法

Tetrisblok() {

newblock();

newmap();

drawwall();

Timer timer = new Timer(1000, new TimerListener());

timer.start();

}

// 旋转的方法

public void turn() {

int tempturnState = turnState;

turnState = (turnState + 1) % 4;

if (blow(x, y, blockType, turnState) == 1) {

}

if (blow(x, y, blockType, turnState) == 0) {

turnState = tempturnState;

}

repaint();

}

// 左移的方法

public void left() {

if (blow(x - 1, y, blockType, turnState) == 1) {

x = x - 1;

}

;

repaint();

}

// 右移的方法

public void right() {

if (blow(x + 1, y, blockType, turnState) == 1) {

x = x + 1;

}

;

repaint();

}

// 下落的方法

public void down() {

if (blow(x, y + 1, blockType, turnState) == 1) {

y = y + 1;

delline();

}

;

if (blow(x, y + 1, blockType, turnState) == 0) {

add(x, y, blockType, turnState);

newblock();

delline();

}

;

repaint();

}

// 是否合法的方法

public int blow(int x, int y, int blockType, int turnState) {

for (int a = 0; a 4; a++) {

for (int b = 0; b 4; b++) {

if (((shapes[blockType][turnState][a * 4 + b] == 1) (map[x

+ b + 1][y + a] == 1))

|| ((shapes[blockType][turnState][a * 4 + b] == 1) (map[x

+ b + 1][y + a] == 2))) {

return 0;

}

}

}

return 1;

}

// 消行的方法

public void delline() {

int c = 0;

for (int b = 0; b 22; b++) {

for (int a = 0; a 12; a++) {

if (map[a][b] == 1) {

c = c + 1;

if (c == 10) {

score += 10;

for (int d = b; d 0; d--) {

for (int e = 0; e 11; e++) {

map[e][d] = map[e][d - 1];

}

}

}

}

}

c = 0;

}

}

// 判断你挂的方法

public int gameover(int x, int y) {

if (blow(x, y, blockType, turnState) == 0) {

return 1;

}

return 0;

}

// 把当前添加map

public void add(int x, int y, int blockType, int turnState) {

int j = 0;

for (int a = 0; a 4; a++) {

for (int b = 0; b 4; b++) {

if (map[x + b + 1][y + a] == 0) {

map[x + b + 1][y + a] = shapes[blockType][turnState][j];

}

;

j++;

}

}

}

// 画方块的的方法

public void paintComponent(Graphics g) {

super.paintComponent(g);

// 画当前方块

for (j = 0; j 16; j++) {

if (shapes[blockType][turnState][j] == 1) {

g.fillRect((j % 4 + x + 1) * 10, (j / 4 + y) * 10, 10, 10);

}

}

// 画已经固定的方块

for (j = 0; j 22; j++) {

for (i = 0; i 12; i++) {

if (map[i][j] == 1) {

g.fillRect(i * 10, j * 10, 10, 10);

}

if (map[i][j] == 2) {

g.drawRect(i * 10, j * 10, 10, 10);

}

}

}

g.drawString("score=" + score, 125, 10);

g.drawString("抵制不良游戏，", 125, 50);

g.drawString("拒绝盗版游戏。", 125, 70);

g.drawString("注意自我保护，", 125, 90);

g.drawString("谨防受骗上当。", 125, 110);

g.drawString("适度游戏益脑，", 125, 130);

g.drawString("沉迷游戏伤身。", 125, 150);

g.drawString("合理安排时间，", 125, 170);

g.drawString("享受健康生活。", 125, 190);

}

// 键盘监听

public void keyPressed(KeyEvent e) {

switch (e.getKeyCode()) {

case KeyEvent.VK_DOWN:

down();

break;

case KeyEvent.VK_UP:

turn();

break;

case KeyEvent.VK_RIGHT:

right();

break;

case KeyEvent.VK_LEFT:

left();

break;

}

}

// 无用

public void keyReleased(KeyEvent e) {

}

// 无用

public void keyTyped(KeyEvent e) {

}

// 定时器监听

class TimerListener implements ActionListener {

public void actionPerformed(ActionEvent e) {

repaint();

if (blow(x, y + 1, blockType, turnState) == 1) {

y = y + 1;

delline();

}

;

if (blow(x, y + 1, blockType, turnState) == 0) {

if (flag == 1) {

add(x, y, blockType, turnState);

delline();

newblock();

flag = 0;

}

flag = 1;

}

;

}

}

}

分享题目：java无用源代码 没有源代码
标题来源：http://ybzwz.com/article/doojhgs.html