devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用JAVA代码实现跳动爱心（脱单节程序员必备哦）_java爱心代码跳动

作者：煮酒与君饮 | 2024-08-10 18:23:55

赞

踩

java爱心代码跳动

520！！！表白日，你脱单了吗？你跟对象彻夜不归了吗？

如果没有说明，你的诚心不够，来给对象一个代码表白吧！

话不多说，先上效果图：

实现代码如下：

  1. import java.awt.Color;
  2. import java.awt.Font;
  3. import java.awt.Graphics;
  4. import java.awt.Image;
  5. import java.awt.Toolkit;
  6. import javax.swing.JFrame;
  7.  
  8. class Cardioid extends JFrame {
  9.  
  10.     //定义窗口大小
  11.     private static final int WIDTH = 900;
  12.     private static final int HEIGHT = 800;
  13.  
  14.     //获取屏幕大小
  15.     private static final int WINDOW_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
  16.     private static final int WINDOW_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height;
  17.     //构造函数
  18.     public Cardioid() {
  19.         //设置窗口标题
  20.         super("♥爱心");
  21.         //设置背景色
  22.         this.setBackground(Color.BLACK);
  23.         //设置窗口位置
  24.         this.setLocation((WINDOW_WIDTH - WIDTH) / 2, (WINDOW_HEIGHT - HEIGHT) / 2);
  25.         //设置窗口大小
  26.         this.setSize(WIDTH, HEIGHT);
  27.         //设置窗口布局
  28.         this.setLayout(getLayout());
  29.         //设置窗口可见
  30.         this.setVisible(true);
  31.         //设置窗口的默认关闭方式
  32.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  33.     }
  34.  
  35.     //图形函数
  36.     public void paint(Graphics g) {
  37.         //横纵坐标及半径
  38.         double x, y, r;
  39.         //绘制图形
  40.         double z = 0.0;
  41.         double size=10;
  42.         int jj=0;
  43.         while (true) {
  44.             Image image = this.createImage(WIDTH, HEIGHT);
  45.             Graphics pic = image.getGraphics();
  46.             if (jj%2==0){
  47.                 size=14.5;
  48.             }else {
  49.                 size=15;
  50.             }
  51.             for (int ii = 30; ii > 0; ii--) {
  52.                 Color color = new Color(255, 175, (int) (20 * Math.random()) + 220);
  53.                 for (int i = 1; i < 400; i++) {
  54.                     int px = (int) (Math.random() * 10);
  55.                     int py = (int) (Math.random() * 10);
  56.                     x = 16 * (Math.sin(z) * Math.sin(z) * Math.sin(z)) * (size) + Math.pow((-1), px) * Math.random() * ii * Math.sqrt(ii) + WIDTH / 2;
  57.                     y = -(13 * Math.cos(z) - 5 * Math.cos(2 * z) - 2 * Math.cos(3 * z) - Math.cos(4 * z)) * (size) + Math.pow((-1), py) * Math.random() * ii * Math.sqrt(ii) + HEIGHT * 1 / 3;
  58.                     z += (Math.PI / 2.0) / 80;
  59.                     pic.setColor(color);
  60.                     pic.fillOval((int) x, (int) y, 2, 2);
  61.                 }
  62.                 if (ii < 3) {
  63.                     pic.setFont(new Font("楷体", Font.BOLD, 40));//设置字体
  64.                     pic.setColor(Color.pink);//字体颜色
  65.                     //可自定义字体哦
  66.                     pic.drawString("Love You", WIDTH / 2 - 100, 240);//绘制字符串
  67.                     pic.drawString("爱你一万年!", WIDTH / 2, 280);//绘制字符串
  68.                     g.drawImage(image, 0, 0, this);
  69.                 }
  70.             }
  71.             jj++;
  72.             if (jj>100){
  73.                 break;
  74.             }
  75.             try {
  76.                 Thread.sleep(500);
  77.             } catch (InterruptedException e) {
  78.                 e.printStackTrace();
  79.             }
  80.         }
  81.     }
  82.  
  83.     public static void main(String[] args) {
  84.         new Cardioid();
  85.     }
  86.  
  87. }
  88.  
  89.  
  90.  
  91.

html使用红心

  1. <!DOCTYPE html>
  2. <html>
  3.   <head>
  4.     <title></title>
  5.   </head>
  6.   <style>
  7.     * {
  8.       padding: 0;
  9.       margin: 0;
  10.     }
  11.     html,
  12.     body {
  13.       height: 100%;
  14.       padding: 0;
  15.       margin: 0;
  16.       background: #000;
  17.     }
  18.     canvas {
  19.       position: absolute;
  20.       width: 100%;
  21.       height: 100%;
  22.     }
  23. 	/* 字体的设置 */
  24. 	#name {
  25. 	        position: absolute;
  26. 	        top: 50%;
  27. 	        left: 50%;
  28. 	        transform: translate(-50%, -50%);
  29. 	        margin-top: -20px;
  30. 	        font-size: 46px;
  31. 	        color: #ea80b0;
  32. 	      }
  33.     .aa {
  34.       position: fixed;
  35.       left: 50%;
  36.       bottom: 10px;
  37.       color: #ccc;
  38.     }
  39.   </style>
  40.   <body>
  41.     <canvas id="pinkboard"></canvas>
  42.  <!-- 在下面加名字 -->
  43.      <div id="name" style="color: pink;">爱你一万年</div> 
  44.  
  45.     <script>
  46.       /*
  47.        * Settings
  48.        */
  49.       var settings = {
  50.         particles: {
  51.           length: 500, // maximum amount of particles
  52.           duration: 2, // particle duration in sec
  53.           velocity: 100, // particle velocity in pixels/sec
  54.           effect: -0.75, // play with this for a nice effect
  55.           size: 30 // particle size in pixels
  56.         }
  57.       };
  58.  
  59.       /*
  60.        * RequestAnimationFrame polyfill by Erik M?ller
  61.        */
  62.       (function () {
  63.         var b = 0;
  64.         var c = ["ms", "moz", "webkit", "o"];
  65.         for (var a = 0; a < c.length && !window.requestAnimationFrame; ++a) {
  66.           window.requestAnimationFrame = window[c[a] + "RequestAnimationFrame"];
  67.           window.cancelAnimationFrame =
  68.             window[c[a] + "CancelAnimationFrame"] ||
  69.             window[c[a] + "CancelRequestAnimationFrame"];
  70.         }
  71.         if (!window.requestAnimationFrame) {
  72.           window.requestAnimationFrame = function (h, e) {
  73.             var d = new Date().getTime();
  74.             var f = Math.max(0, 16 - (d - b));
  75.             var g = window.setTimeout(function () {
  76.               h(d + f);
  77.             }, f);
  78.             b = d + f;
  79.             return g;
  80.           };
  81.         }
  82.         if (!window.cancelAnimationFrame) {
  83.           window.cancelAnimationFrame = function (d) {
  84.             clearTimeout(d);
  85.           };
  86.         }
  87.       })();
  88.  
  89.       /*
  90.        * Point class
  91.        */
  92.       var Point = (function () {
  93.         function Point(x, y) {
  94.           this.x = typeof x !== "undefined" ? x : 0;
  95.           this.y = typeof y !== "undefined" ? y : 0;
  96.         }
  97.         Point.prototype.clone = function () {
  98.           return new Point(this.x, this.y);
  99.         };
  100.         Point.prototype.length = function (length) {
  101.           if (typeof length == "undefined")
  102.             return Math.sqrt(this.x * this.x + this.y * this.y);
  103.           this.normalize();
  104.           this.x *= length;
  105.           this.y *= length;
  106.           return this;
  107.         };
  108.         Point.prototype.normalize = function () {
  109.           var length = this.length();
  110.           this.x /= length;
  111.           this.y /= length;
  112.           return this;
  113.         };
  114.         return Point;
  115.       })();
  116.  
  117.       /*
  118.        * Particle class
  119.        */
  120.       var Particle = (function () {
  121.         function Particle() {
  122.           this.position = new Point();
  123.           this.velocity = new Point();
  124.           this.acceleration = new Point();
  125.           this.age = 0;
  126.         }
  127.         Particle.prototype.initialize = function (x, y, dx, dy) {
  128.           this.position.x = x;
  129.           this.position.y = y;
  130.           this.velocity.x = dx;
  131.           this.velocity.y = dy;
  132.           this.acceleration.x = dx * settings.particles.effect;
  133.           this.acceleration.y = dy * settings.particles.effect;
  134.           this.age = 0;
  135.         };
  136.         Particle.prototype.update = function (deltaTime) {
  137.           this.position.x += this.velocity.x * deltaTime;
  138.           this.position.y += this.velocity.y * deltaTime;
  139.           this.velocity.x += this.acceleration.x * deltaTime;
  140.           this.velocity.y += this.acceleration.y * deltaTime;
  141.           this.age += deltaTime;
  142.         };
  143.         Particle.prototype.draw = function (context, image) {
  144.           function ease(t) {
  145.             return --t * t * t + 1;
  146.           }
  147.           var size = image.width * ease(this.age / settings.particles.duration);
  148.           context.globalAlpha = 1 - this.age / settings.particles.duration;
  149.           context.drawImage(
  150.             image,
  151.             this.position.x - size / 2,
  152.             this.position.y - size / 2,
  153.             size,
  154.             size
  155.           );
  156.         };
  157.         return Particle;
  158.       })();
  159.  
  160.       /*
  161.        * ParticlePool class
  162.        */
  163.       var ParticlePool = (function () {
  164.         var particles,
  165.           firstActive = 0,
  166.           firstFree = 0,
  167.           duration = settings.particles.duration;
  168.  
  169.         function ParticlePool(length) {
  170.           // create and populate particle pool
  171.           particles = new Array(length);
  172.           for (var i = 0; i < particles.length; i++)
  173.             particles[i] = new Particle();
  174.         }
  175.         ParticlePool.prototype.add = function (x, y, dx, dy) {
  176.           particles[firstFree].initialize(x, y, dx, dy);
  177.  
  178.           // handle circular queue
  179.           firstFree++;
  180.           if (firstFree == particles.length) firstFree = 0;
  181.           if (firstActive == firstFree) firstActive++;
  182.           if (firstActive == particles.length) firstActive = 0;
  183.         };
  184.         ParticlePool.prototype.update = function (deltaTime) {
  185.           var i;
  186.  
  187.           // update active particles
  188.           if (firstActive < firstFree) {
  189.             for (i = firstActive; i < firstFree; i++)
  190.               particles[i].update(deltaTime);
  191.           }
  192.           if (firstFree < firstActive) {
  193.             for (i = firstActive; i < particles.length; i++)
  194.               particles[i].update(deltaTime);
  195.             for (i = 0; i < firstFree; i++) particles[i].update(deltaTime);
  196.           }
  197.  
  198.           // remove inactive particles
  199.           while (
  200.             particles[firstActive].age >= duration &&
  201.             firstActive != firstFree
  202.           ) {
  203.             firstActive++;
  204.             if (firstActive == particles.length) firstActive = 0;
  205.           }
  206.         };
  207.         ParticlePool.prototype.draw = function (context, image) {
  208.           // draw active particles
  209.           if (firstActive < firstFree) {
  210.             for (i = firstActive; i < firstFree; i++)
  211.               particles[i].draw(context, image);
  212.           }
  213.           if (firstFree < firstActive) {
  214.             for (i = firstActive; i < particles.length; i++)
  215.               particles[i].draw(context, image);
  216.             for (i = 0; i < firstFree; i++) particles[i].draw(context, image);
  217.           }
  218.         };
  219.         return ParticlePool;
  220.       })();
  221.  
  222.       /*
  223.        * Putting it all together
  224.        */
  225.       (function (canvas) {
  226.         var context = canvas.getContext("2d"),
  227.           particles = new ParticlePool(settings.particles.length),
  228.           particleRate =
  229.             settings.particles.length / settings.particles.duration, // particles/sec
  230.           time;
  231.  
  232.         // get point on heart with -PI <= t <= PI
  233.         function pointOnHeart(t) {
  234.           return new Point(
  235.             160 * Math.pow(Math.sin(t), 3),
  236.             130 * Math.cos(t) -
  237.               50 * Math.cos(2 * t) -
  238.               20 * Math.cos(3 * t) -
  239.               10 * Math.cos(4 * t) +
  240.               25
  241.           );
  242.         }
  243.  
  244.         // creating the particle image using a dummy canvas
  245.         var image = (function () {
  246.           var canvas = document.createElement("canvas"),
  247.             context = canvas.getContext("2d");
  248.           canvas.width = settings.particles.size;
  249.           canvas.height = settings.particles.size;
  250.           // helper function to create the path
  251.           function to(t) {
  252.             var point = pointOnHeart(t);
  253.             point.x =
  254.               settings.particles.size / 2 +
  255.               (point.x * settings.particles.size) / 350;
  256.             point.y =
  257.               settings.particles.size / 2 -
  258.               (point.y * settings.particles.size) / 350;
  259.             return point;
  260.           }
  261.           // create the path
  262.           context.beginPath();
  263.           var t = -Math.PI;
  264.           var point = to(t);
  265.           context.moveTo(point.x, point.y);
  266.           while (t < Math.PI) {
  267.             t += 0.01; // baby steps!
  268.             point = to(t);
  269.             context.lineTo(point.x, point.y);
  270.           }
  271.           context.closePath();
  272.           // create the fill
  273.           context.fillStyle = "#ea80b0";
  274.           context.fill();
  275.           // create the image
  276.           var image = new Image();
  277.           image.src = canvas.toDataURL();
  278.           return image;
  279.         })();
  280.  
  281.         // render that thing!
  282.         function render() {
  283.           // next animation frame
  284.           requestAnimationFrame(render);
  285.  
  286.           // update time
  287.           var newTime = new Date().getTime() / 1000,
  288.             deltaTime = newTime - (time || newTime);
  289.           time = newTime;
  290.  
  291.           // clear canvas
  292.           context.clearRect(0, 0, canvas.width, canvas.height);
  293.  
  294.           // create new particles
  295.           var amount = particleRate * deltaTime;
  296.           for (var i = 0; i < amount; i++) {
  297.             var pos = pointOnHeart(Math.PI - 2 * Math.PI * Math.random());
  298.             var dir = pos.clone().length(settings.particles.velocity);
  299.             particles.add(
  300.               canvas.width / 2 + pos.x,
  301.               canvas.height / 2 - pos.y,
  302.               dir.x,
  303.               -dir.y
  304.             );
  305.           }
  306.  
  307.           // update and draw particles
  308.           particles.update(deltaTime);
  309.           particles.draw(context, image);
  310.         }
  311.  
  312.         // handle (re-)sizing of the canvas
  313.         function onResize() {
  314.           canvas.width = canvas.clientWidth;
  315.           canvas.height = canvas.clientHeight;
  316.         }
  317.         window.onresize = onResize;
  318.  
  319.         // delay rendering bootstrap
  320.         setTimeout(function () {
  321.           onResize();
  322.           render();
  323.         }, 10);
  324.       })(document.getElementById("pinkboard"));
  325.     </script>
  326.   </body>
  327. </html>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/959812
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号