你提供的代码不完全，无法深入分析，但是照你说的有显示“进入画图”，那么，很可能if(g.drawImage(image1, b.x, b.y, 30, 30, this))这个返回值为false，我刚查了下API，它的返回值说明Returns:
成都创新互联公司服务项目包括云阳网站建设、云阳网站制作、云阳网页制作以及云阳网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，云阳网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到云阳省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！
false if the image pixels are still changing; true otherwise.另外这个方法有这么样的说明This method returns immediately in all cases, even if the entire image has not yet been scaled, dithered, and converted for the current output device. If the current output representation is not yet complete, then drawImage returns false. 也就是说，现行输出未完成，图像像素仍在变化的时候，你就调用了这方法，那么会返回false。你检查一下代码，在你调用这段代码前，你的初始化工作做好了没。另外，最好就是像1楼说的，把图画到一个bufferImage里，再把bufferImage画到屏幕上
可能是由于设计者对面向对象设计经验的缺少，也可能设计者是一个刻板的教条主义者，结果出品了一个很不理想的设计，其中可能就体现在类的数量爆炸的问题。
类爆炸的现象已经发生在我们的软件系统中了。比如我们某期的系统中各种模块文件的数量已经达到一千多个了，虽然比起操作系统这样的系统来说，由一千多个模
块组成的系统不算什么，但是我们目前的软件团队维护这么多的模块真的是有些吃力。由于我们使用的是VB，这还导致另一个问题，VB能装载的文件总数是有限
制的，最后用户提出了新的需求需要新的模块来完成实现，系统却已经不允许加入新的模块了，最后不得不对系统进行拆分或者对某些模块进行合并。
类爆炸的直接原因是设计者对类的抽象粒度没能把握好，只要两个事务有所差别就用不同的类来设计。粒度能多小就做多小，以为这样可以减少耦合。事实是如此
吗？最近组长让我写一份设计问题，他已经规定了设计文档的规范和大纲，规范中说“本系统编码使用了三种类：界面类、实体类、记录集类，并调用了公用模块中
相应函数”，这可能是他从别的设计规范中继承抄袭过来的。但是我最后提交的设计文档没有实体类和记录集类，组长问我为什么没有这两种类，我说我不需要这两
种类，我这个功能一个界面就可完成了。但是他觉得，如果我没有那两个类就应该在设计文档中说明没有那两个类，我说我的设计文档中没有描述那两个类就表明我
没有那两个类，而不需要在文档中说明“实体类，无；记录集类，无”。
如果每一个功能的完成都必须设计成“界面类、实体类、记录集类”这三种类来联合完成，我们就陷入了教条主义的深渊中。曾经和某个项目经理探讨过，“a=c
与a=b=c”的取舍问题，我的观点是根据具体情况来决定是使用“a=c”的结构还是使用“a=b=c”的结构，他的观点是每个功能都一律使用
“a=b=c”的结构，这导致我很郁闷。为什么要在很简单的情况下，本来可以直接就让“a=c”，何必非要加一个中间件“b”，通过“b”来让
“a=c”？不是我不知道“a=b=c”的结构的用意，而是我觉要根据具体情况来应用。我们的系统的类爆炸就是因为不分优劣一律使用“a=b=c”的结构
而爆炸的。对于面向对象的初期使用者来说，总会津津乐道他在系统中实现了面向对象的设计，尽管那个设计比较糟糕。其实这位项目经理只是给了一个系统的规范
文档而已，至于说是他设计了系统的架构，那还远远谈不到。系统中有什么类，类如何创建，类如何组织，类之间如何通信，他都没有做。只是在文档里说了“本系
统编码使用了三种类：界面类、实体类、记录集类，并调用了公用模块中相应函数”，一句话了事。系统中到底有多少类，他不知道。
我在阅读设计专家关于面向对象设计和设计模式的文章时，这些专家一再强调要谨慎使用面向对象和设计模式，否则后果就是苦果。我在应用面向对象时一向比较小心，一步一步的学习使用，而不是一步到位，毕竟我是个初学者。
再举一个例子。我们的系统中有一个连接类，大家都知道这个类是用来连接数据库的。不过我想很少有人知道为什么设计者要设计出这样一个类来。是因为他刚刚读
过设计模式中有一个“单例模式”。对于我们现在的这个系统来说，使用一个数据库连接对象就可以了，设计者为了避免每个程序员都去创建新的数据库连接，就使
用“单例模式”设计出一个连接类来。“单例模式”的用意就是某个类的实例在整个系统中只能有一个实例存在。比如我们用的windows剪贴板，在整个系统
中只能有一个剪贴板，大家都不会去new一个新的剪贴板出来。
我感到非常的郁闷，在一个公用模块里申明一个系统变量connection就可以了，告诉大家这个对象是我们的数据库连接对象，大家都用这个对象，为什么
再来一个clsConnection类对connection重新包装一下？，这反而就有问题了，我可以new出无数个clsConnection的实
例，没有达到“单例模式”的用意，因为在clsConnection类里没有提供静态方法来总是返回系统中已经存在的连接对象，这成了“多例模式”了。也
许设计者的另一个用意是要使用设计模式中的“简单工厂模式”。不过，不管是想练习什么模式，对于一个connection根本没有必要再包装了。这好比我
们有一个系统级变量，为了避免大家都去申明这个变量就用一个类来包装这个变量。那么系统中已经存在这样一个类，为了避免大家乱用这个类，就再来一个类来包
装这个类？层层包裹下去，怎么才算安全？（这里的例子是应用VB做的系统，JAVA使用者请勿随意理解。这里有语言差异。）
使用面向对象设计技术会产生良好的系统，但是，类是面向对象中的东西，那么类爆炸也必然是使用面向对象的产物，这是不良设计导致的。
我们有的程序员有些过于遵守规范而显得有些刻板了。举个例子。某个程序员做了一个类A和一个类B，实体B是实体A的载体（规范中要求每个实体都要对应一个
类），类A提供了一个修改自身的方法，当实体B的某个属性改变时必须要改变实体A的某个属性。我看了源代码，发现一条SQL语句就可以解决这个问题，但是
这个程序员为了用类A的修改方法，在类B中写了一个循环，先找出所有属于实体B的实体A，并创建类A的实例，然后调用类A的修改方法。代码不但冗长还效率
低下。这个程序员有自已的理由去那样做，理由1是上面领导制定的规范要求这样做，理由2是这是一种面向对象的应用，因为类A已经提供了修改实体A的方法，
别人就应该重用这个方法。一切讲究重用。
我想提出的是，如果重用这个方法即不使代码简洁又不能提高效率而且还造成强烈的耦合，为什么还要重用它？在面向对象中，大家知道类的构造函数是用来做什么
的吗？重载方法又是为什么吗？为什么一个类可以有多个不同的构造函数？不同的构造函数是为了达到不同的目的，而不仅仅是为了实例化一个类。方法的重载也是
为了实现不同的目的。当类A提供的方法不能很好的完成任务时，我们就应该舍弃它或者重载它。如果规范要求必须类B调用类A的方法（这个“必须”很值得疑
问）时，那么应该在类A中提供不同的修改方法以使设计合理。类A可以有这样的两个方法：方法1（以实体A自身的引用为参数）,方法2（以实体B的引用为参
数）。
关于重用。
我们现在设计系统一直想达到重用的目的。但是考虑我们所做软件的性质，我们对系统组件应该达到什么样的重用程度。我们的组件是不是要发布出去供第三方二次
开发？我们的组件是不是每年能达到2次重用？业务组件和与业务无关的组件重用的能力是不是有很大区别？我们不同的客户的业务规范是不是相差比较大？
由于我们现在对业务抽象的不到位，设计出来的类的粒度控制的不够好。业务相关和业务无关的对象的分离做的不够好，因此，实现组件甚至一个子系统的重用是很难的，只能为不同的客户去修改现有的代码，这显然不是重用，而是维护。我们的代码一年连一次重用的机会都没有。
关于创新。
如果没有创新的设计，后果是可想而知的，不管我们了解的业务再多，我们总是用最原始或者最笨拙的设计去实现业务。这样我们对业务了解的越多，系统做的越
大，代码就越混乱越不稳定。能达到将就凑乎的使用已经是不错的了。当硬件技术飞速发展的时候，软件技术却落后，结果是什么？那么，在我们公司，业务和技
术，哪个是硬件哪个是软件？当所有程序员都意识到争当项目经理和项目组长可以不去编写程序而待遇却提高了时，结果是什么？设计需要创新，了解业务却是一种
带有明显的“被动”特征。用户不告诉你他的业务规则你就不知道，告诉你，你就知道。当用户停止提供需求时，这段时间内，需求调研人员应该做什么工作？是不
是留下了大量的需求文档，是不是去抽象业务规则了？需求调研人员是不是能发现不同客户的不同业务之间的相似性为设计人员提供指导？
我们无法为客户去创新业务，但我们应该去创新我们的设计。一个软件的设计很难保持三年不变，如果三年后还不能有所创新而发生变换，那就落后了。为了适应新
的形式，微软敢于修改自己的操作系统的内核使系统升级。不升级意味着失去财富，而升级时难免要修改部分内核。那么，应用创新技术付出的代价大还是保持原有
系统不变的受益大？我们要考虑新系统生产时的阵痛和它以后带来的长远利益。
公司的人员流动的特征我们是否加以分析了，流走的是什么的样人，进来的又是什么样的人。这些人的技术能力、性格、悟性又是如何？我们拥有了许多安于现状不
具创新的老员工，我们该怎么对待他们？如果一个员工的性格激烈但悟性良好能有创新，我们是不是排击他了？兢兢业业、按部就班、任由指挥是不是就是一个优秀
的员工？
一个公司，各种性格的员工的存在应该有一个比例。全部都是不安分的创新者是不好的，充斥大量的安分守己、明哲保身、上面怎么说下面就怎么做的员工也是不好的现象。公司员工的性格和悟性的分布应该象一个波浪一样，有浪头有浪波，这样才能形成巨浪。
关于沟通。
公司越大，我发现员工之间的沟通越差。当我们还是一家小公司的时候，我可以认识所有的人，现在仅能认识个别几个人。沟通，不是由领导来强调下面的人去做
的，而是由领导来启动和带动的。所谓“领导”两个字，就是“领”和“导”，什么意思？大家自然知道。如何才能称得上一个领导，他必须具有领头和导向的作
用。各个部门的领导肩负着不同的“领导”。技术领导，他的技术是不是一定要强？若不强，是不是他能通过沟通的艺术来让下面的人服从？
沟通是一个大的问题。比如我早已经应用过一个比较好的数据库设计模型，但是新项目的设计者从来也没有咨询过我是怎么做的，结果他自己搞出一个很糟糕的数据
模型。沟通是一个双向过程。被动的沟通与主动的沟通的效果自然是不同的。我们现在缺乏主动沟通，就是被动沟通都不能好好的参与。所以，沟通出现了“推模
式”和“拉模式”。举个例子，我有些编程技巧放到公司网站了，很少有人去用主动的看，如果他主动去看了，这种行为模式称作“拉模式”。为了让更多的人知道
我的技巧，我只能主动把技术文章发到每个人的邮箱里，我的这种行为模式是一种“推模式”。我把技术文章推到每个人的邮箱里了，那么接收邮件的人是不是“拉
过来”看一眼？我发现，有一部分人是从来不看的，技术人员也不看。到底为什么不看？看不起我的文章还是太了解我而觉得没有必要看？他的心态我没有办法了
解，总之，沟通是有障碍的。
“聚集”沟通需要大家坐在一起去探讨某些问题，但这可能会浪费参与人的时间。因此我一直以为“推模式”的沟通还是可取的。使用邮件来沟通，想看则看不想看
就不看，尊重接收邮件的人的参与意识。但是发邮件会引来一些误会。一部分人会把你的邮件当作垃圾，心里不喜欢你给他发邮件但又不能说出来。一部分人会认为
发邮件的人脑子有毛病或者出风头，我觉得应该让每一个人都摆正心态：尊重发邮件的人。历来都有“枪打出头鸟”的现象，人在浪头上，难免遭遇不恰当的言语。
因此，永远低调和保持沉默便成为一种人生哲学。激进主义是用来推动社会前进的，保守主义是用来维持社会稳定的。我们允许这些同时存在。
由对事演化到对人。
当我们探讨问题时一般都是本着“对事不对人”的态度的。对于言者也许是这样的心里，但听者可能认为言者就是“对人不对事”。我们没有办法使他消除那种心里，因为那是他的性格使然。但是我们希望每个人都心胸开阔一些。
在探讨关于类爆炸的问题时，我说了一些题外话。
当我和一些同事在探讨设计中的缺陷时，发现大家的眼睛都还是明亮的，知道问题所在。不幸的是，几乎所有的人保都持沉默而不将问题暴露出来。当我暴露问题时，会得到个别人的善意的奉劝：“不要去做”。
//CatchMice.java
//还有部分功能未实现，自己去搞吧
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.*;
public class CatchMice {
public static void main(String[] args) {
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new Mice().setUser("Haha"));
f.pack();
f.setResizable(false);
f.setLocationRelativeTo(null);
f.setVisible(true);
}
}
class Mice extends Canvas implements MouseListener,MouseMotionListener{
private String url=":";//老鼠图片
private int index=-1;
private int score;
private int initDelay=2000;
private int delay = initDelay;
private int level = 1;
private int gradeScore=160;
private int caughtScore=10;
private Image mice;
private BufferedImage bimg;
private int cellW=80,cellH=80,r=4,c=4;//53
private Rectangle rec;
private String user;
private Thread t;
private long time;
private boolean pause,gameover;
public Mice(){
try{
bimg=ImageIO.read(new URL(url));
mice=bimg.getSubimage(0,0,cellW,cellH);
bimg=null;
}catch(Exception e){
if(bimg==null){
bimg=new BufferedImage(cellW,cellH,BufferedImage.TYPE_INT_ARGB);
Graphics2D g = bimg.createGraphics();
g.setColor(Color.LIGHT_GRAY);
g.drawOval(10,10,cellW-20,cellH-20);
g.dispose();
mice=bimg.getSubimage(0,0,cellW,cellH);
bimg=null;
}
};
setPreferredSize(new Dimension(cellW*c,cellH*r+60));
index=next();
rec = new Rectangle(0,0,cellW,cellH);
this.addMouseListener(this);
this.addMouseMotionListener(this);
}
public Mice setUser(String u){user=u;return this;}
private int next(){
int next = (int)(Math.random()*r*c);
return index==next?next():next;
}
public void paint(Graphics gg){
Graphics g=gg.create();
g.setColor(Color.white);
g.fillRect(0,0,cellW*c,cellH*r);
g.setColor(Color.gray);
for(int i=0; ir*c; i++){
if(i==index){
g.drawImage(mice,i%c*cellW,i/r*cellH,this);
rec.setLocation(i%c*cellW,i/r*cellH);
}
g.drawRect(i%c*cellW,i/r*cellH,cellW,cellH);
}
g.setColor(Color.DARK_GRAY);
g.setColor(Color.blue);
String info = "User:"+user+" Level:"+level+" Score:"+score+" Delay:"+delay;
g.drawString(info,1,r*cellH+16);
g.dispose();
if(t==null){
start();
}
}
private void start(){
time = System.currentTimeMillis();
t=new Thread(){
public void run(){
while(true){
if(pause){
time=System.currentTimeMillis();
try{sleep(50);}catch(Exception e){}
continue;
}
if(!gameovertime+delaySystem.currentTimeMillis()){
gameOver();
}
if(!gameover)
drawTime();
else
drawGameOver();
try{sleep(50);}catch(Exception e){}
}
}
};
t.start();
}
private void drawGameOver() {
Graphics g = this.getGraphics();
g.setColor(Color.DARK_GRAY);
g.fillRect(0,r*cellH+18,80,18);
if(System.currentTimeMillis()%1000500){
g.setColor(Color.yellow);
g.drawString("Game over!",4,r*cellH+32);
}
g.dispose();
}
private void drawTime() {
Graphics g = this.getGraphics();
long t = delay+time-System.currentTimeMillis();;
g.setColor(Color.DARK_GRAY);
g.fillRect(0,r*cellH+18,48,18);
g.setColor(Color.yellow);
g.drawString(""+t,4,r*cellH+32);
g.dispose();
}
private void gameOver() {
gameover=true;
index=-1;
repaint();
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {
// if(!gameoverrec.contains(e.getPoint())){
// index=next();
// time=System.currentTimeMillis();
// score+=caughtScore;
// level=score/gradeScore+1;
// delay=initDelay;
// for(int i=0; ilevel-1; i++)
// delay=(int)(delay*2f/3);
// repaint();
// }
}
public void mouseReleased(MouseEvent e) {}
public void mouseDragged(MouseEvent e) {}
public void mouseMoved(MouseEvent e) {
if(!gameoverrec.contains(e.getPoint())){
index=next();
time=System.currentTimeMillis();
score+=caughtScore;
level=score/gradeScore+1;
delay=initDelay;
for(int i=0; ilevel-1; i++)
delay=(int)(delay*2f/3);
repaint();
}
}
}
以下从技术角度就常见的保护措施 和常用工具来看看如何有效保护java代码：1. 将java包装成exe 特点：将jar包装成可执行文件，便于使用，但对java程序没有任何保护。不要以为生成了exe就和普通可执行文件效果一样了。这些包装成exe的程序运行时都会将jar文件释放到临时目录，很容易获取。常用的工具有exe4j、jsmooth、NativeJ等等。jsmooth生成的exe运行时临时目录在exe所在目录中或是用户临时目录 中；exe4j生成的exe运行时临时目录在用户临时目录中；NativeJ生成的exe直接用winrar打开，然后用zip格式修复成一个jar文件，就得到了原文件。如果只是为了使用和发布方便，不需要保护java代码，使用这些工具是很好的选择。2. java混淆器特点：使用一种或多种处理方式将class文件、java源代码进行混淆处理后生成新的class，使混淆后的代码不易被反编译，而反编译后的代码难以阅 读和理解。这类混淆器工具很多，而且也很有成效。缺点：虽然混淆的代码反编译后不易读懂，但对于有经验的人或是多花些时间，还是能找到或计算出你代码中隐藏的敏感内容，而且在很多应用中不是全部代码都能混淆的，往往一些关键的库、类名、方法名、变量名等因使用要求的限制反而还不能混淆。3. 隔离java程序到服务端特点：把java程序放到服务端，让用户不能访问到class文件和相关配套文件，客户端只通过接口访问。这种方式在客户/服务模式的应用中能较好地保护java代码。缺点是：必须是客户/服务模式，这种特点限制了此种方式的使用范围；客户端因为逻辑的暴露始终是较为薄弱的环节，所以访问接口时一般都需要安全性认证。4. java加密保护特点：自定义ClassLoader，将class文件和相关文件加密，运行时由此ClassLoader解密相关文件并装载类，要起到保护作用必须自定 义本地代码执行器将自定义ClassLoader和加密解密的相关类和配套文件也保护起来。此种方式能很有效地保护java代码。缺点：可以通过替换JRE包中与类装载相关的java类或虚拟机动态库截获java字节码。 jar2exe属于这类工具。5. 提前编译技术(AOT) 特点：将java代码静态编译成本地机器码，脱离通用JRE。此种方式能够非常有效地保护java代码，且程序启动比通用JVM快一点。具有代表性的是GNU的gcj，可以做到对java代码完全提前编译，但gcj存在诸多局限性，如：对JRE 5不能完整支持、不支持JRE 6及以后的版本。由于java平台的复杂性，做到能及时支持最新java版本和JRE的完全提前编译是非常困难的，所以这类工具往往采取灵活方式，该用即时编译的地方还是 要用，成为提前编译和即时编译的混合体。缺点：由于与通用JRE的差异和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；只能使用此种工具提供的一个运行环境，如果工具更新滞后或你需要特定版本的JRE，有可能得不到此种工具的支持。 Excelsior JET属于这类工具。6. 使用jni方式保护特点：将敏感的方法和数据通过jni方式处理。此种方式和“隔离java程序到服务端”有些类似，可以看作把需要保护的代码和数据“隔离”到动态库中，不同的是可以在单机程序中运用。缺点和上述“隔离java程序到服务端”类似。7. 不脱离JRE的综合方式保护特点：非提前编译，不脱离JRE，采用多种软保护方式，从多方面防止java程序被窃取。此种方式由于采取了多种保护措施，比如自定义执行器和装载器、加密、JNI、安全性检测、生成可执行文件等等，使保护力度大大增强，同样能够非常有效地保护java代码。缺点：由于jar文件存在方式的改变和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；很有可能并不支持所有的JRE版本。 JXMaker属于此类工具。8. 用加密锁硬件保护特点：使用与硬件相关的专用程序将java虚拟机启动程序加壳，将虚拟机配套文件和java程序加密，启动的是加壳程序，由加壳程序建立一个与硬件相关的 受保护的运行环境，为了加强安全性可以和加密锁内植入的程序互动。此种方式与以上“不脱离JRE的综合方式保护”相似，只是使用了专用硬件设备，也能很好地保护java代码。缺点：有人认为加密锁用户使用上不太方便，且每个安装需要附带一个。从以上描述中我们可以看出：1. 各种保护方式都有其优缺点，应根据实际选用2. 要更好地保护java代码应该使用综合的保护措施3. 单机环境中要真正有效保护java代码，必须要有本地代码程序配合当然，安全都是相对的，一方面看你的保护措施和使用的工具能达到的程度，一方面看黑客的意愿和能力，不能只从技术上保护知识产权。总之，在java 代码保护方面可以采取各种可能的方式，不可拘泥于那些条条框框。
代码有点多, 实现思路, 实现键盘事件监听机制, 在监听函数中判断 按了什么键,比如按J就发送子弹. 然后启动子弹线程. 定义一个子弹类线程, 定义出子弹的所在属性和方法.
写个方法,判断子弹是否击中目标,以XY坐标相交来判断
Shape.java接口代码
public interface Shape {
public static final double PI = 3.14d;
public double area();
}
Circle.java圆类代码
public class Circle implements Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return PI * this.radius * this.radius;
}
public double perimeter() {
return 2 * PI * this.radius;
}
}
Cylinder.java圆柱体类代码
public class Cylinder extends Circle {
private double height;
public Cylinder(double radius, double height) {
super(radius);
this.height = height;
}
public double area() {
return 2 * super.area() + super.perimeter() * this.height;
}
public double volume() {
return super.area() * this.height;
}
}
X5_3_6.java主类代码
public class X5_3_6 {
public static void main(String[] args) {
Circle cir1 = new Circle(5);
System.out.println("圆的面积为：" + cir1.area());
System.out.println("圆的周长为：" + cir1.perimeter());
Cylinder cy1 = new Cylinder(10, 15);
System.out.println("圆柱体的表面积为：" + cy1.area());
System.out.println("圆柱体的体积为：" + cy1.volume());
}
}
上面是我写的代码，下图是执行结果，麻烦看一下，是否可以。
重庆分公司
重庆分公司
