Java Applet Animation Program for Moving Car

Hello friends, this is a Java applet program of moving car. In this java program draw a car. Car moves left to right direction on the screen continuously. Here use concepts of applet life cycle, multithreading.

Program Code: Applet_Animation.java

//Java Applet Animation Program  
//Developed by: Om Prakash Vishnoi
import java.awt.*; //import package
import java.applet.*; // import package
/*
<applet code=Applet_Animation width=1000 height =500>
</applet>
*/
public class Applet_Animation extends Applet implements Runnable
{
 int col,col1, row;
 int angle;
 Thread th;
 int x,y;
 public void init()   //initilize applet cycle
 {
  col=50;
  col1=col+220;
  row=400;
  angle=0;
  repaint();
 }
 public void start()   //start applet
 {
  th=new Thread(this);
  th.start();
 }
 public void run()  //run applet
 {
  for(int i=0;;i++)
  {
  try
  {

   Thread.sleep(100);
   repaint();
  }
  catch(InterruptedException e){}
  }
 }
 public void paint(Graphics g)  //draw on screen
 {

  Color c1=new Color(255,255,255);
  Color black = new Color(0,0,0);
  Color c2=new Color(255,0,0);
  Color c3=new Color(0,255,0);
  Color c4=new Color(0,0,255);
  Color c5=new Color(150,150,150);
  Color c6=new Color(190,160,160);
  g.setColor(c2);
  g.drawString("Developed By: Om Prakash Vishnoi",100,100);
  g.setColor(c1);  
  g.setColor(black);
//Car Designing  
  g.drawLine(col+47, row-4, col1-10, row-4); //connection line of wheel cover
  g.drawLine(col-47, row-4, col-10, row-4); //back wheel cover to back line- engine down line
  g.drawLine(col1+10, row-4, col1+80, row-4); //front wheel cover to front line
  g.drawLine(col-47, row-4, col-47, row-60); //back panel line
  //silencer
  g.drawLine(col-47, row-7,col-57,row-7 );
  g.drawLine(col-47, row-15,col-57,row-15 );  
  g.drawArc(col-58, row-15, 4, 8, 0, 360);

  g.drawLine(col1+80, row-4, col1+80, row-60); //engine front line
  g.drawLine(col-47, row-60, col, row-60); //back panel line
  g.drawLine(col1+20, row-60, col1+80, row-60); //engine up line
  g.drawArc(col, row-130, 240,140,15,165);  //uper arc
  g.drawLine(col1+18,321, col1+18,340);
//red light
  if(col%5==0)
   g.setColor(c2);
  else
   g.setColor(c1);

  g.fillArc(col+150, row-145, 15,40, 0,180); 
  g.setColor(black);
  g.drawArc(col+40, row-100, 50, 80, 0, 180); //back mirror
  g.drawLine(col+40, row-60, col+90, row-60);  //back mirror down line
  g.drawArc(col1-70, row-100, 50,80,0,180); //front mirror
  g.drawLine(col1-70, row-60,col1-20, row-60); //front mirror back line
  
//back wheel cover
  g.fillArc(col-9, row-28, 58,50, 0, 180);
  g.setColor(c1);
  g.fillArc(col-5, row-25, 50,50, 0, 180);
  
//front wheel cover
  g.setColor(black);
  g.fillArc(col1-9, row-28, 58,50, 0, 180);
  g.setColor(c1);
  g.fillArc(col1-5, row-25, 50,50, 0, 180);
 
//back wheel
  g.setColor(c3);
  g.drawOval(col,row-20,40,40);

//back wheel spikes
  g.setColor(c2);
  x=(col+20)+(int)(20*Math.sin(angle));
  y=(row)+(int)(20*Math.cos(angle));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+45));
  y=(row)+(int)(20*Math.cos(angle+45));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+90));
  y=(row)+(int)(20*Math.cos(angle+90));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+100));
  y=(row)+(int)(20*Math.cos(angle+100));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+135));
  y=(row)+(int)(20*Math.cos(angle+135));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+145));
  y=(row)+(int)(20*Math.cos(angle+145));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+180));
  y=(row)+(int)(20*Math.cos(angle+180));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+190));
  y=(row)+(int)(20*Math.cos(angle+190));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+225));
  y=(row)+(int)(20*Math.cos(angle+225));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+235));
  y=(row)+(int)(20*Math.cos(angle+235));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+280));
  y=(row)+(int)(20*Math.cos(angle+280));
  g.drawLine(col+20, row, x, y);
  x=(col+20)+(int)(20*Math.sin(angle+325));
  y=(row)+(int)(20*Math.cos(angle+325));
  g.drawLine(col+20, row, x, y);

//front wheel
  g.setColor(c3);
  g.drawOval(col1,row-20,40,40);
//front wheel spikes
  g.setColor(c2);
  x=(col1+20)+(int)(20*Math.sin(angle));
  y=(row)+(int)(20*Math.cos(angle));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+45));
  y=(row)+(int)(20*Math.cos(angle+45));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+90));
  y=(row)+(int)(20*Math.cos(angle+90));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+100));
  y=(row)+(int)(20*Math.cos(angle+100));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+135));
  y=(row)+(int)(20*Math.cos(angle+135));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+145));
  y=(row)+(int)(20*Math.cos(angle+145));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+180));
  y=(row)+(int)(20*Math.cos(angle+180));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+190));
  y=(row)+(int)(20*Math.cos(angle+190));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+225));
  y=(row)+(int)(20*Math.cos(angle+225));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+235));
  y=(row)+(int)(20*Math.cos(angle+235));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+280));
  y=(row)+(int)(20*Math.cos(angle+280));
  g.drawLine(col1+20, row, x, y);
  x=(col1+20)+(int)(20*Math.sin(angle+325));
  y=(row)+(int)(20*Math.cos(angle+325));
  g.drawLine(col1+20, row, x, y);
  String str=x+"  "+y;
  if(col%3==0)
  {
   g.setColor(c6);
   g.fillOval(col-90, row-30, 5,8);
   g.fillOval(col-90, row-15, 5,8);
   g.fillOval(col-90, row, 5,8);
  }
  if(col%3==1)
  {
   g.setColor(c5);
   g.fillOval(col-80, row-20, 3,5);
   g.fillOval(col-80, row-5, 3,5);
  }
  if(col%3==2)
  {
   g.setColor(black);
   g.fillOval(col-68, row-10, 3,4);
  }
  angle+=1;
  if(col==1500)
  {
   col=-300;
   col1=col+220;
  }
  else
  {
   col+=1;
   col1+=1;
  }
 }
}

Output
Java Program Name: Applet_Animation.java

C Program to Generate Analog Clock Using Graphics

It is a sample C program to generate analog clock using graphics in c programming. You run this code and enter the time Hour, Minutes and Second and press Enter. You will get Analog clock that start from your set time.

Program Code

//C program For Analog Clock
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#include<math.h>
#include<dos.h>
main()
{
int gd=DETECT,gm;
int xm,ym,i,j,k,hrs,min,sec;
clrscr();
// Entering the correct and current time with verification
printf("Enter the current time\n Hours: ");
scanf("%d",&hrs);
printf("Minutes: ");
scanf("%d",&min);
printf("Seconds: ");
scanf("%d",&sec);

while (hrs<=0||hrs>12)
 {
 printf("Enter the correct hour:");
 scanf("%d",&hrs);
 }

while (min<0||min>=60)
 {
 printf("Enter the correct minute:");
 scanf("%d",&min);
 }

while (sec<0||sec>=60)
 {
 printf("Enter the correct second:");
 scanf("%d",&sec);
 }

//   Initilization of graphics mode
initgraph(&gd,&gm,"..\\bgi");
xm=getmaxx();
ym=getmaxy();

//   Generating the gasic outline of the clock
for(i=0;i<3;i++)         //   Drawing outer circle in dark
 circle(xm/2,ym/2,200+i);

setcolor(4);

for (i=-1;i<2;i++)      //Drawing the 2 vertical lines in thick
 {
 line(xm/2+i,ym/2-200,xm/2+i,ym/2-170);
 line(xm/2+i,ym/2+200,xm/2+i,ym/2+170);
 }

for (i=-1;i<2;i++)        //Drawing 2 horizontal lines in thick
 {
 line(xm/2-200,ym/2+i,xm/2-170,ym/2+i);
 line(xm/2+200,ym/2+i,xm/2+170,ym/2+i);
 }

setcolor(15);

for (i=1;i<12;i++)                  //Drawing the remaining lines in light
 if ((i!=3)&&(i!=6)&&(i!=9))
  line(xm/2+200*cos(3.14*i/6),ym/2+200*sin(3.14*i/6),xm/2+170*cos

(3.14*i/6),ym/2+170*sin(3.14*i/6));

// outtextxy(xm/2+50,ym/2+225,"CLOCK MADE BY  D VAMSI KRISHNA");

// Setting the error in hours hand
if (hrs==12)
 hrs=0;
if (hrs==11)
 hrs=-1;
if (hrs==10)
 hrs=-2;
if (hrs==9)
 hrs=-3;


k=sec;
j=min*60+i;
i=hrs*60*60+j;

//   Drawing the lines of minutes hours n seconds and updating it regularly
while(!kbhit())
 {
  
 setcolor(9);
 outtextxy(xm/2-60,ym/2+75,"D VAMSI KRISHNA");
 setcolor(14);
 line(xm/2,ym/2,xm/2+100*cos(0.000145*i-1.570),ym/2+100*sin(0.000145*i-1.570));
 circle(xm/2+100*cos(0.000145*i-1.570),ym/2+100*sin(0.000145*i-1.570),3);
 setcolor(3);
 line(xm/2,ym/2,xm/2+125*cos(0.001745*j-1.570),ym/2+125*sin(0.001745*j-1.570));
 circle(xm/2+125*cos(0.001745*j-1.570),ym/2+125*sin(0.001745*j-1.570),3);
 setcolor(5);
 line(xm/2,ym/2,xm/2+150*cos(0.1047*k-1.570),ym/2+150*sin(0.1047*k-1.570));
 //circle(xm/2+150*cos(0.1047*k-1.570),ym/2+150*sin(0.1047*k-1.570),3);
 delay(1000);

 setcolor(0);
 line(xm/2,ym/2,xm/2+100*cos(0.000145*i-1.570),ym/2+100*sin(0.000145*i-1.570));
 circle(xm/2+100*cos(0.000145*i-1.570),ym/2+100*sin(0.000145*i-1.570),3);
 line(xm/2,ym/2,xm/2+125*cos(0.001745*j-1.570),ym/2+125*sin(0.001745*j-1.570));
 circle(xm/2+125*cos(0.001745*j-1.570),ym/2+125*sin(0.001745*j-1.570),3);
 line(xm/2,ym/2,xm/2+150*cos(0.1047*k-1.570),ym/2+150*sin(0.1047*k-1.570));
 //circle(xm/2+150*cos(0.1047*k-1.570),ym/2+150*sin(0.1047*k-1.570),3);

 if (i==32400)
  i=-10800;
 if (k==60)
  k=0;
 if (j==3600)
  j=3600;

 i++;
 j++;
 k++;

 }
getch();
closegraph();
return 0;
}

Output

Difference Between White Box And Black Box Framework

What is reuse of framework?

Reuse - It is advantage of object oriented development. Object oriented approach has a unique feature of inheritance. In this child class acquires properties of parent class. It reduces the development time of a project. No need to rewrite same code again.

Framework - It is a set of classes that work together to achieve a purpose but that must be specialized internally by the designer.

Difference between white box framework and black box framework

1. In white box framework, where developer often needs to know the detailed implementation of framework but in black box framework consists of components that hide their internal implementation.

2. In white box framework less range of flexibility but in black box grater range of flexibility. Developers can choose different components and classes in black box framework. In white box have to show complete details but in black box has flexibility. Developers can select which data to show and which data to hide.

3. In developing, white box framework easy to develop compare to black box because no need to analyses about what data to be hide and what data to be show. In white box complete data is available and all internal information also available. No level of abstraction in white box so easy to develop.

4. White box framework always comes with source code but black box not comes with source code.

5. White box framework requires deep understanding of framework implementation but black box not require deep knowledge of framework development.

Gray Box Framework: A Hybrid Framework of White Box and Black Box
Gray-box frameworks take both inheritance and composition approach, is usually made up with combination of abstract classes and concrete classes. When developing an application framework, there is no requirement that the framework contain either all abstract classes or all concrete classes. In business application sometimes need to inherit all properties of component and sometimes only need to use properties.

In fact, neither pure white-box nor black-box frameworks are practical in the real world. In real world by mixing of white-box frameworks and black-box frameworks effectively create a gray-box frameworks.