老师，我把静态变量的值赋给对象调用的非静态变量是不是意味着改变了非静态变量的属性，所以我再用非静态去调用才会报错

import java.util.Scanner;
public class MonthlyIncomeTax {
    public static void main(String[] args){
        System.out.println("########个人月薪计算器########");
        Scanner s = new Scanner(System.in);
        while (true){
            System.out.println("请输入你的月薪:");
           double monthSalary = s.nextInt();
            if (monthSalary>=85000){
                double monthSalary01;
                monthSalary01 = monthSalary- (monthSalary-85000)*0.45-25000*0.35-20000*0.30-10000*0.25-13000*0.2-9000*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+monthSalary01);
            }else if (monthSalary>=60000){
                double monthSalary02;
                monthSalary02 =monthSalary-(monthSalary-60000)*0.35-20000*0.30-10000*0.25-13000*0.2-9000*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+monthSalary02);
            }else if (monthSalary>=40000){
                double mountSalary03;
                mountSalary03 = monthSalary-(monthSalary-40000)*0.3-10000*0.25-13000*0.2-9000*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+mountSalary03);
            }else if (monthSalary>=30000){
                double monthSalary04;
                monthSalary04 = monthSalary-(monthSalary-30000)*0.25-13000*0.2-9000*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+monthSalary04);
            }else if (monthSalary>=17000){
                double monthSalary05;
                monthSalary05 = monthSalary-(monthSalary-17000)*0.2-9000*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+monthSalary05);
            }else if (monthSalary>=8000){
                double monthSalary06;
                monthSalary06 = monthSalary-(monthSalary-8000)*0.1-3000*0.03 ;
                System.out.println("除税后你的真实工资："+monthSalary06);
            }else if (monthSalary>=5000){
                double monthSalary07;
                monthSalary07 = monthSalary- (monthSalary-5000)*0.03;
                System.out.println("除税后你的真实工资："+monthSalary07);
            }else {
                System.out.println("除税后你的真实工资："+monthSalary);
            }
            System.out.println("若输出88则退出程序，若输入66则重新开始计算下一个年薪");

            int conut =s.nextInt();
            if (conut==88){
                System.out.println("系统退出！！！！");
                break;
            }else if(conut==1) {
                System.out.println("########个人月薪计算器########");
                continue;
            }

        }

    }

}

jer1.8.0_301有什么用，可以卸载吗

package com.bjsxt.plane;
import jdk.jshell.tool.JavaShellToolBuilder;

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 planeimg=GameUtil.getImage("images/plane.png");
    Image bg=GameUtil.getImage("images/bg.jpg");


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

    Shell[] shells=new Shell[3];

    Explode explode;

    @Override
    public void paint(Graphics g) {   //g当作是一只画笔
        g.drawImage(bg,0,0,500,500,null);
        p1.drawMyself(g);
        for(int i=0;i<shells.length;i++){
            shells[i].drawMyself(g);
            //实现碰撞检测，将多有炮弹和飞机进行检测矩形检测
            boolean peng=shells[i].getRec().intersects(p1.getRec());
            if(peng){
               // System.out.println("飞机被击中了！！！");
                p1.live=false;
                //处理爆炸效果
                if(explode==null){
                    explode=new Explode(p1.x,p1.y);
                }
                explode.drawMyself(g);
            }
        }
    }
    //初始化窗口
    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()); //启动键盘监听
        for(int i=0;i<shells.length;i++){
            shells[i]=new Shell();

        }
    }

    /**
     * 定义一个重画窗口的线程类
     * 定义成内部类是为了方便直接使用窗口类的相关方法
     */
    class PaintThread extends Thread{
        @Override
        public void run() {
            while(true){
                repaint(); //内部类可以调用外部类的成员
                try {
                    Thread.sleep(50);          //1秒画20次（20*50=1000）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //内部类，实现键盘的监听处理
    class KeyMonitor extends KeyAdapter{
        @Override
        public void keyPressed(KeyEvent e) {
           /* if(e.getKeyCode()==KeyEvent.VK_LEFT){
                left=true;
            }if(e.getKeyCode()==KeyEvent.VK_RIGHT){
                right=true;
            }*/
            p1.addDirection(e);
        }
        @Override
        public void keyReleased(KeyEvent e) {
            p1.minusDirection(e);
        }
    }
    //解决屏幕闪烁缓冲技术
    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 com.bjsxt.plane;

import java.awt.*;

/**
 * 爆炸类
 */
public class Explode {
    //位置
    double x,y;
    static Image[] imgs=new Image[16];

    int count;
    static{
        for(int i=0;i<imgs.length;i++){
            imgs[i]=GameUtil.getImage("images/explode/e"+(i+1)+".gif");
            imgs[i].getWidth(null);
        }
    }
   public void  drawMyself(Graphics g){
        if(count<16){
            g.drawImage(imgs[count],(int)x,(int)y,null);
            count++;
        }
   }
    public Explode(){}
    public Explode(double x,double y){
        this.x=x;
        this.y=y;
    }
}

老师怎么解决啊 ，没看到解决的办法啊

老师好：

      麻烦帮我看一下下面这段代码加的注释正不正确，有不对的或者说不准确的还望老师帮忙指出来，加深理解，顺便提问，代码第19行c1.tyreNum值为什么是10，第18行不是把10赋值给c2.tyreNum了吗

package homework;
/**
 * 使用文字和图画描述，如下程序的执行过程
 */
public class TestObject {                      //创建主类TestObject类
    public static void main(String[] args) {   //main方法
        Car c1 = new Car();                    //创建一个Car类的新对象c1
        c1.changeColor("红色");              //调用Car类的成员方法changeColor()给Car的字符串类型的成员变量color赋值为"红色"
        c1.showColor();                        //调用Car类的成员方法showColor()打印出"我的颜色是："字符串 拼接 Car类成员变量color的值(我的颜色是：红色)
        System.out.println(Car.tyreNum);       //打印出Car类的静态成员变量tyreNum的值(4)
        System.out.println(c1.tyreNum);        //打印出Car类的对象c1的静态成员变量的值(4)
        Car c2 = new Car();                    //创建一个Car类的新对象c2
        Engine e = new Engine();               //创建一个Engine类的新对象e
        e.speed = 1000;                        //给对象e的成员变量speed赋值为1000
        e.weight = 10;                         //给对象e的成员变量weight赋值为10
        c2.engine = e;                         //将对象e的引用赋给对象c2的成员变量engine
        c2.color = "黑色";                      //将对象c2的成员变量color赋值为"黑色"
        c2.tyreNum = 10;                       //将对象c2的静态成员变量tyreNum赋值为10
        System.out.println(c1.tyreNum);        //打印出对象c1的静态成员变量tyreNum的值(10)
    }
}

class Car {                                    //创建Car类
    static int tyreNum = 4;                    //声明Car类的整型静态成员变量tyreNum 并赋值为4
    Engine engine;                             //声明Car类的成员变量engine为Engine类型
    String color;                              // 声明一个字符串变量 color

    void changeColor(String c) {               //声明一个Car类的 无返回值的 带参成员方法 changeColor，形参为字符串类型 c
        color = c;                             // 将参数c的值赋值给Car类的成员变量color
    }

    void showColor() {                         //声明一个Car类的 无返回值的 无参成员方法 showColor
     System.out.println("我的颜色是：" + color); //打印出"我的颜色是："字符串  拼接Car类成员变量color的值
    }
}

class Engine {                                 //创建Engine类
    int speed;                                 //声明Engine类的整型成员变量speed
    int weight;                                //声明Engine类的整型成员变量weight
}

第16行输出语句那 p.getDistance(origin); 用了一个对象p的getD方法 为什么用另一个对象origin作为实参呢？是因为origin作为实参只是传递的是他的地址值吗？从而获得x y的值吗？

老师，我跟着敲，很多都不能理解，有必要再把基础课程听一遍么。

package com.whygame;
import java.awt.*;
import java.awt.event.*;
import  static com.whygame.GameUtil.*;
public class whygameframe extends Frame {
    int x=100,y=100;//飞机的坐标
    Image bg =GameUtil.getImage("images/bg.jpg");

    Image palane=GameUtil.getImage("images/meinv .jpg" );
    Plane plane=new Plane(palane,100,100,1);
    class keymonitr extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
           plane.addDriection(e);
        }

        @Override
        public void keyReleased(KeyEvent e) {
           plane.relDriection(e);
        }
    }
   public void Launchframe(){

        this.setTitle("Ying ge 's 飞机大战");
        this.setVisible(true);//窗口默认不可见，设置为可见true
        this.setSize(FrameWidth,FrameHeight);
        this.setLocation(FrameWidth,FrameHeight);
        //增加关闭窗口的动作
       this.addWindowListener(new WindowAdapter() {
           @Override
           public void windowClosing(WindowEvent e) {
              System.exit(0);
           }
       });
       new PaintThread().start();
       //启动键盘监听
       this.addKeyListener( new keymonitr());
    }

    @Override
    public void paint(Graphics g) {
     g.drawImage(bg,0,0,FrameWidth,FrameHeight,null);
plane.drawMyself(g);

     /*  Color old=g.getColor();
        g.setColor(Color.PINK);
       g.drawLine(100,10,200,20);
       g.drawRect(300,300,300,300);
       g.drawOval(400,400,100,100);
       g.drawString("你好",300,300);
       g.setColor(old);
       g.drawLine(200,50,400,100);
*/
    }
    public static void main(String[]args) {
        long a1 = System.currentTimeMillis();
        whygameframe frame = new whygameframe();
        frame.Launchframe();
        long a2 = System.currentTimeMillis();
        System.out.println("共用时：" + (a2 - a1) + "ms");
    }
class PaintThread extends Thread{
    @Override
    public void run() {
       while(true){
           repaint();
           try {
               sleep(10);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}
//解决屏幕闪烁问题
    private Image offScreenImage=null;
   public void update(Graphics g){
       if (offScreenImage==null){
           offScreenImage=this.createImage(FrameWidth,FrameHeight);
       }
       Graphics gOff=offScreenImage.getGraphics();
       paint(gOff);
       g.drawImage(offScreenImage,0,0,null);
   }
}
这是个什么错误，正常运行了几秒钟就不动了

为什么有定义类前面加class，有时候加public，有什么又加public class

我记得老师说过静态方法里面只能用静态变量和方法，那么main函数也被static修饰符修饰了，为什么可以调用非静态的方法和变量呢

age和id为啥要用private修饰，有什么特殊用意吗？

 ide ctrl加鼠标单击为啥没有源码

还是感觉有点乱，听得有点糊涂所以我定义的类每次要重新定义，但是那个构造器下代码可以重复调用？

代码：

public class Constants{

public static void main(String[] args) {

final double PI=3.14;

double r =3;

double area =PI*r*r;

System.out.println("圆形的面积是"+area)；

}

}

报错：

另存为ANSI格式后，也是报错

老师，我附上问题的出现的gif图和代码，您帮我看一下，看了一个小时了，还没有看出问题来，幸苦您一下哈

，谢谢