讲师中心 微信公众号
首页
文章
后端开发 web前端 数据库 开发工具 php框架 常见问题 人工智能 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 人工智能 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 AI 提示词
学习
大前端 后端开发 数据库 移动端 运维开发 计算机基础
编程手册
大前端 后端开发 数据库 移动端 运维开发 计算机基础
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机游戏
最近更新
当前位置：首页 > 后端开发 > php教程 >

正文

0

0

坦克大战DEMO

php中文网

php中文网

发布时间：2016-07-25 09:08:16

|

1901人浏览过

|

来源于php中文网

原创

实现了基本功能....地方坦克寻路做得比较弱智，每个坦克最多能同时发射5发炮弹....敌方有三种兵种，菜单栏没做响应，这个很简单，需要的可以自己加......上传全部代码，仅供学习参考...... 坦克大战DEMO
  1. package tank.common;
  3. abstract public class Bullet implements Runnable, Common {
  4. private int x, y;
  5. private int speed;
  6. private int direction;
  7. private boolean alive;
  8. protected int power;
  10. public Bullet(int x, int y, int speed, int direction) {
  11. this.x = x;
  12. this.y = y;
  13. this.speed = speed;
  14. this.direction = direction;
  15. alive = true;
  16. }
  18. public void die() {
  19. alive = false;
  20. }
  22. public int getPower() {
  23. return power;
  24. }
  26. public int getX() {
  27. return x;
  28. }
  30. public int getY() {
  31. return y;
  32. }
  34. public boolean isAlive() {
  35. return alive;
  36. }
  38. public void run() {
  39. while (true) {
  40. try {
  41. Thread.sleep(15);
  42. } catch (InterruptedException e) {
  43. // TODO Auto-generated catch block
  44. e.printStackTrace();
  45. }
  46. switch (direction) {
  47. case UP:
  48. y -= speed;
  49. break;
  50. case DOWN:
  51. y += speed;
  52. break;
  53. case RIGHT:
  54. x += speed;
  55. break;
  56. case LEFT:
  57. x -= speed;
  58. break;
  59. }
  60. if (x WIDTH || y > HEIGHT || y
  61. alive = false;
  62. return;
  63. }
  64. }
  65. }
  67. }
复制代码
  1. package tank.common;
  3. public interface Common {
  4. public static final int UP = 0;
  5. public static final int DOWN = 1;
  6. public static final int RIGHT = 2;
  7. public static final int LEFT = 3;
  8. public static final int WIDTH = 600;
  9. public static final int HEIGHT = 400;
  10. public static final int WATER = 0;
  11. public static final int WALLS = 1;
  12. public static final int STEELS = 2;
  13. public static final int GRASS = 3;
  15. }
复制代码
  1. package tank.common;
  3. import java.awt.Color;
  4. import java.awt.Point;
  6. public abstract class EnemyTank extends Tank {
  7. private class AutoFire implements Runnable {
  9. @Override
  10. public void run() {
  11. // TODO Auto-generated method stub
  12. while (isAlive()) {
  13. try {
  14. Thread.sleep(500);
  15. } catch (InterruptedException e) {
  16. // TODO Auto-generated catch block
  17. e.printStackTrace();
  18. }
  19. if (Math.random() > shotKey) {
  20. shot();
  21. }
  22. }
  23. }
  25. }
  27. private class AutoMove implements Runnable {
  29. @Override
  30. public void run() {
  31. // TODO Auto-generated method stub
  33. int moves[] = new int[4];
  34. while (isAlive()) {
  35. try {
  36. Thread.sleep(110);
  37. } catch (InterruptedException e) {
  38. // TODO Auto-generated catch block
  39. e.printStackTrace();
  40. }
  41. for (int i = 0; i
  42. moves[i] = judgeHero(i);
  43. }
  44. int direction = 0;
  45. int max = Integer.MIN_VALUE;
  46. for (int i = 0; i
  47. if (moves[i] >= max) {
  48. max = moves[i];
  49. direction = i;
  50. }
  51. }
  52. move(direction);
  53. }
  54. }
  56. }
  58. private double shotKey;
  60. private Point heroPosition;
  62. private Tank hero;
  64. public EnemyTank(int x, int y, Tank hero, int life, int ID) {
  65. super(x, y, Color.cyan);
  66. this.lifes = life;
  67. this.hero = hero;
  68. super.setImageID(ID);
  69. }
  71. private int judgeHero(int direction) {
  72. heroPosition = new Point(hero.getX() + 9, hero.getY() + 9);
  73. int result = 0;
  74. int x = this.getX();
  75. int y = this.getY();
  76. int speed = this.getSpeed();
  77. double distance1 = Math.abs((this.getX() - heroPosition.x)
  78. * (this.getX() - heroPosition.x)
  79. + (this.getY() - heroPosition.y)
  80. * (this.getY() - heroPosition.y));
  81. switch (direction) {
  82. case UP:
  83. y -= speed;
  84. break;
  85. case DOWN:
  86. y += speed;
  87. break;
  88. case RIGHT:
  89. x += speed;
  90. break;
  91. case LEFT:
  92. x -= speed;
  93. break;
  94. }
  95. if (getDirection() == direction) {
  96. result += 5000;
  97. }
  98. if (!canMove(x, y)) {
  99. result -= Integer.MAX_VALUE;
  100. }
  102. double distance2 = Math.abs((x - heroPosition.x) * (x - heroPosition.x)
  103. + (y - heroPosition.y) * (y - heroPosition.y));
  104. if (Math.random() > 0.8) {
  105. result += Math.random() * 20000;
  106. }
  107. result += (distance1 - distance2) * 10;
  108. return result;
  109. }
  111. public void setPosition(int x, int y) {
  112. super.x = x;
  113. super.y = y;
  114. }
  116. public void setShotSpeed(double shotSpeed) {
  117. this.shotKey = shotSpeed;
  118. }
  120. public void startFire() {
  121. new Thread(new AutoFire()).start();
  122. }
  124. public void startMove() {
  125. new Thread(new AutoMove()).start();
  126. }
  128. }
复制代码
  1. package tank.common;
  3. import java.awt.Color;
  4. import java.util.ArrayList;
  6. import tank.entity.NormalBullet;
  8. public abstract class Tank implements Common {
  9. protected int x;
  11. protected int y;
  13. private Color color;
  15. private int speed;
  17. private int direction;
  19. private ArrayList bullets;
  21. private ArrayList tanks;
  23. private Bullet bullet;
  25. private int maxBulletNum;
  27. private boolean alive;
  29. protected int lifes;
  31. ArrayList walls;
  33. private int tankImageID;
  35. {
  36. speed = 2;
  37. direction = UP;
  38. alive = true;
  39. }
  41. public Tank() {
  42. this.x = 0;
  43. this.y = 0;
  44. color = Color.black;
  45. }
  47. public Tank(int x, int y, Color color) {
  48. this.x = x;
  49. this.y = y;
  50. this.color = color;
  51. maxBulletNum = 5;
  52. bullets = new ArrayList();
  53. walls = new ArrayList();
  54. }
  56. protected boolean canMove(int x, int y) {
  57. if (x WIDTH - 20 || y HEIGHT - 20) {
  58. return false;
  59. }
  61. if (tanks == null) {
  62. return true;
  63. }
  65. if (tanks.size() == 1) {
  66. return true;
  67. }
  69. for (int i = 0; i
  70. Wall tempWall = walls.get(i);
  71. if (tempWall.isAlive()) {
  72. if (x >= tempWall.getX() && y >= tempWall.getY()) {
  73. if (x
  74. return tempWall.canBeWalk();
  75. }
  76. } else if (x >= tempWall.getX() && y
  77. if (x
  78. && (y + 20) >= tempWall.getY()) {
  79. return tempWall.canBeWalk();
  80. }
  81. } else if (x = tempWall.getY()) {
  82. if ((x + 20) >= tempWall.getX()
  83. && y
  84. return tempWall.canBeWalk();
  85. }
  86. } else if (x
  87. if ((x + 20) >= tempWall.getX()
  88. && (y + 20) >= tempWall.getY()) {
  89. return tempWall.canBeWalk();
  90. }
  91. }
  92. }
  93. }
  95. for (int i = 0; i
  96. Tank tempTank = tanks.get(i);
  97. if (tempTank == this)
  98. break;
  99. if (tempTank.isAlive()) {
  100. if (x >= tempTank.getX() && y >= tempTank.getY()) {
  101. if (x
  102. return false;
  103. }
  104. } else if (x >= tempTank.getX() && y
  105. if (x
  106. && (y + 20) >= tempTank.getY()) {
  107. return false;
  108. }
  109. } else if (x = tempTank.getY()) {
  110. if ((x + 20) >= tempTank.getX()
  111. && y
  112. return false;
  113. }
  114. } else if (x
  115. if ((x + 20) >= tempTank.getX()
  116. && (y + 20) >= tempTank.getY()) {
  117. return false;
  118. }
  119. }
  120. }
  121. }
  122. return true;
  123. }
  125. public void damage(int power) {
  126. lifes -= power;
  127. if (lifes
  128. alive = false;
  129. }
  130. }
  132. public ArrayList getBullet() {
  133. return bullets;
  134. }
  136. public Color getColor() {
  137. return color;
  138. }
  140. public int getDirection() {
  141. return direction;
  142. }
  144. public int getImageID() {
  145. return tankImageID;
  146. }
  148. public int getSpeed() {
  149. return speed;
  150. }
  152. public ArrayList getWalls() {
  153. return this.walls;
  154. }
  156. public int getX() {
  157. return x;
  158. }
  160. public int getY() {
  161. return y;
  162. }
  164. public boolean isAlive() {
  165. return alive;
  166. }
  168. public void move(int direction) {
  169. setDirection(direction);
  170. int x = this.x;
  171. int y = this.y;
  172. switch (direction) {
  173. case UP:
  174. y -= speed;
  175. break;
  176. case DOWN:
  177. y += speed;
  178. break;
  179. case RIGHT:
  180. x += speed;
  181. break;
  182. case LEFT:
  183. x -= speed;
  184. break;
  185. }
  186. if (canMove(x, y)) {
  187. this.x = x;
  188. this.y = y;
  189. }
  190. }
  192. public void setAllTanks(ArrayList tanks) {
  193. this.tanks = tanks;
  194. }
  196. public void setDirection(int direction) {
  197. this.direction = direction;
  198. }
  200. final protected void setImageID(int ID) {
  201. this.tankImageID = ID;
  202. }
  204. public void setSpeed(int speed) {
  205. this.speed = speed;
  206. }
  208. public void setWalls(ArrayList wallList) {
  209. this.walls = wallList;
  210. }
  212. public void shot() {
  213. switch (direction) {
  214. case UP:
  215. bullet = new NormalBullet(x + 10, y, UP);
  216. break;
  217. case DOWN:
  218. bullet = new NormalBullet(x + 10, y + 20, DOWN);
  219. break;
  220. case RIGHT:
  221. bullet = new NormalBullet(x + 20, y + 10, RIGHT);
  222. break;
  223. case LEFT:
  224. bullet = new NormalBullet(x, y + 10, LEFT);
  225. break;
  226. }
  227. for (int i = 0; i
  228. Bullet temp = bullets.get(i);
  229. if (!temp.isAlive()) {
  230. bullets.remove(temp);
  231. }
  232. }
  233. if (bullets.size() >= maxBulletNum) {
  235. } else {
  236. new Thread(bullet).start();
  237. bullets.add(bullet);
  238. }
  240. }
  241. }
复制代码
  1. package tank.common;
  3. public abstract class Wall {
  4. private int x, y;
  6. private int wallImageID;
  8. private boolean canWalk;
  10. private boolean canFly;
  12. private boolean alive;
  14. private boolean canHit;
  16. public Wall(int x, int y, int ID, boolean walk, boolean fly, boolean Hit) {
  17. this.x = x;
  18. this.y = y;
  19. this.wallImageID = ID;
  20. this.canWalk = walk;
  21. this.canFly = fly;
  22. this.alive = true;
  23. this.canHit = Hit;
  24. }
  26. public boolean canBeFly() {
  27. return canFly;
  28. }
  30. public boolean canBeHit() {
  31. return this.canHit;
  32. }
  34. public boolean canBeWalk() {
  35. return canWalk;
  36. }
  38. public void die() {
  39. alive = false;
  40. }
  42. public int getImageID() {
  43. return wallImageID;
  44. }
  46. public int getX() {
  47. return x;
  48. }
  50. public int getY() {
  51. return y;
  52. }
  54. public boolean isAlive() {
  55. return alive;
  56. }
  58. }
复制代码
  1. package tank.entity;
  3. public class Bomb {
  4. private int x;
  5. private int y;
  7. private int life = 9;
  9. private boolean alive;
  11. public Bomb(int x, int y) {
  12. this.x = x;
  13. this.y = y;
  14. alive = true;
  15. }
  17. public void decrese() {
  18. if (life > 0) {
  19. life--;
  20. } else {
  21. alive = false;
  22. }
  23. }
  25. public int getLife() {
  26. return life;
  27. }
  29. public int getX() {
  30. return x;
  31. }
  33. public int getY() {
  34. return y;
  35. }
  37. public boolean isAlive() {
  38. return alive;
  39. }
  41. }
复制代码
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank1 extends EnemyTank {
  8. public EnemyTank1(int x, int y, Tank hero) {
  9. super(x, y, hero, 3, 1);
  10. setSpeed(2);
  11. setShotSpeed(0.8);
  12. }
  13. }
复制代码
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank2 extends EnemyTank {
  7. public EnemyTank2(int x, int y, Tank hero) {
  8. super(x, y, hero, 5, 2);
  9. setSpeed(3);
  10. setShotSpeed(0.5);
  11. }
  12. }
复制代码
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank3 extends EnemyTank {
  7. public EnemyTank3(int x, int y, Tank hero) {
  8. super(x, y, hero, 10, 3);
  9. setSpeed(5);
  10. setShotSpeed(0.2);
  11. }
  12. }
复制代码
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Grass extends Wall {
  6. public Grass(int x, int y) {
  7. super(x, y, 3, true, true, false);
  8. }
  9. }
复制代码
  1. package tank.entity;
  3. import java.awt.Color;
  5. import tank.common.Tank;
  7. public class MyTank extends Tank {
  8. public MyTank(int x, int y) {
  9. super(x, y, Color.yellow);
  10. lifes = 5;
  11. super.setImageID(0);
  12. }
  14. public int getLife() {
  15. return lifes;
  16. }
  18. }
复制代码
  1. package tank.entity;
  3. import tank.common.Bullet;
  5. public class NormalBullet extends Bullet {
  7. public NormalBullet(int x, int y, int direction) {
  8. super(x, y, 2, direction);
  9. power = 1;
  10. }
  12. }
复制代码
  1. package tank.entity;
  3. import java.util.ArrayList;
  5. import tank.common.EnemyTank;
  7. public class Stage {
  8. private int totalEnemyNum;
  9. private int leaveEnemyNum;
  10. private int totalHeroLife;
  11. private int leaveHeroLife;
  12. private int level;
  13. private WallContainer wallContainer;
  14. private ArrayList enemeyTanks;
  15. private int activeEnemyTankNum;
  16. private EnemyTank activeEnemyTanks[];
  17. private MyTank hero;
  19. public Stage(int totalEnemyNum, int totalHeroLife, int level,
  20. int activeEnemyTankNum) {
  21. this.totalEnemyNum = totalEnemyNum;
  22. this.totalHeroLife = totalHeroLife;
  23. this.level = level;
  24. this.activeEnemyTankNum = activeEnemyTankNum;
  25. this.leaveEnemyNum = this.totalEnemyNum;
  26. this.leaveHeroLife = this.totalHeroLife;
  27. this.enemeyTanks = new ArrayList();
  28. this.activeEnemyTanks = new EnemyTank[this.activeEnemyTankNum];
  29. this.hero = new MyTank(290, 370);
  30. this.wallContainer = new WallContainer();
  31. }
  33. public void addEnemyTank(EnemyTank tank) {
  34. enemeyTanks.add(tank);
  35. }
  37. public void autoCreateEnemyTank() {
  38. for (int i = 0; i
  39. double key = Math.random();
  40. if (key
  41. this.enemeyTanks.add(new EnemyTank1(0, 0, hero));
  42. } else if (key >= 0.66) {
  43. this.enemeyTanks.add(new EnemyTank2(0, 0, hero));
  44. } else {
  45. this.enemeyTanks.add(new EnemyTank3(0, 0, hero));
  46. }
  47. }
  48. }
  50. public int getActiveEnemyTankNum() {
  51. return this.activeEnemyTankNum;
  52. }
  54. public EnemyTank[] getEnemyTank() {
  55. return this.activeEnemyTanks;
  56. }
  58. public MyTank getHeroTank() {
  59. return this.hero;
  60. }
  62. public int getLeaveEnemyNum() {
  63. return this.leaveEnemyNum;
  64. }
  66. public int getLeaveHeroLife() {
  67. return this.leaveHeroLife;
  68. }
  70. public int getLevel() {
  71. return this.level;
  72. }
  74. public WallContainer getWallContainer() {
  75. return this.wallContainer;
  76. }
  78. public boolean isHeroDead() {
  79. if (this.leaveHeroLife
  80. return true;
  81. } else
  82. return false;
  83. }
  85. public EnemyTank popEnemyTank() {
  86. if (leaveEnemyNum > 0) {
  87. this.leaveEnemyNum--;
  88. EnemyTank temp = enemeyTanks.get(enemeyTanks.size() - 1);
  89. enemeyTanks.remove(temp);
  90. return temp;
  91. } else
  92. return null;
  93. }
  95. public MyTank popHero() {
  96. leaveHeroLife--;
  97. MyTank temp = new MyTank(290, 370);
  98. temp.setWalls(wallContainer.getWallList());
  99. return temp;
  100. }
  102. public void setHeroTank(MyTank tank) {
  103. this.hero = tank;
  104. }
  105. }
复制代码
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Steels extends Wall {
  6. public Steels(int x, int y) {
  7. super(x, y, 2, false, false, false);
  8. }
  9. }
复制代码
  1. package tank.entity;
  3. import java.util.ArrayList;
  5. import tank.common.Common;
  6. import tank.common.Wall;
  8. public class WallContainer implements Common {
  9. private ArrayList data;
  11. public WallContainer() {
  12. data = new ArrayList();
  13. for (int i = 0; i
  14. this.addWall(10 + i * 20, 100, WATER);
  15. if (i == 11) {
  16. i += 4;
  17. }
  18. }
  20. for (int i = 0; i
  21. this.addWall(10 + i * 20, 160, WALLS);
  22. if (i == 12) {
  23. i += 4;
  24. }
  25. }
  27. for (int i = 0; i
  28. this.addWall(10 + i * 20, 220, STEELS);
  29. if (i == 11) {
  30. i += 4;
  31. }
  32. }
  34. for (int i = 0; i
  35. this.addWall(10 + i * 20, 280, GRASS);
  36. if (i == 12) {
  37. i += 4;
  38. }
  39. }
  40. }
  42. public void addWall(int x, int y, int kind) {
  43. switch (kind) {
  44. case WATER:
  45. data.add(new Water(x, y));
  46. break;
  47. case WALLS:
  48. data.add(new Walls(x, y));
  49. break;
  50. case STEELS:
  51. data.add(new Steels(x, y));
  52. break;
  53. case GRASS:
  54. data.add(new Grass(x, y));
  55. break;
  56. }
  57. }
  59. public ArrayList getWallList() {
  60. ArrayList temp = data;
  61. return temp;
  62. }
  64. public boolean isEmpty() {
  65. return data.isEmpty();
  66. }
  68. public void removeDead() {
  69. for (int i = 0; i
  70. Wall temp = data.get(i);
  71. if (!temp.isAlive())
  72. data.remove(temp);
  73. }
  74. }
  75. }
复制代码
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Walls extends Wall {
  6. public Walls(int x, int y) {
  7. super(x, y, 1, false, false, true);
  8. }
  9. }
复制代码
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Water extends Wall {
  6. public Water(int x, int y) {
  7. super(x, y, 0, false, true, false);
  8. }
  9. }
复制代码
  1. package tank.gui;
  3. import javax.swing.JFrame;
  4. import javax.swing.JMenu;
  5. import javax.swing.JMenuBar;
  6. import javax.swing.JMenuItem;
  8. public class TankFrame extends JFrame {
  10. /**
  11. *
  12. */
  13. private static final long serialVersionUID = 1L;
  14. private TankPanel gamePanel;
  16. public TankFrame() {
  17. super("坦克大战————玄雨制作");
  18. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  19. // 添加游戏主面板
  20. gamePanel = new TankPanel();
  21. this.add(gamePanel);
  22. gamePanel.addMouseListener(gamePanel);
  23. this.addKeyListener(gamePanel);
  25. // 添加菜单栏
  26. JMenuBar menuBar = new JMenuBar();
  27. // ///////////////////////////////
  28. JMenu menu1 = new JMenu("菜单");
  29. menuBar.add(menu1);
  30. JMenuItem itemNewGame = new JMenuItem("新游戏");
  31. menu1.add(itemNewGame);
  32. menu1.addSeparator();
  33. JMenuItem itemList = new JMenuItem("排行榜");
  34. menu1.add(itemList);
  35. menu1.addSeparator();
  36. JMenuItem itemExit = new JMenuItem("退出");
  37. menu1.add(itemExit);
  38. // //////////////////////////////////
  39. JMenu menu2 = new JMenu("设置");
  40. JMenuItem itemSet = new JMenuItem("设置");
  41. menu2.add(itemSet);
  42. menuBar.add(menu2);
  43. // /////////////////////////////////
  44. JMenu menu3 = new JMenu("帮助");
  45. menuBar.add(menu3);
  46. JMenuItem itemInfo = new JMenuItem("关于");
  47. menu3.add(itemInfo);
  48. JMenuItem itemHelp = new JMenuItem("帮助");
  49. menu3.add(itemHelp);
  50. this.setJMenuBar(menuBar);
  52. this.setResizable(false);
  53. this.pack();
  54. this.setVisible(true);
  55. }
  57. }
复制代码
  1. package tank.start;
  3. import tank.gui.TankFrame;
  5. public class TankStart {
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. // TODO Auto-generated method stub
  12. new TankFrame().setLocation(250, 150);
  13. }
  15. }
复制代码


相关文章

PHP Git 实战：如何管理大型代码库中的协作？

从混乱到清晰：PHP Git 如何简化项目管理

本站声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

上一篇：如何解析百度搜索结果link?url=参数 下一篇：mybatis数据库分页

热门AI工具

更多
DeepSeek
DeepSeek

幻方量化公司旗下的开源大模型平台

AI 编程开发AI 聊天问答
豆包大模型
豆包大模型

字节跳动自主研发的一系列大型语言模型

AI 编程开发AI大模型
通义千问
通义千问

阿里巴巴推出的全能AI助手

AI 编程开发Agent智能体
腾讯元宝
腾讯元宝

腾讯混元平台推出的AI助手

文档处理AI 聊天问答
文心一言
文心一言

文心一言是百度开发的AI聊天机器人，通过对话可以生成各种形式的内容。

AI 编程开发AI 文本写作
讯飞写作
讯飞写作

基于讯飞星火大模型的AI写作工具，可以快速生成新闻稿件、品宣文案、工作总结、心得体会等各种文文稿

AI 文本写作中文写作
即梦AI
即梦AI

一站式AI创作平台，免费AI图片和视频生成。

AI 图片处理图片拼接
ChatGPT
ChatGPT

最最强大的AI聊天机器人程序，ChatGPT不单是聊天机器人，还能进行撰写邮件、视频脚本、文案、翻译、代码等任务。

AI 编程开发AI 文本写作
智谱清言 - 免费全能的AI助手
智谱清言 - 免费全能的AI助手

智谱清言 - 免费全能的AI助手

AI 编程开发Agent智能体

相关专题

更多
pixiv网页版官网登录与阅读指南_pixiv官网直达入口与在线访问方法
pixiv网页版官网登录与阅读指南_pixiv官网直达入口与在线访问方法

本专题系统整理pixiv网页版官网入口及登录访问方式，涵盖官网登录页面直达路径、在线阅读入口及快速进入方法说明，帮助用户高效找到pixiv官方网站，实现便捷、安全的网页端浏览与账号登录体验。

705

2026.02.13

微博网页版主页入口与登录指南_官方网页端快速访问方法
微博网页版主页入口与登录指南_官方网页端快速访问方法

本专题系统整理微博网页版官方入口及网页端登录方式，涵盖首页直达地址、账号登录流程与常见访问问题说明，帮助用户快速找到微博官网主页，实现便捷、安全的网页端登录与内容浏览体验。

233

2026.02.13

Flutter跨平台开发与状态管理实战
Flutter跨平台开发与状态管理实战

本专题围绕Flutter框架展开，系统讲解跨平台UI构建原理与状态管理方案。内容涵盖Widget生命周期、路由管理、Provider与Bloc状态管理模式、网络请求封装及性能优化技巧。通过实战项目演示，帮助开发者构建流畅、可维护的跨平台移动应用。

117

2026.02.13

TypeScript工程化开发与Vite构建优化实践
TypeScript工程化开发与Vite构建优化实践

本专题面向前端开发者，深入讲解 TypeScript 类型系统与大型项目结构设计方法，并结合 Vite 构建工具优化前端工程化流程。内容包括模块化设计、类型声明管理、代码分割、热更新原理以及构建性能调优。通过完整项目示例，帮助开发者提升代码可维护性与开发效率。

22

2026.02.13

Redis高可用架构与分布式缓存实战
Redis高可用架构与分布式缓存实战

本专题围绕 Redis 在高并发系统中的应用展开，系统讲解主从复制、哨兵机制、Cluster 集群模式及数据分片原理。内容涵盖缓存穿透与雪崩解决方案、分布式锁实现、热点数据优化及持久化策略。通过真实业务场景演示，帮助开发者构建高可用、可扩展的分布式缓存系统。

61

2026.02.13

c语言 数据类型
c语言 数据类型

本专题整合了c语言数据类型相关内容，阅读专题下面的文章了解更多详细内容。

30

2026.02.12

雨课堂网页版登录入口与使用指南_官方在线教学平台访问方法
雨课堂网页版登录入口与使用指南_官方在线教学平台访问方法

本专题系统整理雨课堂网页版官方入口及在线登录方式，涵盖账号登录流程、官方直连入口及平台访问方法说明，帮助师生用户快速进入雨课堂在线教学平台，实现便捷、高效的课程学习与教学管理体验。

15

2026.02.12

豆包AI网页版入口与智能创作指南_官方在线写作与图片生成使用方法
豆包AI网页版入口与智能创作指南_官方在线写作与图片生成使用方法

本专题汇总豆包AI官方网页版入口及在线使用方式，涵盖智能写作工具、图片生成体验入口和官网登录方法，帮助用户快速直达豆包AI平台，高效完成文本创作与AI生图任务，实现便捷智能创作体验。

669

2026.02.12

PostgreSQL性能优化与索引调优实战
PostgreSQL性能优化与索引调优实战

本专题面向后端开发与数据库工程师，深入讲解 PostgreSQL 查询优化原理与索引机制。内容包括执行计划分析、常见索引类型对比、慢查询优化策略、事务隔离级别以及高并发场景下的性能调优技巧。通过实战案例解析，帮助开发者提升数据库响应速度与系统稳定性。

58

2026.02.12

热门下载

更多
网站特效
/
网站源码
/
网站素材
/
前端模板

相关下载

更多
原生JS编写的坦克大战小游戏代码

精品课程

更多
相关推荐
/
热门推荐
/
最新课程
马士兵JAVA坦克游戏视频教程
马士兵JAVA坦克游戏视频教程

共23课时 | 5万人学习

百变小程序
百变小程序

共9课时 | 3万人学习

最新文章

更多
如何在 PHP 表单提交中正确获取 select 下拉框的选中值
SQL Server 游标在 PHP 中执行异常中断的解决方案
如何解决 CSRF Token 在生产服务器上失效的问题
SQL Server 游标在 PHP 中执行不完整？改用集合操作彻底解决
MongoDB 中 PHP 实现数组字段到字符串的安全拼接教程
Sulu CMS 中为导航项动态注入页面图标数据的完整实现方案
MongoDB 中 PHP 数组转字符串的完整实践指南
MongoDB 中 PHP 实现数组字段到字符串的灵活拼接
WordPress中根据自定义字段值动态添加CSS类的完整实现方案
Sulu CMS 中为导航项动态注入页面图标字段的完整实现方案
关于我们 免责申明 举报中心 意见反馈 讲师合作 广告合作 最新更新
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送

Copyright 2014-2026 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • PHP学习

  • 技术支持

  • 返回顶部