㈠ java中.html文件和.java文件的用途及运行环境
您好，这样的：
解析HTML文档的Java程序
下面是一个解析HTML字符串，网络上下载的HTML文件，以及本地文件系统中的HTML文件的完整的Java程序。你可以使用Eclipse IDE或者别的IDE甚至命令来运行这个程序。在Eclipse里面则很简单，拷贝这份代码，新建一个Java工程，在src包上右键并粘贴进去就可以了。Eclipse会去创建正确的包及同名的Java源文件的，因此工作量最小。如果你已经有一个Java示例工程了，那么仅需一步就可以了。下面的这个Java程序展示了解析及遍历HTML文件的三个不同例子。第一个例子中，我们直接解析了一个内容为HTML的字符串，第二个例子中我们解析了一个从URL中下载的HTML文件，第三个中我们从本地文件系统中加载了一个HTML文档并进行解析。第一和第三个例子中都用到了parse方法来获取一个Document对象，你可以查询它来提取出任何的标签值或者属性值。第二个例子中，我们用到了Jsoup.connect方法，它会去创建URL的连接，下载HTML并进行解析。这个方法也会返回Document，它可以用于后续的查询及获取标签或者属性的值。
import java.io.IOException;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
/**
[*] Java Program to parse/read HTML documents from File using Jsoup library.
[*] Jsoup is an open source library which allows Java developer to parse HTML
[*] files and extract elements, manipulate data, change style using DOM, CSS and
[*] JQuery like method.
[*]
[*] @author Javin Paul
[*]/
public class HTMLParser{
public static void main(String args[]) {
// Parse HTML String using JSoup library
String HTMLSTring = "<!DOCTYPE html>"
+ "<html>"
+ "<head>"
+ "<title>JSoup Example</title>"
+ "</head>"
+ "<body>"
+ "|[b]HelloWorld[/b]"
+ ""
+ "</body>"
+ "</html>";
Document html = Jsoup.parse(HTMLSTring);
String title = html.title();
String h1 = html.body().getElementsByTag("h1").text();
System.out.println("Input HTML String to JSoup :" + HTMLSTring);
System.out.println("After parsing, Title : " + title);
System.out.println("Afte parsing, Heading : " + h1);
// JSoup Example 2 - Reading HTML page from URL
Document doc;
try {
doc = Jsoup.connect("http://google.com/").get();
title = doc.title();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Jsoup Can read HTML page from URL, title : " + title);
// JSoup Example 3 - Parsing an HTML file in Java
//Document htmlFile = Jsoup.parse("login.html", "ISO-8859-1"); // wrong
Document htmlFile = null;
try {
htmlFile = Jsoup.parse(new File("login.html"), "ISO-8859-1");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} // right
title = htmlFile.title();
Element div = htmlFile.getElementById("login");
String cssClass = div.className(); // getting class form HTML element
System.out.println("Jsoup can also parse HTML file directly");
System.out.println("title : " + title);
System.out.println("class of div tag : " + cssClass);
}
}
输出：
Input HTML String to JSoup :<!DOCTYPE html><html><head><title>JSoup Example</title></head><body><table><tr><td><h1>HelloWorld</h1></tr></table></body></html>
After parsing, Title : JSoup Example
Afte parsing, Heading : HelloWorld
Jsoup Can read HTML page from URL, title : Google
Jsoup can also parse HTML file directly title : Login Page
class of div tag : simple
Jsoup的好处就是它的健壮性很强。Jsoup HTML解析器会对你提供的HTML进行尽量干净的解析，而不去考虑这个HTML是否是格式良好的。它可以处理如下这些错误：未闭合的标签（比如，Java <p>Scala to <p>JavaScala)，隐式标签（比如，一个裸的|Java is Great被封装到了|里面），它总能创建出一个文档结构（包含head及body的HTML，并且head里只会包含正确的元素）。这就是在Java中如何进行HTML的解析。Jsoup是一个优秀的健壮的开源库，它使得读取HTML文档，body片段，HTML字符串，以及直接从WEB中解析HTML内容都变得相当简单。在这篇文章中，我们学习了如何在Java中获取一个特定的HTML标签，正如第一个例子中我们将title及H1标签的值提取成了文本，而第三个例子中我们学习到了如何通过提取CSS属性来从HTML标签中获取属性值。除了强大的jQuery风格的html.body().getElementsByTag("h1").text()方法，你还可以提取任意的HTML标签，它还提供了像Document.title()和Element.className()这样便捷的方法，你可以快速获取到标题及CSS类。希望JSoup能让你玩得愉快，很快我们将会看到关于这个API的更多的一些例子。
㈡ 想用nodesjs做后台获取 java后台接口参数，这样可行吗
用nodesjs做后台获取 java后台接口参数，这是可以的。把java所以数据操作做成接口，让nodejs调用！
㈢ Java一个组织树里边增加一个节点，然后把另一个节点下面的数据放在新创建的这个节点里。如何实现
</script>
<!--表格树js-->
<script>
$(function(){
varsetting={
view:{showLine:true,showIcon:false},//有没有连线和显不示显示图标
//下面语句可以让pid相同的分层
data:{
simpleData:{
enable:true//自动成圣树结构
}
},
callback:{
onClick:zTreeOnClick//回调点击函数
}
};
//动态获取数据自动生成树
$.ajax({
type:"post",
url:"../tools/admin_ajax.ashx?action=GetCallContent&time="+Math.random(),//链接地址
dataType:"html",
success:function(data){
//转换一下json
varmyNodes=JSON.parse(data);
varzNodes=[];
//alert(myNodes);
for(vari=0;i<myNodes.length;i++){//判断
if(myNodes[i].open!=null){
if(myNodes[i].checked!=null&&myNodes[i].checked)
zNodes[i]={id:myNodes[i].id,pId:myNodes[i].pId,name:myNodes[i].name,answer:myNodes[i].answer,open:true,checked:true};
else
zNodes[i]={id:myNodes[i].id,pId:myNodes[i].pId,name:myNodes[i].name,answer:myNodes[i].answer,open:true};
}
else{
if(myNodes[i].checked!=null&&myNodes[i].checked)
zNodes[i]={id:myNodes[i].id,pId:myNodes[i].pId,name:myNodes[i].name,answer:myNodes[i].answer,checked:true};
else
zNodes[i]={id:myNodes[i].id,pId:myNodes[i].pId,name:myNodes[i].name,answer:myNodes[i].answer,};
}
}
$.fn.zTree.init($("#demoZtree"),setting,zNodes);//初始化树
$.fn.zTree.getZTreeObj("#demoZtree");//把得到的树赋给div
}
});
//动态生成树的ztree子节点点击事件
functionzTreeOnClick(event,treeId,treeNode){
//alert(treeNode.tId+","+treeNode.name);
$("#eventProblemDesc1").html(treeNode.name);//把标题赋值给div
//插入节点到右边的框内$("#tab_content_ztree_explain").html(treeNode.name+':');
$.ajax({
type:"get",
url:"../tools/admin_ajax.ashx?action=GetCallContent&time="+Math.random(),
dataType:"html",
success:function(data){
//转换一下
varmyNodes=JSON.parse(data);
varzNodes=[];
//利用Selected获取zTree当前被选中的节点数据集合
vartreeObj=$.fn.zTree.getZTreeObj("demoZtree");
varnodes=treeObj.getSelectedNodes();
//console.log(nodes);
for(vari=0;i<myNodes.length;i++){
varitem=myNodes[i];
if(item.id==nodes[0].id){//<spanstyle="font-family:Arial,Helvetica,sans-serif;">判断树节点与点击的节点对应的id是否相等</span>
//alert(item);
varcont='';
cont+=item.answer;
$('#tab_content_ztree_explain').html(cont);//赋值给div
//$('treeNode.name').html(answ);
}
}
}
});
};
});
</script>
㈣ 请问这个树状图在Java中应该怎么做
打个比方
可以写一个Tree的类
public class Tree extends BaseDomain {private String id;
private String key;
private String icon;
private String title;
private String value;
private String text;
private String code;
private String mtype;
private String type;
/**
* 部门的特殊个别字段
* 1.部门 / 2.岗位 的编码
*/
private String number;
private Double order;
private Double sort;
private String href;
private String component;
private List<Tree<T>> children;
private String parentId;
private boolean hasParent = false;
private boolean hasChildren = false;
private Date createTime;
private Date modifyTime;
public void initChildren(){
this.children = new ArrayList<>();
}
}
在写一个工具类
public class TreeUtil {
protected TreeUtil() {
}
private final static String TOP_NODE_ID = "0";
/**
* 用于构建菜单
*
* @param nodes nodes
* @param <T> <T>
* @return <T> Tree<T>
*/
public static <T> Tree<T> build(List<Tree<T>> nodes) {
if (nodes == null) {
return null;
}
List<Tree<T>> topNodes = new ArrayList<>();
nodes.forEach(node -> {
String pid = node.getParentId();
if (pid == null || TOP_NODE_ID.equals(pid)) {
topNodes.add(node);
return;
}
for (Tree<T> n : nodes) {
String id = n.getId();
if (id != null && id.equals(pid)) {
if (n.getChildren() == null)
n.initChildren();
n.getChildren().add(node);
node.setHasParent(true);
n.setHasChildren(true);
n.setHasParent(true);
return;
}
}
if (topNodes.isEmpty())
topNodes.add(node);
});
Tree<T> root = new Tree<>();
root.setId("0");
root.setParentId("");
root.setHasParent(false);
root.setHasChildren(true);
root.setChildren(topNodes);
root.setText("root");
return root;
}}
写完了这两个在写业务层
一个构建书的方法
private void buildTrees(List> trees, List menus, List ids) {
menus.forEach(menu -> {
ids.add(menu.getId().toString());
Tree tree = new Tree<>();
tree.setId(menu.getId().toString());
tree.setKey(tree.getId());
tree.setParentId(menu.getParentId().toString());
tree.setText(menu.getName());
tree.setTitle(tree.getText());
tree.setIcon(menu.getIcon());
tree.setComponent(menu.getComponent());
tree.setCreateTime(menu.getCreateTime());
tree.setCreateTime(menu.getCreateTime());
tree.setHref(menu.getHref());
tree.setSort(menu.getSort());
tree.setCode(menu.getCode());
tree.setMtype(menu.getMtype());
trees.add(tree);
});
}Map<String, Object> result = new HashMap<>();
List<Dept> depts = findDepts(dept, request);
List<Tree<Dept>> trees = new ArrayList<>();
buildTrees(trees, depts);
Tree<Dept> deptTree = TreeUtil.build(trees);
result.put("rows", deptTree);
result.put("total", depts.size());
㈤ 请问谁能看明白这段代码 java的
这个方法的作用是检查由所有Nodes构成的图是否存在环。m_nNodes定义了结点数，m_bits应该是定义了结点间的连接关系。
三个for循环，第一个是遍历所有结点，第二个是根据当前遍历的结点，遍历所有其他结点，找出两个结点间的关系。第三个是判断是否存在环。
但是我感觉代码似乎有逻辑问题。
㈥ java 什么是单向链表 和 双向链表
链表是类似一种数据结构的东西，就是分别存放有地址以及数据单项链表一般是上一个存放地址的地方存放下一个节点的地址，而双向的就是有两个存放地址的地方，分别存上一个以及下一个的地址。大概是这样子
㈦ JAVA point类和链表的问题
练习了一下，我机子上的JRE 是特别的。。。所以可能有些问题。。。共同进步啊。。。有优化的也提出来。。。
两个类
Node.java===========================================
package nodeLink;
public class Node {
public int x = 0 ;
public int y = 0;
public Node next = null;
public int getDistance()
{
int distance = 0;
distance = (int)java.lang.Math.sqrt(this.x * this.x + this.y * this.y);
return distance;
}
public Node()
{
//
}
public Node( int x , int y)
{
this.x = x;
this.y = y;
}
}
NodeLink.java==============================================
package nodeLink;
import java.util.Random;
public class NodeLink {
Node nodes[] = null;
public NodeLink(Node[] nodes)
{
this.nodes = nodes;
}
public NodeLink()
{
}
public Node[] Reverse()
{
Node nodesRev[] = null;
nodesRev = new Node[this.nodes.length];
for(int i=0;i<this.nodes.length ; i++)
{
nodesRev[this.nodes.length -i -1 ]= this.nodes[i];
if(i>=1)
nodesRev[this.nodes.length -i-1 ].next = this.nodes[i-1];
}
return nodesRev;
}
public Node[] Sort()
{
Node nodesSort[] = null;
Node nodeTemp = null;
//init nodesSort
nodesSort = new Node[this.nodes.length];
for(int i = 0;i<this.nodes.length ;i++)
nodesSort[i]= this.nodes[i];
for(int i=0;i<nodesSort.length-1;i++)
{
for (int j=i+1;j<nodesSort.length;j++)
{
if(nodesSort[i].getDistance() > nodesSort[j].getDistance())
{
nodeTemp = nodesSort[i];
nodesSort[i]=nodesSort[j];
nodesSort[j]=nodeTemp;
}
}
}
for(int i = 0;i<nodesSort.length;i++)
{
if (i < nodesSort.length -1)
nodesSort[i].next = nodesSort[i+1];
}
return nodesSort;
}
public void print()
{
for(int i = 0;i<this.nodes.length;i++)
{
System.out.println( Integer.toString(i) + " "
+ this.nodes[i].x + " "
+ this.nodes[i].y + " "
+ this.nodes[i].getDistance());
}
}
public static void printLink( Node[] nodes)
{
for(int i = 0;i< nodes.length;i++)
{
System.out.println( Integer.toString(i) + " "
+ nodes[i].x + " "
+ nodes[i].y + " "
+ nodes[i].getDistance());
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("test NodeLink");
//利用随机函数定义10对(x,y)值，由此创建的Point类实例存入一个数组中
Node nodeArray[] = new Node[10];
Node nodeTemp = null;
Random r = new Random();
int x = 0;
int y = 0;
for(int i=0;i<nodeArray.length;i++)
{
x = r.nextInt(100);
if( x < 50) x = x + 50;
y = r.nextInt(100);
if( y < 50) y = y + 50;
nodeArray[i]= new Node(x , y);
}
System.out.println("Original List");
NodeLink.printLink(nodeArray);
Node nodesRev[] = null;
Node nodesSort[] = null;
NodeLink nodeLink = new NodeLink(nodeArray);
//按与原点（0，0）的距离由小到大的顺序输出所有的点及到原点的距离
System.out.println("Sort it");
nodesSort = nodeLink.Sort();
NodeLink.printLink(nodesSort);
//编程实现根据一个已存在的链表创建一个倒序链表。
System.out.println("Reverse it");
nodesRev = nodeLink.Reverse();
NodeLink.printLink(nodesRev);
}
}
㈧ 简单的JAVA多叉树问题实现
TreeNode.java
/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名称：TreeNode.java
*摘要：
*作者：Walker
*创建时间：2013-03-19
*/
packagecom.walker.commons.data.model;
/**
*树节点
*
*@authorWalker
*@version1.0.0.0
*/
publicclassTreeNode
{
/**节点Id*/
privateStringnodeId;
/**父节点Id*/
privateStringparentId;
/**文本内容*/
privateStringtext;
/**
*构造函数
*
*@paramnodeId节点Id
*/
publicTreeNode(StringnodeId)
{
this.nodeId=nodeId;
}
/**
*构造函数
*
*@paramnodeId节点Id
*@paramparentId父节点Id
*/
publicTreeNode(StringnodeId,StringparentId)
{
this.nodeId=nodeId;
this.parentId=parentId;
}
publicStringgetNodeId(){
returnnodeId;
}
publicvoidsetNodeId(StringnodeId){
this.nodeId=nodeId;
}
publicStringgetParentId(){
returnparentId;
}
publicvoidsetParentId(StringparentId){
this.parentId=parentId;
}
publicStringgetText(){
returntext;
}
publicvoidsetText(Stringtext){
this.text=text;
}
}
ManyTreeNode.java
/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名称：ManyTreeNode.java
*摘要：
*作者：Walker
*创建时间：2013-03-19
*/
packagecom.walker.commons.data.model;
importjava.util.ArrayList;
importjava.util.List;
/**
*多叉树节点
*
*@authorWalker
*@verion1.0.0.0
*/
publicclassManyTreeNode
{
/**树节点*/
privateTreeNodedata;
/**子树集合*/
privateList<ManyTreeNode>childList;
/**
*构造函数
*
*@paramdata树节点
*/
publicManyTreeNode(TreeNodedata)
{
this.data=data;
this.childList=newArrayList<ManyTreeNode>();
}
/**
*构造函数
*
*@paramdata树节点
*@paramchildList子树集合
*/
publicManyTreeNode(TreeNodedata,List<ManyTreeNode>childList)
{
this.data=data;
this.childList=childList;
}
publicTreeNodegetData(){
returndata;
}
publicvoidsetData(TreeNodedata){
this.data=data;
}
publicList<ManyTreeNode>getChildList(){
returnchildList;
}
publicvoidsetChildList(List<ManyTreeNode>childList){
this.childList=childList;
}
}
ManyNodeTree.java
/*
*CopyrightWalkerStudio
*AllRightsReserved.
*
*文件名称：ManyNodeTree.java
*摘要：
*作者：Walker
*创建时间：2013-03-19
*/
packagecom.walker.commons.data.model;
importjava.util.ArrayList;
importjava.util.List;
/**
*多叉树生成、遍历工具
*
*@authorWalker
*@version1.0.0.0
*/
publicclassManyNodeTree
{
/**树根*/
privateManyTreeNoderoot;
/**
*构造函数
*/
publicManyNodeTree()
{
root=newManyTreeNode(newTreeNode("root"));
}
/**
*生成一颗多叉树，根节点为root
*
*@paramtreeNodes生成多叉树的节点集合
*@returnManyNodeTree
*/
publicManyNodeTreecreateTree(List<TreeNode>treeNodes)
{
if(treeNodes==null||treeNodes.size()<0)
returnnull;
ManyNodeTreemanyNodeTree=newManyNodeTree();
//将所有节点添加到多叉树中
for(TreeNodetreeNode:treeNodes)
{
if(treeNode.getParentId().equals("root"))
{
//向根添加一个节点
manyNodeTree.getRoot().getChildList().add(newManyTreeNode(treeNode));
}
else
{
addChild(manyNodeTree.getRoot(),treeNode);
}
}
returnmanyNodeTree;
}
/**
*向指定多叉树节点添加子节点
*
*@parammanyTreeNode多叉树节点
*@paramchild节点
*/
publicvoidaddChild(ManyTreeNodemanyTreeNode,TreeNodechild)
{
for(ManyTreeNodeitem:manyTreeNode.getChildList())
{
if(item.getData().getNodeId().equals(child.getParentId()))
{
//找到对应的父亲
item.getChildList().add(newManyTreeNode(child));
break;
}
else
{
if(item.getChildList()!=null&&item.getChildList().size()>0)
{
addChild(item,child);
}
}
}
}
/**
*遍历多叉树
*
*@parammanyTreeNode多叉树节点
*@return
*/
publicStringiteratorTree(ManyTreeNodemanyTreeNode)
{
StringBuilderbuffer=newStringBuilder();
buffer.append(" ");
if(manyTreeNode!=null)
{
for(ManyTreeNodeindex:manyTreeNode.getChildList())
{
buffer.append(index.getData().getNodeId()+",");
if(index.getChildList()!=null&&index.getChildList().size()>0)
{
buffer.append(iteratorTree(index));
}
}
}
buffer.append(" ");
returnbuffer.toString();
}
publicManyTreeNodegetRoot(){
returnroot;
}
publicvoidsetRoot(ManyTreeNoderoot){
this.root=root;
}
publicstaticvoidmain(String[]args)
{
List<TreeNode>treeNodes=newArrayList<TreeNode>();
treeNodes.add(newTreeNode("系统权限管理","root"));
treeNodes.add(newTreeNode("用户管理","系统权限管理"));
treeNodes.add(newTreeNode("角色管理","系统权限管理"));
treeNodes.add(newTreeNode("组管理","系统权限管理"));
treeNodes.add(newTreeNode("用户菜单管理","系统权限管理"));
treeNodes.add(newTreeNode("角色菜单管理","系统权限管理"));
treeNodes.add(newTreeNode("用户权限管理","系统权限管理"));
treeNodes.add(newTreeNode("站内信","root"));
treeNodes.add(newTreeNode("写信","站内信"));
treeNodes.add(newTreeNode("收信","站内信"));
treeNodes.add(newTreeNode("草稿","站内信"));
ManyNodeTreetree=newManyNodeTree();
System.out.println(tree.iteratorTree(tree.createTree(treeNodes).getRoot()));
}
}
㈨ java贪吃蛇代码注释求解
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
public class InterFace extends JFrame {
/**
* WIDTH:宽
* HEIGHT:高
* SLEEPTIME:可以看作蛇运动的速度
* L = 1,R = 2, U = 3, D = 4 左右上下代码
*/
public static final int WIDTH = 800, HEIGHT = 600, SLEEPTIME = 200, L = 1,R = 2, U = 3, D = 4;
BufferedImage offersetImage= new BufferedImage(WIDTH, HEIGHT,BufferedImage.TYPE_3BYTE_BGR);;
Rectangle rect = new Rectangle(20, 40, 15 * 50, 15 * 35);
Snake snake;
Node node;
public InterFace() {
//创建"蛇"对象
snake = new Snake(this);
//创建"食物"对象
createNode();
this.setBounds(100, 100, WIDTH, HEIGHT);
//添加键盘监听器
this.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent arg0) {
System.out.println(arg0.getKeyCode());
switch (arg0.getKeyCode()) {
//映射上下左右4个键位
case KeyEvent.VK_LEFT:
snake.dir = L;
break;
case KeyEvent.VK_RIGHT:
snake.dir = R;
break;
case KeyEvent.VK_UP:
snake.dir = U;
break;
case KeyEvent.VK_DOWN:
snake.dir = D;
}
}
});
this.setTitle("贪吃蛇 0.1 By ： Easy");
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
//启动线程,开始执行
new Thread(new ThreadUpadte()).start();
}
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) offersetImage.getGraphics();
g2d.setColor(Color.white);
g2d.fillRect(0, 0, WIDTH, HEIGHT);
g2d.setColor(Color.black);
g2d.drawRect(rect.x, rect.y, rect.width, rect.height);
//如果蛇碰撞(吃)到食物，则创建新食物
if (snake.hit(node)) {
createNode();
}
snake.draw(g2d);
node.draw(g2d);
g.drawImage(offersetImage, 0, 0, null);
}
class ThreadUpadte implements Runnable {
public void run() {
//无限重绘画面
while (true) {
try {
Thread.sleep(SLEEPTIME);
repaint(); //
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 创建食物
*/
public void createNode() {
//随机食物的出现位置
int x = (int) (Math.random() * 650) + 50,y = (int) (Math.random() * 500) + 50;
Color color = Color.blue;
node = new Node(x, y, color);
}
public static void main(String args[]) {
new InterFace();
}
}
/**
* 节点类(包括食物和蛇的身躯组成节点)
*/
class Node {
int x, y, width = 15, height = 15;
Color color;
public Node(int x, int y, Color color) {
this(x, y);
this.color = color;
}
public Node(int x, int y) {
this.x = x;
this.y = y;
this.color = color.black;
}
public void draw(Graphics2D g2d) {
g2d.setColor(color);
g2d.drawRect(x, y, width, height);
}
public Rectangle getRect() {
return new Rectangle(x, y, width, height);
}
}
/**
* 蛇
*/
class Snake {
public List<Node> nodes = new ArrayList<Node>();
InterFace interFace;
int dir=InterFace.R;
public Snake(InterFace interFace) {
this.interFace = interFace;
nodes.add(new Node(20 + 150, 40 + 150));
addNode();
}
/**
* 是否碰撞到食物
* @return true 是 false 否
*/
public boolean hit(Node node) {
//遍历整个蛇体是否与食物碰撞
for (int i = 0; i < nodes.size(); i++) {
if (nodes.get(i).getRect().intersects(node.getRect())) {
addNode();
return true;
}
}
return false;
}
public void draw(Graphics2D g2d) {
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).draw(g2d);
}
move();
}
public void move() {
nodes.remove((nodes.size() - 1));
addNode();
}
public synchronized void addNode() {
Node nodeTempNode = nodes.get(0);
//如果方向
switch (dir) {
case InterFace.L:
//判断是否会撞墙
if (nodeTempNode.x <= 20) {
nodeTempNode = new Node(20 + 15 * 50, nodeTempNode.y);
}
nodes.add(0, new Node(nodeTempNode.x - nodeTempNode.width,
nodeTempNode.y));
break;
case InterFace.R:
//判断是否会撞墙
if (nodeTempNode.x >= 20 + 15 * 50 - nodeTempNode.width) {
nodeTempNode = new Node(20 - nodeTempNode.width, nodeTempNode.y);
}
nodes.add(0, new Node(nodeTempNode.x + nodeTempNode.width,
nodeTempNode.y));
break;
case InterFace.U:
//判断是否会撞墙
if (nodeTempNode.y <= 40) {
nodeTempNode = new Node(nodeTempNode.x, 40 + 15 * 35);
}
nodes.add(0, new Node(nodeTempNode.x, nodeTempNode.y - nodeTempNode.height));
break;
case InterFace.D:
//判断是否会撞墙
if (nodeTempNode.y >= 40 + 15 * 35 - nodeTempNode.height) {
nodeTempNode = new Node(nodeTempNode.x,40 - nodeTempNode.height);
}
nodes.add(0, new Node(nodeTempNode.x, nodeTempNode.y + nodeTempNode.height));
break;
}
}
}