CareerCup

Generics is implemented via Erasure. Type parameters in generics are for compile time safety. Once compiled at bytecode level, raw and generic types are same.
Compile erases all the type information at bytecode level.
It means bytecode of List<String> is same as bytecode of List.

When we implement the generic then compiler does these things
1. Type casting if necessary to preserve type safety.
2. Resolve all the cases at compile time. Make safe to run.
3. Generate a bridge to gain polymorphism.

Please make comments if not correct.

During compilation phase providing actual type replacements for the parameterized variable(s) declared (say class SomeClass <T>) and providing relevant type casts compatible with the actual parameters passed for the parameterized variable(s) is Type Erasure in Java's Generic implementation. All these erasures take place during compilation phase itself.

package com.zetcode;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;

public class HelloWorld{
public static void main(String []args){

final int B_WIDTH = 300;
final int B_HEIGHT = 300;
final int DOT_SIZE = 10;
final int ALL_DOTS = 900;
final int RAND_POS = 29;
final int DELAY = 140;

final int x[] = new int[ALL_DOTS];
final int y[] = new int[ALL_DOTS];

int dots;
int apple_x;
int apple_y;

boolean leftDirection = false;
boolean rightDirection = true;
boolean upDirection = false;
boolean downDirection = false;
boolean inGame = true;

Timer timer;
Image ball;
Image apple;
Image head;

Board(); {

initBoard();
}

initBoard(); {

addKeyListener(new TAdapter());
setBackground(Color.black);
setFocusable(true);

setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));
loadImages();
initGame();
}

loadImages(); {

ImageIcon iid = new ImageIcon("src/resources/dot.png");
ball = iid.getImage();

ImageIcon iia = new ImageIcon("src/resources/apple.png");
apple = iia.getImage();

ImageIcon iih = new ImageIcon("src/resources/head.png");
head = iih.getImage();
}

initGame();

dots = 2;

for (int z = 0; z < dots; z++) {
x[z] = 50 - z * 10;
y[z] = 50;
}

locateApple();

timer = new Timer(DELAY, this);
timer.start();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

doDrawing(g);
}

drawing (Graphics g); {

if (inGame) {

g.drawImage(apple, apple_x, apple_y, this);

for (int z = 0; z < dots; z++) {
if (z == 0) {
g.drawImage(head, x[z], y[z], this);
} else {
g.drawImage(ball, x[z], y[z], this);
}
}

Toolkit.getDefaultToolkit().sync();

} else {

gameOver(g);
}
}

void gameOver(Graphics g) {

String msg = "Game Over";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = getFontMetrics(small);

g.setColor(Color.white);
g.setFont(small);
g.drawString(msg, (B_WIDTH - metr.stringWidth(msg)) / 2, B_HEIGHT / 2);
}

void checkApple() {

if ((x[0] == apple_x) && (y[0] == apple_y)) {

dots++;
locateApple();
}
}

void move() {

for (int z = dots; z > 0; z--) {
x[z] = x[(z - 1)];
y[z] = y[(z - 1)];
}

if (leftDirection) {
x[0] -= DOT_SIZE;
}

if (rightDirection) {
x[0] += DOT_SIZE;
}

if (upDirection) {
y[0] -= DOT_SIZE;
}

if (downDirection) {
y[0] += DOT_SIZE;
}
}

void checkCollision() {

for (int z = dots; z > 0; z--) {

if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
inGame = false;
}
}

if (y[0] >= B_HEIGHT) {
inGame = false;
}

if (y[0] < 0) {
inGame = false;
}

if (x[0] >= B_WIDTH) {
inGame = false;
}

if (x[0] < 0) {
inGame = false;
}

if (!inGame) {
timer.stop();
}
}

void locateApple() {

int r = (int) (Math.random() * RAND_POS);
apple_x = ((r * DOT_SIZE));

r = (int) (Math.random() * RAND_POS);
apple_y = ((r * DOT_SIZE));
}

@Override
public void actionPerformed(ActionEvent e) {

if (inGame) {

checkApple();
checkCollision();
move();
}

repaint();
}

class TAdapter extends KeyAdapter {

@Override
public void keyPressed(KeyEvent e) {

int key = e.getKeyCode();

if ((key == KeyEvent.VK_LEFT) && (!rightDirection)) {
leftDirection = true;
upDirection = false;
downDirection = false;
}

if ((key == KeyEvent.VK_RIGHT) && (!leftDirection)) {
rightDirection = true;
upDirection = false;
downDirection = false;
}

if ((key == KeyEvent.VK_UP) && (!downDirection)) {
upDirection = true;
rightDirection = false;
leftDirection = false;
}

if ((key == KeyEvent.VK_DOWN) && (!upDirection)) {
downDirection = true;
rightDirection = false;
leftDirection = false;
}
}
}
}