老师好

请问每个声明变量的大小是怎么认定的，为什么double是八个字节大小，int是4个

常用包里的函数（方法？）被其他包（自己建）里的类调用，这是抽象化是：不同包里的类可以调用其他包里的函数吗？

老师请问为什么我每次只要离开我的游戏画面（换去另一个窗口，或者是缩小窗口），程序就会崩？

package com.bjsxt.planeWar;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * 游戏主窗口
 */
public class MyGameFrame extends Frame {

    Image planeImage = GameUtil.getImage("Images/plane.png");
    Image bg = GameUtil.getImage("Images/bg.jpg");

    Plane p1 = new Plane(planeImage, 100, 100, 7);

    boolean left, right, up, down;  //飞机方向控制

    @Override
    public void paint(Graphics g) { //g当做是一支画笔

        g.drawImage(bg, 0, 0, 500, 500, null);

        p1.drawMyself(g);

        if (left) {
            p1.x -= p1.speed;   //为什么是 - ：记住画面是从左上角开始的
        }
        if (right) {
            p1.x += p1.speed;
        }
        if (up) {
            p1.y -= p1.speed;
        }
        if (down) {
            p1.y += p1.speed;
        }

    }

    // 初始化窗口
    public void launchFrame() {
        this.setTitle("飞机大战-尚学堂");
        setVisible(true); //窗口是否可见

        setSize(Constant.GAME_WIDTH, Constant.GAME_HEIGHT); //窗口大小

        setLocation(100, 100); //窗口打开位置

        // 增加关闭窗口的动作
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0); // 正常退出程序

            }
        });

        new PaintThread().start(); //启动重画窗口的线程
        this.addKeyListener(new KeyMonitor()); //启动键盘监听
    }

    /**
     * 定义了一个重画窗口的线程类
     * 定义成内部类是为了方便直接使用窗口类的相关方法
     */
    class PaintThread extends Thread {
        @Override
        public void run() {
            while (true) {
                repaint();      // 内部类可以直接使用外部类的成员

                try {
                    Thread.sleep(50);  //1s = 1000ms, 1s画20次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 内部类， 实现键盘的监听处理
    class KeyMonitor extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            System.out.println("按下："+e.getKeyCode());
//            if (e.getKeyCode() == KeyEvent.VK_LEFT) {
//                left = true;
//            }

            switch (e.getKeyCode()) {
                case KeyEvent.VK_LEFT:
                    left = true;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = true;
                    break;
                case KeyEvent.VK_UP:
                    up = true;
                    break;
                case KeyEvent.VK_DOWN:
                    down = true;
                    break;
            }

        }

        @Override
        public void keyReleased(KeyEvent e) {
            System.out.println("抬起："+e.getKeyCode());
            switch (e.getKeyCode()) {
                case KeyEvent.VK_LEFT:
                    left = false;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = false;
                    break;
                case KeyEvent.VK_UP:
                    up = false;
                    break;
                case KeyEvent.VK_DOWN:
                    down = false;
                    break;
            }
        }
    }


    private Image offScreenImage = null;
    public void update(Graphics g) {
        if(offScreenImage == null)
        offScreenImage = this.createImage(Constant.GAME_WIDTH, Constant.GAME_HEIGHT);//这是游戏窗口的宽度和高度
        Graphics gOff = offScreenImage.getGraphics(); paint(gOff);
        g.drawImage(offScreenImage, 0, 0, null);
    }

    public static void main(String[] args) {
        MyGameFrame gameFrame = new MyGameFrame();
        gameFrame.launchFrame();
    }
}

源代码：

package ballGame;
/**
 * 台球小游戏
 */

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javax.swing.*;

public class BallGame extends JFrame{
    static int drawCnt = 1;

    Image ball = Toolkit.getDefaultToolkit().getImage("images/ball.png");
    Image desk = Toolkit.getDefaultToolkit().getImage("images/desk.png");

    double x=200;
    double y=200;

  //  boolean right = true;
  //  boolean down = true;

    double degree = Math.PI/4;//3; // 设置球的角度

    public String format(double value){ // 取2位小数
        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(2, RoundingMode.HALF_UP);
        return bd.toString();
    }

    public void paint(Graphics g){
     //   System.out.println("窗口画了\t"+(drawCnt++)+"" +
      //          "\t次"+",\tx="+format(x)+",\ty="+format(y)); // 打印轨迹信息

        g.drawImage(desk, 0,0,null);
        g.drawImage(ball, (int)x, (int)y, null);

        x   =  x + 10*Math.cos(degree);
        y   =  y + 10*Math.sin(degree);

        if((x>=790) || (x<30))   {degree = Math.PI - degree;} // 左右边界反弹

        if((y>=430) || (y<70))   {degree = -degree;} // 上下界面反弹


        /*
        if(right)
            x+=1.5;
        else
            x-=1.5;

        if(x>=780){right=false;}
        else if(x<70){right = true;}

        if(down)
            y+=1;
        else
            y-=1;

        if(y>=430){down=false;}
        else if(y<70){down = true;}*/
    }

    // 创建窗口
    void launchFrame(){
        setSize(856, 501);
        setLocation(100, 100);
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                //   super.windowClosing(e);
                System.exit(0);
            }
        });
        setVisible(true);


/*
        while(true){
            repaint();

            try {
                Thread.sleep(40);
            }  catch(InterruptedException e)
            {
                e.printStackTrace();
            }
        }*/

        new PaintTread().start();
    }



    /**
     * 重画窗口的线程
     */
    class PaintTread extends Thread{
        @Override
        public void run() {
            while(true) {
                repaint();
                try {
                    Thread.sleep(40);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String[] args){
        BallGame game = new BallGame();
        game.launchFrame();

    }

    private Image offScreenInage = null;

    // 
    //
    // 参照飞机大战那个小项目，加了如下方法，运行时台球移动还是有鬼影（一闪一闪的），飞机大战里面的
    // 飞机和炮弹不会有残影
    public void update (Graphics g){
        if(offScreenInage == null){
         //   offScreenInage = this.createImage(this.getWidth(), this.getHeight());
            offScreenInage = this.createImage(856, 501);
        }

        Graphics gOff= offScreenInage.getGraphics();
        paint(gOff);
        g.drawImage(offScreenInage, 0, 0, null);
    }
}

运行没问题。

请教一个问题，在飞机大战那个小游戏的实操中，通过这段代码重画窗口以消除鬼影，但是为什么在这个台球这个案例中，我也添加了，但是好像没起到作用

咋找不到下载网址

老师，我想要一下您的这个画图软件，网络上面的好多都不是您电脑上的这个软件，而且网络上的软件还收费，方便的话可以发一下吗？

想请问一下老师，我把资料中的代码在IDEA里运行，但是也是无限循环，小球出不来

高老师，你好，有个小问题请教一下，我的光标为啥在这儿闪烁，

elicps 假如刪錯了，怎麼進行撤回呢？

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

读源码问题1：默认会返回“类名+@+16进制的hashcode，其中getClass()指的是包名吗？getName()指的是类名吗？hashCode()指的是什么了？

问题2：java源码有很多，成为称职的java开发人员，是不是需要把常用的类，方法都了如指掌？该怎么做到不相混淆，且还能记得住？

版本0.3同样不知道错在哪，网上搜索说可能是图片路径不对，核对后发现没问题啊

package cn.sxt.game;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
/**
 * 飞机游戏的主窗口
 * @author 高毅
 *
 */
public class MyGameFrame extends JFrame{
	
	Image plane = GameUtil.getImage("images/plane.png");
	Image bg = GameUtil.getImage("images/bg.jpg");
	
	int planeX = 250,planeY = 250;
	
	@Override
	public void paint(Graphics g) {  //自动被调，g相当于一支画笔
		super.paint(g);
		g.drawImage(bg, 0, 0, null);
		g.drawImage(plane, 250, 250, null);
		planeX++;
	}
	//内部类方便使用外部类的属性方法
	
	//帮助我们反复重画窗口
	class PaintThread extends Thread{
		@Override
		public void run() {
			while(true) {
				System.out.println("窗口画一次");
				repaint();  //重画
				
				try {
					Thread.sleep(40);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}  //1s=1000ms
			}
		}
	}
	
	
	/**
	 * 初始化窗口
	 */
	public void launchFrame(){
		this.setTitle("尚学堂学员，程序员作品");		
		this.setVisible(true);  //设置可见
		this.setSize(500, 500);  //设置窗口大小
		this.setLocation(300,300);  //窗口位置
		
		
		this.addWindowListener(new WindowAdapter() {
			//设置窗口关闭
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		
		new PaintThread().start(); //启动窗口重画的线程
		
	}
	
	public static void main(String[] args) {
		MyGameFrame f = new MyGameFrame();
		f.launchFrame();
	}
}

错误显示如下：

老师，我想问一下为什么我在launchFram方法中没有加this也同样运行起来了，在这个方法中this究竟有哪些作用

老师为什么我的会出现这个？

代码区：

package cn.sxt.oo2;

/**
 * 测试继承
 * @author 高淇
 *
 */
public class TestExtends {
	public static void main(String[]args) {
		Student stu=new Student();
		stu.name="高淇";
		stu.height=172;
		stu.rest();
		
		Student stu2=new Student("希希",6,"挖掘机专业");
		
		System.out.println(stu2 instanceof Student);
		System.out.println(stu2 instanceof Person);
		System.out.println(stu2 instanceof Object);
		System.out.println(new Person() instanceof Student);
	}
}


class Person /*extends Object*/{
	String name;
	int height;
	
	public void rest() {
		System.out.println("休息一会！");
	}
}

class Student extends Person{
	String major;
	
	public void study() {
		System.out.println("学习两小时！");	
	}
	
	public Student(String name,int height,String major) {
		this.name=name;
		this.height=height;
		this.major=major;
	}
	
	public Student() {
	}
}

问题：第20行那里，为什么要new一个Person?第25行不是建了一个Person类了吗？

可以有多个main重载吗？（符合重载的条件，就是名字都叫main，会不会有问题？）