我这个结果是这样为什么呀？     

老师，现在可以打印出1-25每行5个，但想给他们打乱顺序比如说1  3  24  7   2这种，怎么操作？

老师你好

关于这一章的内容我想不明白，为什么在1的位置调用方法，在碰撞后不会画图，在2的位置碰撞后会画图

com.java.oopTestOverride {
    (String args[]){
        Vehicle v = Vehicle()}
Vehicle{(){
        System..println()}
    Vehicle (){
        System..println()}
}
Horse Vehicle{(){
        System..println()}
    Horse (){
        Horse()}
}
}

在创建对象时，为啥会提示加静态修饰符static

package com.bjsxt.plane;

/**
 * 存放相关的常量
 */
public class Constant {
    //游戏窗口的宽度
    public static final int GAME_WIDTH = 500;
    //游戏窗口的高度
    public static final int GAME_HEIGHT = 500;


}

package com.bjsxt.plane;

import java.awt.*;

/**
 * 游戏物体的分类
 */
public class GameObject {

    Image img;          //图片
    double x, y;        //物体的坐标
    int planeX = 100;   //物体移动的速度
    int width, height;  //物体的宽度和高度

    public GameObject(Image img, double x, double y, int planeX, int width, int height) {
        this.img = img;
        this.x = x;
        this.y = y;
        this.planeX = planeX;
        this.width = width;
        this.height = height;
    }

    public void drawMyself(Graphics g) {
        g.drawImage(img, (int) x, (int) y, width, height, null);
    }

    //所有的物体都是矩形，当你获得对应的矩形的时候，我们就可以做一些相关的判断操作！
    public Rectangle getRec() {
        return new Rectangle((int) x, (int) y, width, height);
    }
}

package com.bjsxt.plane;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

//import java.imageio.ImageIO;

/**
 * 游戏工具类
 */
public class GameUtil {

    //构造器私有,防止别人创建本类的对象
    private GameUtil() {

    }

    public static Image getImage(String path) {     //images/plane.png
        BufferedImage img = null;
        URL u = GameUtil.class.getClassLoader().getResource(path);
        try {
            img = ImageIO.read(u);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return img;
    }

    public static void main(String[] args) {
        Image img = GameUtil.getImage("images/plane.png");
        System.out.println(img);
    }


}

package com.bjsxt.plane;

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

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


    Image planeImg = GameUtil.getImage("images/plane.png");
    Image bg = GameUtil.getImage("images/bg.jpg");

    static int count = 0;

    GameObject plane2 = new GameObject(planeImg, 100, 100, 3, 22, 33);
    GameObject plane3 = new GameObject(planeImg, 200, 100, 3, 22, 33);

    @Override
    public void paint(Graphics g) {     //g当做是一支画笔
        System.out.println("绘制窗口次数:" + count);
        count++;

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

        plane2.drawMyself(g);
        plane3.drawMyself(g);


    }

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

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

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

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

        new PaintThread().start();  //启动重画窗口的线程

    }

    /**
     * 定义了一个重画窗口的线程类
     * 定义成内部类是为了方便直接使用窗口类的相关方法
     */
    class PaintThread extends Thread {
        @Override
        public void run() {
            while (true) {
                repaint();      //内部类可以直接使用外部类的成员！
                try {
                    Thread.sleep(50);           //1s=1000ms 1s画20次(20*50=1000)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    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();
    }

}

    想在运行效果下插入一张照片，为什么无法插入啊？

Comparable方法中的this.age和man22.age，其中man22.age代表的是什么，是哪两个数据在比较？

这个是为啥

请问老师，我这个错是为什么呀？？

只显示一个分号的错误。

老师，我想让boy类继承student类，为什么会报错？

public class kaoshi {
    public static void main(String[] args) {
        exam[] exams = new exam[2];
        exams[0]= new exam(70,50,90,100);
        exams[1]= new exam(12,20,30,40);
        for(int i = 0;i< exams.length;i++) {
            System.out.println(exams[i]);
        }
        for(exam xx:exams){
            System.out.println(xx);
        }
        System.out.println(exams[0]);

    }
    static class exam {
            private int java;
            private int python;
            private int dasj;
            private int regzn;

            public exam() {
            }

            public exam(int java, int python, int dasj, int regzn) {
                super();
                this.java = java;
                this.python = python;
                this.dasj = dasj;
                this.regzn = regzn;
            }
            @Override
        public String toString() {
            return "我的java成绩是："+java+"\t"+"我的Python成绩是："+python+"\t"+"我的大数据成绩是："+dasj+"\t"+"我的人工智能成绩是："+regzn;
        }

        public void setJava(int java) {
                this.java = java;
            }

            public int getJava() {
                return java;
            }

            public void setPython(int python) {
                this.python = python;
            }

            public int getPython() {
                return python;
            }

            public void setDasj(int dasj) {
                this.dasj = dasj;
            }

            public int getDasj() {
                return dasj;
            }

            public void setRegzn(int regzn) {
                this.regzn = regzn;
            }

            public int getRegzn() {
                return regzn;
           }

    }

}

你好 老师  我感觉这段代码里面所有的get和set方法是不是可以删除不写的

总结一下，我在本章学到的内容，请老师检查一下是否有理解错误的地方

1、方法区

是堆，所有线程共享，只有一个

存放：static修饰的内容、不变及唯一的内容、类的信息（成员变量、方法、构造器）

2、堆

所有线程共享，只有一个。分配灵活，速度慢

存放：对象（对象的共性是都有同一个类的方法和成员变量，个性是由构造器代入实参赋予的？）（对象是内存地址，存着方法区中类的信息所在的地址？）

3、栈

可以存在复数的栈和线程。每个线程中可以有多个栈，栈属于线程私有，线程间不能共享。且同一个线程栈与栈之间也不共享信息（局部变量）；先进后出；由JVM分配空间，速度快。

存放：方法的信息（局部变量）

package com.java.oop;
//测试方法重写
public class TestOverride {
    public static void main(String args[]){
        Vehicle v = new Vehicle();
        Horse h = new Horse();
    }
static class Vehicle{//父类
    public void run(){
        System.out.println("跑");
    }
    public Vehicle getVehicle(){
        System.out.println("给你交通工具");
        return null;
    }
}
static class Horse extends Vehicle{//子类继承父类拥有父类方法
    public void run(){
        System.out.println("嘚嘚得");
    }
    public Horse getVehicle(){
        return new Horse();
    }
}
}

在创建对象时，报错提示类加static静态修饰符

老师问一下就是方法重写的时候假如：

父类的方法中是有返回值类型，但是子类要重写的方法中返回值类型写成了 void的话，子类的这个方法也算是重写吗？

实时效果反馈：

原文：Full GC用于清理年轻代，年老代区域，jvm调优很大程度上是对Full GC的调节。

Full GC是清理所有区域的吧？答案不严谨呀？还是我理解错了呢