Javacron为什么刚第一次不执行

public class Person {
    private String name;
    private int age;
    public Person(){//无参构造方法
        
    }
    public Person(String name){//构造方法二：初始化姓名
        this.name=name;
    }
    public Person(int age){//构造方法三：初始化年龄
        this.age=age;
    }
    public Person(String name,int age){//构造方法四：初始化姓名和年龄
        this.name=name;
        this.age=age;
    }
    public String getName(){//获取姓名
        return name;
    }
    public String setName(String name){//设置姓名
        return name;
    }
    public String getAge(){//获取年龄
        return name;
    }
    public void setAge(int age){//设置年龄
        if(age<0){
            this.age=0;
        }else{
            this.age=age;
        }
    }
    //打印信息
    public void printMessage(){
        System.out.println("姓名："+name+"  年龄："+age);
    }
    //模拟过了一年，年龄加一
    public void addAge(){
        age++;
    }
//  public static void main(String[] args) {
//      // TODO Auto-generated method stub
//
//  }

}

1）该类包含几个属性？2几个构造方法？4几个成员方法？6
2）属性、构造方法、成员方法的访问权限修饰符分别是什么？
this，类名，
3）什么是方法的重载？此程序，哪几个方法构成了重载？
Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法
无参方法，方法二，方法三，方法四
4）为什么要提供getXXX和setXXX方法？

public class TestPerson {

    public static void main(String[] args) {
        //创对象1
        Person p1 = new Person("小明",18);
        p1.addAge();
        p1.printMessage();
        //创对象2
        Person p2 = new Person("小红");
        p2.setAge(20);
        p2.addAge();
        p2.printMessage();
        //创对象3
        Person p3 = new Person("小北",100);
        p3.addAge();
        p3.printMessage();
    }
}

1）创建对象时，将自动调用什么方法？
2）以上程序创建了三个对象，分别调用的是哪个构造方法？
3）创建对象三时，没有传递参数，请问如何初始化对象呢？请添加初始化对象的代码。
4）我想要统计这三个对象中，有多少是成年人（年龄大于等于18岁）并输出人数。请添加相应代码。

1. 编写“电费管理类”及其测试类。
    第一步 编写“电费管理”类
   1）私有属性：上月电表读数、本月电表读数
   2）构造方法：无参、2个参数
   3）成员方法：getXXX（）方法、setXXX（）方法
   4）成员方法：显示上月、本月电表读数
    第二步 编写测试类
   1）创建对象一：上月电表读数为1000，本月电表读数为1200。
   要求：调用无参构造方法创建对象；
   调用setXXX（）方法初始化对象；
   假设每度电的价格为1.2元，计算并显示本月电费。
   2）创建对象二：上月电表读数1200，本月电表读数为1450。
   要求：调用2个参数的构造方法创建并初始化对象；
   调用setXXX（）方法修改本月电表读数为1500（模拟读错了需修改）；
   假设每度电的价格为1.2元，计算并显示本月电费。

public class dfgl {
    private int beforeMoth;
    private int newMoth;
    public dfgl(){//无参构造方法
        
    }
    public dfgl(int beforeMoth,int newMoth){//两个参数构造方法
        this.beforeMoth=beforeMoth;
        this.newMoth=newMoth;   
    }
    public int getbeforeMoth(){//获取上月读表
        return beforeMoth;
    }
    public void setbeforeMoth(int beforeMoth){//设置上月读表      
        this.beforeMoth=beforeMoth;
    }
    public int getnewMoth(){//获取本月读表
        return newMoth;
    }
    public void setnewMoth(int newMoth){//设置本月读表       
        this.newMoth=newMoth;
    }    
    public void printMessage(){
        System.out.println("上月："+beforeMoth+"  本月："+newMoth);
        System.out.println("本月电费为："+(getnewMoth()-getbeforeMoth())*1.2);
    }

}

测试类：

public class Testdfgl {
    public static void main(String[] args) {
        //创对象1
        dfgl p1 = new dfgl();
        p1.setbeforeMoth(1000);
        p1.setnewMoth(1200);
        p1.printMessage();
 
        //创对象2
        dfgl p2 = new dfgl(1200,1450);
        p2.setbeforeMoth(1200);
        p2.setnewMoth(1450);
        p2.setnewMoth(1500);
        p2.printMessage();
        }
}

3.1 “圆柱体”类

私有属性：圆底半径、高，
构造方法：带两个参数
方法1：计算底面积
方法2：计算体积
方法3：打印圆底半径、高、底面积和体积。
3.2 测试类

创建2个对象，并调用方法

public class yuanzhu{
    private float R;
    private float H;
    double P=3.14;
    double S;
    double V;
    public yuanzhu(){
        
    }
    public yuanzhu(float R,float H){
        this.H=H;
        this.R=R;
    }
    public float getR(){//获取半径
        return R;
    }
    public void setR(float R){//设置半径        
        this.R=R;
    }
    public float getH(){//获取高度
        return H;
    }
    public void setH(float H){//设置高度       
        this.H=H;
    }
    public void jisuanS(){//计算底面积       
        S=P*R*R;
    } 
    public void jisuanV(){//计算体积       
        V=S*H;
    }
    public void dayin(){//打印       
        System.out.println("半径为："+R+"   高为："+H+"   底面积为："+S+"   体积为："+V);
    }
    
}

测试类

public class Testyuanzhu {
    public static void main(String[] args) {
        //创对象1
        yuanzhu V1 = new yuanzhu(1, 1);
        V1.jisuanS();
        V1.jisuanV();
        V1.dayin();
        //创对象2
        yuanzhu V2 = new yuanzhu();
        V2.setR(1);
        V2.setH(2);
        V2.jisuanS();
        V2.dayin();      
        }
}

4、编写“四则运算类”及其测试类。

4.1 应用场景

计算器。能实现简单的四则运算，要求：只进行一次运算。
4.1 “四则运算”类

私有属性：操作数一、操作数二、操作符
构造方法：带两个参数
构造方法：带三个参数
方法一：对两个操作数做加运算
方法二：对两个操作数做减运算
方法三：对两个操作数做乘运算
方法四：对两个操作数做除运算
4.2 测试类

从键盘输入两个操作数和一个操作符，计算之后，输出运算结果。

public class jisuan {
    private double a;
    private double b;
    private String c;
    public jisuan(double a,double b) {
    this.a=a;
    this.a=a;
    }
    public void jusuan(double a,double b,String c) {
        this.a=a;
        this.b=b;
        this.c=c;
    }
    public double geta() {
        return a;
    }
    public double getb() {
        return b;
    }
    public String getc() {
        return c;
    }
    public void jia(double a,double b) {
        double sum;
        sum=a+b;
        System.out.println("a+b="+sum);
    }
    public void jian(double a,double b) {
        double sum;
        sum=a-b;
        System.out.println("a-b="+sum);
    }
    public void chen(double a,double b) {
        double sum;
        sum=a*b;
        System.out.println("a*b="+sum);
    }
    public void chu(double a,double b) {
        double sum;
        sum=a/b;
        System.out.println("a/b="+sum);
    }
}

import java.util.Scanner;
public class Tsetjisuan {
    public static void main(String[] args) {
        double a = 0;
        double b = 0;
        String c = null;
        jisuan s1 = new jisuan(a,b);
        Scanner rd=new Scanner(System.in);
        System.out.print("请输入第一个数据：");
        a=rd.nextDouble();
        System.out.print("请输入第二个数据：");
        b=rd.nextDouble();
        System.out.print("请输入运算符：");
        c=rd.next();
        switch(c) {
            case "+": s1.jia(a,b);break;
            case "-": s1.jian(a, b);break;
            case "*": s1.chen(a, b);break;
            case "/": s1.chu(a, b);break;
        }
    }
}