大一期末——写程序100道

最新推荐文章于 2024-08-26 16:40:46 发布

鱼骨不是鱼翅

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量736

点赞数 13

文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/2301_80251684/article/details/139609931

版权

1．用循环的嵌套，输出输出如下图形

   *

   * * *

   * * * * *

   * * * * * * *

   * * * * *

   * * *

   *

    public static void main(String[] args) {
        int i=0;//用i记录行数
        int j=1;//用j记录每一行打印*的个数
    while (i<7){//打印7行
 if (i<3){//打印1~3行
     int x=j;用x记录需要打印*的个数
     while (x>0){
         System.out.print("*");
         x--;//每打印一个*，x--
     }
     j+=2;//每打印完一行，下一行的*个数加2
 } else if (i==3) {//打印到中间一行，直接打印
     System.out.print("*******");
 } else {//剩下的每打印一行，*的个数-2
     int x=j-2;
     while (x>0){
         System.out.print("*");
         x--;//每打印一个*，x--
     }
     j-=2;//每打印完一行，下一行的*个数减2
 }
        System.out.println();每打印一行，换行
i++;
    }
    }

2．写一段程序对数组int[] array内的元素从小到大重新排列

   public static void main(String[] args) {
        int []array={2,31,3,2,41,23,1,21,31,42,21};//定义一个数组并初始化
        Arrays.sort(array);//调用Arrays中的sort方法
        System.out.println(Arrays.toString(array));//调用Arrays中的toString方法将数组内容打印
    }

3．求 2/1+3/2+5/3+8/5+13/8.....前20项之和？

    public static void main(String[] args) {
        double sum=0;//定义一个求和变量,因为是分数，所以sum为double
        double x=2,y=1;//定义x变量为分子，y为分母
        for (int i = 0; i <20 ; i++) {
            sum+=x/y;//将每一个项数加到sum里面
            double t=x;//提前记录一下x，下一步会修改x的值
            x=t+y;//分子为前一项的分子和分母的和
            y=t;//分母为前一项的分子
        }
        System.out.println(sum);
    }

4．计算圆周率：

public static double PI(double C,double r){
        return C/(2*r);//C为周长，r为半径，π=C/(2*r)
    }

5.定义两个数3和10，输出大数和小数

    public static void main(String[] args) {
        int x1=3;
        int x2=10;
        if(x1>x2){
            System.out.println(x1+"是大数"+","+x2+"是小数");
        } else if (x1==x2) {
            System.out.println(x1+"和"+x2+"两数相等");
        } else {
            System.out.println(x1+"是小数"+","+x2+"是大数");
        }
    }

6. 用if..else语句，判断一个数字是奇数还是偶数

  public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int x=scanner.nextInt();//输入一个数
        if (x%2==0){//如果一个数模2取余为0，则是偶数，否则是奇数
            System.out.println(x+"是偶数");
        }else {
            System.out.println(x+"是奇数");
        }
    }

7. 定义两个数3和10，用三目运算符输出最大数

   public static void main(String[] args) {
     int x1=3;
     int x2=10;
     System.out.println(x1>x2?x1:x2);//使用？三目操作符，x1大于x2吗？大于的话输出x1，否则输出x2
    }

8. 定义两个数3和10，用if语句输出最大数

    public static void main(String[] args) {
        int x=3;
        int y=10;
        if (x>y){
            System.out.println(x);
        } else {
            System.out.println(y);
        }
    }

9.用while输出1+2+……+10的和

    public static void main(String[] args) {
        int sum=0;
        int i=1;
       while (i<=10){
           sum+=i;
           i++;
       }
        System.out.println(sum);
    }

10.用do while语句输出1+2+……+10的和

    public static void main(String[] args) {
        int sum=0;
        int i=1;
        do {
            sum+=i;
            i++;
        }while (i<=10);
        System.out.println(sum);
    }

11. 用for语句输出1+2+……+10的和

    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <10 ; i++) {
            sum+=i;
        }
        System.out.println(sum);
    }

12.输出1-100之间不能被3整除的数

    public static void main(String[] args) {
        for (int i = 1; i <=100 ; i++) {
if (i%3!=0){
    System.out.print(i+" ");
}
        }
    }

13.定义数组，数组元素的值为67,89,87,69,90,100,75,90，用循环找出数组的最大数和最小数

    public static void main(String[] args) {
    int []array={67,89,87,69,90,100,75,90};
int max=array[0];//假设最大值和最小值都为array[0]
int min=array[0];
        for (int i = 1; i <array.length ; i++) {//遍历数组
            if (array[i]>max){//如果i下标的值大于max，就将i下标的赋给max
                max=array[i];
            }
            if (array[i]<min){
                min=array[i];//如果i下标的值小于min，就将i下标的赋给min
            }
        }
        System.out.println("最小值为："+min+"最大值为："+max);
    }

14.定义方法addInt()和addFloat(),第一个方法能求两个整数的和，第二个方法能求两个实数的和，写测试类，调用这两个方法

public class T1 {
    public static void main(String[] args) {
        System.out.println(addInt(10,20));
        System.out.println(addFloat(12.2f,12.6f));//注意float类型的数据需要再后面加f标识
    }
    public static int addInt(int x,int y){
        return x+y;
    }
    public static float addFloat(float x,float y){
        return x+y;
    }
}

15.用递归方法求5！

    public static void main(String[] args) {
        System.out.println(fac(5));
    }
    public static int fac(int x){
        if(x==1){
            return 1;
        }else {
            return x*fac(x-1);
        }
    }
}

16.定义Person类，Person类有name和age属性，有方法tell()输出Person实例的姓名和年龄，定义测试类，创建Person对象person他的名字叫Tom，年龄18，person调用tell()方法输出它的姓名和年龄

Person类：

public class Person {
    public String name;
    public int age;
        public void tell(){
        System.out.println("姓名："+name+",年龄："+age);
    }
}

测试类：

public class T1 {
      public static void main(String[] args) {
        Person person=new Person();
        person.name="Tom";
        person.age=18;
        person.tell();
    }
}

17. 定义Person类，Person类有name和age属性，

有方法tell()输出Person实例的姓名和年龄，

有构造方法实现对域的初始化

定义测试类，创建Person对象person他的名字叫Tom，年龄18，person调用tell()方法输出它的姓名和年龄

Person类：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void tell(){
        System.out.println("姓名："+name+",年龄："+age);
    }
}

测试类：

public class T1 {
    public static void main(String[] args) {
        Person person=new Person("Tom",18);
        person.tell();
    }
}

18. 定义父类Person和子类Student，父类有非私有的name和age,有两个构造方法，一个是无参的构造方法，一个是有参的构造方法，子类有自己的属性school,有无参的和有三个参数的构造方法

父类：

public class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

子类：

public class Student extends Person{
    private String school;

    public Student(String name, int age, String school) {
        super.name=name;
        super.age=age;
        this.school = school;
    }

    public Student(String school) {
        this.school = school;
    }
}

19. 定义父类Person和子类Student，父类有非私有的name和age,有两个构造方法，一个是无参的构造方法，一个是有参的构造方法，子类有自己的属性school,有无参的和有三个参数的构造方法,其中第二个构造方法在初始化时要调用父类的构造方法

父类：

public class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

子类：

public class Student extends Person{
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }

    public Student(String school) {
        this.school = school;
    }
}

20. 定义抽象父类Person，子类Student，父类有非私有的name和age,有两个构造方法，一个是无参的构造方法，一个是有参的构造方法，有一个抽象的方法String getInfo(),子类有自己的属性school,有无参的和有三个参数的构造方法,要求在子类中重写抽象方法，并输出子类的各项信息

父类：

public abstract class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    abstract String getInfo();
}

子类：

public class Student extends Person{
    private String school;

    public Student(String name, int age, String school) {
        super.name=name;
        super.age=age;
        this.school = school;
    }

    public Student() {
    }

    @Override
    String getInfo() {
        System.out.println("姓名："+name+", 年龄："+age+",学校："+school);
        return "姓名："+name+", 年龄："+age+",学校："+school;
    }
}

21.定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法和String 的getInfo()方法，类X是A的实现类，类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”

接口A:

public interface A {
    final String s = "Java的s";
    void print();
    String getInfo();
}

类X：

public class X implements A{
    @Override
    public void print() {
        System.out.println(s);
    }

    @Override
    public String getInfo() {
        return "Hello!!!";
    }
}

22. 定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法,定义一个接口B，B中有String 的getInfo()方法，类X是接口A和B的实现类，类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”

接口A：

public interface A {
    final String s = "Java的s";
    void print();
}

接口B：

public interface B {
    String getInfo();
}

类X：

public class X implements A,B{
    @Override
    public void print() {
        System.out.println(s);
    }

    @Override
    public String getInfo() {
        return "Hello!!!";
    }
}

23. 定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法,定义一个接口B，B是A的子接口，B接口有String 的getInfo()方法,类X是接口A和B的实现类，类X的print()方法输出常量s,方法getInfo()返回“Hello!!!”

接口A：

public interface A {
    final String s = "Java的s";
    void print();
}

接口B:

public interface B extends A{
    String getInfo();
}

类X：

public class X implements A,B{
    @Override
    public void print() {
        System.out.println(s);
    }
    @Override
    public String getInfo() {
        return "Hello!!!";
    }
}

24. 定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法,定义一个接口B，抽象类B有String 的抽象方法getInfo(),类X是接口A和类B的实现类，类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”

接口A：

public interface A {
    final String s = "Java的s";
    void print();
}

接口B：

public interface B {
    abstract String getInfo();
}

类X：

public class X implements A,B{
    @Override
    public void print() {
        System.out.println(s);
    }
    @Override
    public String getInfo() {
        return "Hello!!!";
    }
}

25. 定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法,定义一个接口B，抽象类B是类A实现类，且有String 的抽象方法getInfo(),类X是类B的实现类，类X的print()方法输出常量s,方法getInfo()返回“Hello!!!”

接口A：

public interface A {
    final String s = "Java的s";
    void print();
}

接口B：

public interface B extends A{
    abstract String getInfo();
}

类X：

public class X implements B{
    @Override
    public void print() {
        System.out.println(s);
    }
    @Override
    public String getInfo() {
        return "Hello!!!";
    }
}

26.定义一个接口A，有void 的printA()方法,定义一个接口B，有void 的printB()方法,接口C继承接口A和接口B，且有void 的printC()方法，类X是接口C的实现类。

接口A：

public interface A {
    void printA();
}

接口B：

public interface B extends A{
    void printB();
}

接口C：

public interface C extends A,B{
    void printC();
}

类X：

public class X implements C{
    @Override
    public void printA() {
    }

    @Override
    public void printB() {
    }

    @Override
    public void printC() {
    }

27. 定义一个接口A，有void 的printA()方法,定义一个接口B，有void 的printB()方法,类X是接口A和接口B的实现类。

接口A：

public interface A {
    void printA();
}

接口B：

public interface B{
    void printB();
}

类X：

public class X implements A,B{
    @Override
    public void printA() {
    }
    @Override
    public void printB() {
    }
}

28. 定义一个接口A，有void 的printA()方法,定义一个接口B，有void 的printB()方法,抽象类C有抽象方法void 的printC()方法，X类是接口A和抽象类C的实现类。

接口A：

public interface A {
    void printA();
}

接口B:

public interface B{
    void printB();
}

抽象类C：

public abstract class C {
    abstract void printC();
}

X类：

public class X extends C implements A{
    @Override
    public void printA() {
    }

    @Override
    void printC() {
    }
}

29．定义一个有5个整型数的数组，将数组元素倒序存放并输出

    public static void main(String[] args) {
int []array={1,2,3,4,5};
int l=0;//l为第一个元素下标
int r=array.length-1;//r为最后一个元素下标
while(l<=r){//交换l和r下标的元素，l往后移动，r往前移动
    int t=array[l];
    array[l]=array[r];
    array[r]=t;
    l++;
    r--;
}
        System.out.println(Arrays.toString(array));//打印数组元素
    }

30.求1-100间奇数的和

    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <=100 ; i++) {//遍历1~100
            if(i%2!=0){//如果i%2！=0，那么i就是奇数
                sum+=i;//将奇数i加到sum里面
            }
        }
        System.out.println(sum);
    }

31.使用do…while循环语句计算正数5的阶乘。

    public static void main(String[] args) {
        int x=1;
        int i=1;
        do {
            x*=i;
            i++;
        }while(i<=5);
        System.out.println(x);
    }

32.

某公司正进行招聘工作，被招聘人员需要填写个人信息，编写“个人简历”的封装类Resume，并编写测试类进行实现。类图及输出效果如下。

类名：Resume

name : String (private)

sex : String (private)

age : int (private)

Resume( ) // 没有参数的空构造方法

Resume(Srting name, String sex, int age)

// 得到各个属性值的方法getXxx( )

introduce( ) : void // 自我介绍（利用属性）

程序运行结果如下：

我是：李四,性别：男,年龄：20

public class Resume {
private String name;
private String sex;
private int age;

    public Resume() {
    }

    public Resume(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }
    public void introduce(){
        System.out.println("我是："+name+",性别："+sex+"年龄："+age);
    }
}

33. 某公司正进行招聘工作，被招聘人员需要填写个人信息，编写“个人简历”的封装类Resume，并编写测试类进行实现。类图及输出效果如下。

类名：Resume

name : String (private)

age : int (private)

Resume( ) // 没有参数的空构造方法

Resume(Srting name, int age)

// 得到各个属性值的方法getXxx( )

introduce( ) : void // 自我介绍（利用属性）

程序运行结果如下：

我是：李四,性别：男,年龄：20

public class Resume {
private String name;
private int age;

    public Resume() {
    }

    public Resume(String name,  int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }


    public int getAge() {
        return age;
    }
    public void introduce(){
        System.out.println("我是："+name+",性别：男+"年龄："+age);
    }
}

34. 已知函数

                      x + 3   ( x > 0 )

y= 0     ( x = 0 )

                      x2 –1 ( x < 0 )

请设计一个方法实现上面的函数，根据传入的值x的不同，返回对应的y值。

    public static int xxx(int x){
        if (x>0){
            return x+3;
        } else if (x==0) {
            return 0;
        }else {
            return 2*x-1;
        }
    }

35. 已知函数

                      x- 3   ( x > 0 )

               y =     5     ( x = 0 )

                      x   ( x < 0 )

请设计一个方法实现上面的函数，根据传入的值x的不同，返回对应的y值。

    public static int xxx(int x){
        if (x>0){
            return x-3;
        } else if (x==0) {
            return 5;
        }else {
            return x;
        }
    }

36.请按照以下要求设计一个学生类Student，并进行测试。

要求如下：

1）Student类中包含姓名、成绩两个属性

2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

3）Student类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和成绩属性赋值

4）在测试类中创建两个Student对象，一个使用无参的构造方法，然后调用方法给姓名和成绩赋值，一个使用有参的构造方法，在构造方法中给姓名和成绩赋值

Student类：

public class Student {
    private String name;
    private double grades;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getGrades() {
        return grades;
    }

    public void setGrades(double grades) {
        this.grades = grades;
    }

    public Student() {
    }

    public Student(String name, double grades) {
        this.name = name;
        this.grades = grades;
    }
}

测试类：

    public static void main(String[] args) {
        Student student1=new Student();
        student1.setName("李四");
        student1.setGrades(99);
        Student student2=new Student("张三",100);
    }

37.请按照以下要求设计一个学生类Student，并进行测试。

要求如下：

1）Student类中包含姓名、年龄两个属性

2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

3）Student类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和成绩属性赋值

4）在测试类中创建两个Student对象，一个使用无参的构造方法，然后调用方法给姓名和年龄赋值，一个使用有参的构造方法，在构造方法中给姓名和年龄赋值

和36题一样，只是把成绩换成了年龄

38.

请按照以下要求设计一个学生类Student，并进行测试。

要求如下：

1）Student类中包含姓名、学校两个属性

2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

3）Student类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和学校属性赋值

4）在测试类中创建两个Student对象，一个使用无参的构造方法，然后调用方法给姓名和学校赋值，一个使用有参的构造方法，在构造方法中给姓名和学校赋值

和36题一样，只是把成绩换成了学校

39.请按照以下要求设计一个学生类Student，并进行测试。

要求如下：

1）Student类中包含学号、姓名两个属性

2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

3）Student类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和学号属性赋值

4）在测试类中创建两个Student对象，一个使用无参的构造方法，然后调用方法给姓名和年龄赋值，一个使用有参的构造方法，在构造方法中给姓名和年龄赋值

和36题一样，只是把成绩换成了学号

40. 请按照以下要求设计一个学生类Student，并进行测试。

要求如下：

1）Student类中包含姓名、性别两个属性

2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

3）Student类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和性别属性赋值

4）在测试类中创建两个Student对象，一个使用无参的构造方法，然后调用方法给姓名和年龄赋值，一个使用有参的构造方法，在构造方法中给姓名和性别赋值

和36题一样，只是把成绩换成了性别

41.定义一个Father和Child类，并进行测试。

要求如下：

(1)Father类为外部类，类中定义一个私有的String类型的属性name，name的值为“Join”。

(2)Child类为Father类的内部类，其中定义一个readName()方法，方法中调用Father类的name属性。

(3)定义一个测试类Test，在Test类的main()方法中，创建Child对象，并调用readName ()方法。

成员内部类：

class Father{
private String name="Join";
class Child{
    public void readName(){
        System.out.println("我是"+name);
    }
}
}

测试类：

    public static void main(String[] args) {
        Father.Child child=new Father().new Child();
        child.readName();
    }

成员内部类创建格式：

外部类.内部类.对象名=外部类对象.内部类对象（）

Outer.Inner oi=new Outer().new Inner();

42.定义一个Father和Child类，并进行测试。

要求如下：

(1)Father类为外部类，类中定义一个私有的int类型的属性age，name的值为40。

(2)Child类为Father类的内部类，其中定义一个readAge()方法，方法中调用Father类的age属性。

3）定义一个测试类Test，在Test类的main()方法中，创建Child对象，并调用readAge()方法。

和41题类似

43.设计一个学生类Student和它的一个子类Undergraduate，要求如下：

Student类有name(姓名)、和age(年龄)属性，一个包含两个参数的构造方法，用于给name和age属性赋值，一个show()方法打印Student的属性信息

本科生类Undergraduate增加一个degree(学位)属性。有一个包含三个参数的构造方法，前两个参数用于给继承的name和age属性赋值，第三个参数给degree专业赋值，一个show()方法用于打印Undergraduate的属性信息

Student类：

public class Student {
    public String name;
    public int  age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("姓名："+name+",年龄："+age);
    }

}

Undergraduate类：

public class Undergraduate extends Student{
private String degree;

    public Undergraduate(String name, int age, String degree) {
        super(name, age);
        this.degree = degree;
    }

    @Override
    public void show() {
        System.out.println("姓名："+super.name+"年龄："+super.age+"学位："+degree);
    }
}

44. 设计一个学生类Student和它的一个子类Undergraduate，要求如下：

Student类有name(姓名)属性，一个包含一个参数的构造方法，用于给name属性赋值，一个show()方法打印Student的属性信息

本科生类Undergraduate增加一个degree(学位)属性。有一个包含二个参数的构造方法，一个参数用于给继承的name属性赋值，一个参数给degree专业赋值，一个show()方法用于打印Undergraduate的属性信息

定义一个测试类，创建一个Undergraduate对象，并输出该对象的属性信息。

和43题类似，只是少了一个年龄

45.请按照题目的要求编写程序并给出运行结果

编写一个程序，实现字符串大小写的转换并倒序输出，要求如下

1）使用for循环将字符串“HelloWorld”,利用字符串的toCharArray()方法将字符串转为字符数组，然后从最后一个字符开始遍历。

2）遍历的当前字符如果是大写字符，就使用toLowerCase()方法将其转换为小写字符，反之则使用toUpperCase() 方法将其转换为大写字符，并将转换后的字符存放在StrngBuffer字符串里。

    public static void main(String[] args) {
        String str="HelloWorld";
        StringBuffer stringBuffer=new StringBuffer();
        char []array=str.toCharArray();
        for (int i = array.length-1; i >=0 ; i--) {
            if(array[i]>='A'&&array[i]<='Z'){
                stringBuffer.append(Character.toLowerCase(array[i]));
            } else if (array[i]>='a'&&array[i]<='z') {
                stringBuffer.append(Character.toUpperCase(array[i]));
            }
        }
        System.out.println(stringBuffer);
    }

46.用for循环打印下面图形

    public static void main(String[] args) {
        for (int i = 1; i <10 ; i++) {
            for (int j = 1; j <=i ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

47.定义一个求矩形面积的方法，方法的参数分别为高和宽，写程序测试方法的正确性。

    public static void main(String[] args) {
        System.out.println(area(10,21));
    }
    public static double area(double x,double y){
        return x*y;
    }

48.定义一个求圆面积的方法，方法的参数为圆的半径，写程序测试方法的正确性。

    public static void main(String[] args) {
        System.out.println(area(10));
    }
    public static double area(double r){
        return Math.PI*r*r;
    }

49.定义一个10个元素的数据，初始化10个元素的值为0-9，用循环将每个元素后移，将“100”插入到数据的第1个元素位置。分别输出插入前和插入后数据组信息。

    public static void main(String[] args) {
        int []array=new int[11];
        for (int i = 0; i <10 ; i++) {
            array[i]=i+1;
        }
        System.out.println(Arrays.toString(array));
        for (int i = array.length-1; i >0 ; i--) {
            array[i]=array[i-1];
        }
        array[0]=100;
        System.out.println(Arrays.toString(array));
    }

50.定义animal类，属性有name、age、final的COLOR=”黑色”及name、age的get、set方法，定义它的子类Dog类，写一个测试类，创建dog对象，设置它的name值为边牧，年龄3岁，输出它的上面信息及COLOR值。

animal类：

public class animal {
    public String name;
    public int age;
    public final String COLOR="黑色";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Dog类：

public class Dog extends animal{
}

测试类：

    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("边牧");
        dog.setAge(3);
        System.out.println("姓名："+dog.name+"  年龄："+dog.getAge()+"  颜色："+ dog.COLOR);
    }

51. 定义animal类，属性有name、age属性及对应的get、set方法，定义它的子类Dog类，定义它的属性color及对应get、set方法,写一个测试类，创建dog对象，设置它的name值为边牧、年龄3岁，颜色为黑白，输出它的上面信息。

和50题类似，只是将final修饰的COLOR变来和name一样，仿造name的格式

52.定义Animal类，有void 的shout()方法，输出“动物发出叫声”。定义它的子类Cat类，重写父类的shout()方法，输出“喵喵喵”，测试类里创建Cat对象并调用shout()方法。

animal类：

public class Animal {
    public void shout(){
        System.out.println("动物发出叫声");
    }
}

Cat类：

public class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("喵喵喵");
    }
}

测试类:

   public static void main(String[] args) {
        Cat cat=new Cat();
        cat.shout();
    }

53. 定义Animal类，有void 的shout()方法，输出“动物发出叫声”。定义它的子类Dog类，重写父类的shout()方法，在方法内调用父类的shout()方法，并输出“汪汪汪”，测试类里创建Dog对象并调用shout()方法。

Animal类：

public class Animal {
    public void shout(){
        System.out.println("动物发出叫声");
    }

Dog类：

public class Dog extends Animal{
    @Override
    public void shout() {
        super.shout();
        System.out.println("汪汪汪");
    }
}

测试类：

   public static void main(String[] args) {
        Dog dog=new Dog();
        dog.shout();
    }

54. 定义Animal类，有name和age属性、构造方法和返回字符串的name和age方法info()。定义它的子类Dog类，子类有自己的color和构造方法和info()，测试类里创建Dog对象并调用它的info()方法，要求能输出dog对象的name、age和color。

Animal类：

public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String info(){
        return "姓名："+name+"  年龄："+age;
    }
}

Dog类：

public class Dog extends Animal {
    public String color;

    public Dog(String name, int age, String color) {
        super(name, age);
        this.color = color;
    }

    @Override
    public String info() {
        return "姓名："+name+"  年龄："+age+" 颜色："+color;
    }
}

测试类：

    public static void main(String[] args) {
        Dog dog=new Dog("边牧",2,"黑色");
        System.out.println(dog.info());
    }

55. 定义Animal类，有name和sex属性、构造方法和返回字符串的name和sex方法info()。定义它的子类Dog类，子类有自己的color和构造方法和info()，测试类里创建Dog对象并调用它的info()方法，要求能输出dog对象的name、sex和color。

和54题类似

56.定义Animal类，有void 的eat()方法，输出“动物都要进食”。定义它的子类Dog类，重写父类的eat()方法，在方法内调用父类的eat()方法，并输出“狗爱吃狗狼”，测试类里创建Dog对象并调用eat()方法。

和53题类似

57. 定义一个求圆的周长的方法，方法的参数为圆的半径，写程序测试方法的正确性。

    public static void main(String[] args) {
        System.out.println(circumference(2));
    }
    public static double circumference(double r){
        return Math.PI*2*r;
    }

58.定义一个求矩形周长的方法，方法的参数分别为高和宽，写程序测试方法的正确性。

   public static void main(String[] args) {
        System.out.println(circumference(2,2));
    }
    public static double circumference(double x,double y){
        return 2*(x+y);
    }

59.定义一个求正方形面积的方法，方法的参数为边长，写程序测试方法的正确性。

    public static void main(String[] args) {
        System.out.println(area(2));
    }
public static double area(double x){
        return x*x;
}

60.定义一个求正方形周长的方法，方法的参数为正方形的边长，写程序测试方法的正确性。

    public static void main(String[] args) {
        System.out.println(circumference(4));
    }
    public static double circumference(double x){
        return 4*x;
    }

61．使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串，将字符串类型数据转换为double类型数据，计算两个double数据的和。用户使用程序时可能会出现数据转换异常，如果出现异常，程序输出"输入数据类型错误！程序结束！“。请在main()方法中使用try...catch结构编写程序实现功能。

    public static void main(String[] args) {
        try {
            Scanner sc=new Scanner(System.in);
            String str1=sc.nextLine();
            String str2=sc.nextLine();
            double x=Double.valueOf(str1)+Double.valueOf(str2);
            System.out.println(x);
        } catch (NumberFormatException e) {
            System.out.println("输入数据类型错误！程序结束！");
        }
    }

62．使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串，将字符串类型数据转换为double类型数据，计算两个double数据的和。用户使用程序时可能会出现数据转换异常，如果出现异常，程序输出"输入数据类型错误！程序结束！“。请设计与main()方法在同一类中的public static double jisuan (String str1,String str2)方法，并使用method signature方式处理异常请在main()方法中使用try...catch结构编写程序实现功能。

    public static void main(String[] args) {
        try {
            Scanner sc=new Scanner(System.in);
            String str1= sc.nextLine();
            String str2=sc.nextLine();
            double x=jisuan(str1,str2);
        } catch (NumberFormatException e) {
            System.out.println("输入数据类型错误！程序结束！");
        }
    }

    public static double jisuan(String str1,String str2)throws NumberFormatException {
        double x = Double.valueOf(str1);
        double y = Double.valueOf(str2);
    return x+y;
    }
}

63.使用键盘录入两个int类型数据，并计算二者的商。不考虑输入错误，用户使用程序时可能会出现异常，如果出现异常，程序输出“除数为零，错误！程序结束！”。请在main()方法中使用try...catch结构编写程序实现功能。

  public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try {
            int x= sc.nextInt();
            int y= sc.nextInt();
            System.out.println(x/y);
        } catch (Exception e) {
            System.out.println("除数为零，错误！程序结束！");
        }
    }

64.使用键盘录入两个int类型数据，并计算二者的商。不考虑输入错误，用户使用程序时可能会出现异常，如果出现异常，程序输出“除数为零，错误！程序结束！”。请设计与main()方法在同一类中的public static int divide(int x,int y)方法，并使用method signature方式处理异常。请在main()方法中使用try...catch结构编写程序实现功能。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try {
            int x= sc.nextInt();
            int y=sc.nextInt();
            System.out.println(divide(x,y));
        } catch (ArithmeticException e) {
            System.out.println("除数为零，错误！程序结束！");
        }
    }

    public static int divide(int x,int y)throws ArithmeticException{
        return x/y;
    }

65.使用键盘录入两个int类型数据，并计算二者的商。不考虑输入错误，用户使用程序时可能会出现异常，如果出现异常，程序输出“除数为零，错误！程序结束！”。请设计与main()方法在同一类中的public static int divide(int x,int y)方法，并在其中使用try...catch结构方式处理异常。

    public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
        try {
            int x= sc.nextInt();
            int y= sc.nextInt();
            System.out.println(divide(x, y));
        } catch (Exception e) {
            System.out.println("除数为零，错误！程序结束！");
        }
    }

public static int divide(int x,int y){
        return x/y;
}

66.编制程序输出1到10的自然数，发现当前自然数是5的倍数时，在输出当前数的同时抛出异常。异常对象中含有信息："现在的数是5的倍数"。

程序运行结果：

1 2 3 4 5 现在的数是5的倍数

6 7 8 9 10 现在的数是5的倍数

  public static void main(String[] args) {
        for (int i = 1; i <=10 ; i++) {
            try {
                System.out.print(i+" ");
                if (i%5==0){
                    throw new RuntimeException("现在的数是5的倍数");
                }
            } catch (RuntimeException e) {
                System.out.println(e.getMessage());
            }
        }
    }

67.使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串，将字符串类型数据转换为double类型数据，计算两个double数据的和。用户使用程序时可能会出现数据转换异常，如果出现异常，程序输出“输入数据类型错误！程序结束！”。用户使用程序时，无论是否出现异常，程序都会输出信息“欢迎下次使用！”。请在main()方法中使用try...catch结构编写程序实现功能。

    public static void main(String[] args) {
        try {
            Scanner sc=new Scanner(System.in);
            String str1=sc.nextLine();
            String str2=sc.nextLine();
            System.out.println(Double.valueOf(str1)+Double.valueOf(str2));
        } catch (NumberFormatException e) {
            System.out.println("输入数据类型错误！程序结束！");
        }finally {
            System.out.println("欢迎下次使用！");
        }
    }

68.检测从键盘获取的字符串中是否含有数字符号。如果发现有数字符号在字符串中出现，则抛出异常，异常对象中含有信息：“发现目标！”。程序输出："发现目标！"。程序结束。请编制程序，完成需求的功能。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        try {
            for (char c:str.toCharArray()) {
                if (Character.isDigit(c)){
                    throw new RuntimeException("发现目标");
                }
            }
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
    }

69.从键盘获取字符串str及将要在str中进行统计的指定字符串，输出指定字符串在str中出现的次数。例如：“uabcshyduabchdjabcsk”中含有“abc”的次数是3。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();//输入字符串
        String ch=sc.nextLine();//输入要查找的字符串
int count=0;//记录目标字符串的参数
int index=str.indexOf(ch);//找到第一次出现的位置
while (index!=-1){//如果没有则返回-1
    count++;
    index=str.indexOf(ch,index+ch.length());//当前目标字符串位置+目标字符串长度处开始寻找
}
        System.out.println(count);
    }

70.从键盘获取字符串str及将要在str中进行统计的指定字符，输出指定字符在str中出现的次数。例如：“uabcshyduabchdjabcsk”中含有‘a’的次数是3。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        char ch=sc.nextLine().charAt(0);
        int count=0;
        for (int i = 0; i <str.length() ; i++) {
            if (str.charAt(i)==ch){
                count++;
            }
        }
        System.out.println(count);
    }

71. System.currentTimeMillis()能够获取:“the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.”在不考虑时区的情况下请使用它获取当前的系统时间。

  public static void main(String[] args) {
        long curr=System.currentTimeMillis();
        System.out.println("当前时间："+curr);
    }

72.生成10个 [13,56]的自然数，并在一行输出，数据采用空格进行分隔，最后一个数据后面无空格。

    public static void main(String[] args) {
        Random random=new Random();
        for (int i = 0; i <10 ; i++) {
            int ra= random.nextInt(13,56);
            if (i==9){
                System.out.println(ra);
            }else {
                System.out.print(ra+" ");
            }
        }
    }

73.生成10个[a,b]之间的自然数，并在一行输出，数据采用空格进行分隔，最后一个数据后面无空格。 a 和 b 从键盘获取。

    public static void main(String[] args) {
        Random random=new Random();
        Scanner sc=new Scanner(System.in);
        int a= sc.nextInt();
        int b= sc.nextInt();
        for (int i = 0; i <10 ; i++) {
            int ra= random.nextInt(a,b);
            if (i==9){
                System.out.println(ra);
            }else {
                System.out.print(ra+" ");
            }
        }
    }

74.任意角a，请编程计算：sin3a=4sinasin(π/3+a)sin(π/3-a)。请从键盘获取a，输入为角度。例如输入30 则计算sin3a的值为 1。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int  a= sc.nextInt();
        System.out.println(4*Math.sin(Math.PI/3+a)*Math.sin(Math.PI/3-a));
    }

75.Calendar类用于完成日期和时间段的操作，请使用它获取系统当前时间。输出的格式为：xxxx年xx月xx日空格xx:xx:xx。例如：2023年7月5日 6:26:52

    public static void main(String[] args) {
        Calendar ca=Calendar.getInstance();
        System.out.println(ca.get(Calendar.YEAR)+"年"+(ca.get(Calendar.MONTH)+1)
                +"月"+ ca.get(Calendar.DAY_OF_MONTH)+"日 "+ ca.get(Calendar.HOUR_OF_DAY)+":"
                + ca.get(Calendar.MINUTE)+":"+ ca.get(Calendar.SECOND));
    }

76.从键盘获得一个字符串，将其中我们不喜欢的字符串去除，形成一个新的字符串输出。

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str1= scanner.nextLine();
        String str2=scanner.nextLine();
        String []strings=str1.split(str2);
        StringBuilder sbr=new StringBuilder();
        for (int i = 0; i <strings.length ; i++) {
            sbr.append(strings[i]);
        }
        System.out.println(sbr);
    }

77.机器人A和机器人B，它们有共同点，就是都有名字，不同的是A会唱歌，B会走路。 A在唱歌的方法中输出“我想唱歌”；B在走路的方法中输出“脚踏实地！”。请使用接口技术实现它们,并测试。

    public interface IK {
        void per();
    }
    public class A implements IK{
        @Override
        public void per() {
            System.out.println("我想唱歌");
        }
    }

    public class B implements IK{
        @Override
        public void per() {
            System.out.println("脚踏实地");
        }
    }
    
    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        a.per();
        b.per();
    }

78.机器人A和机器人B，它们有共同点，就是都有名字，不同的是A会唱歌，B会走路。A在唱歌的方法中输出“我想唱歌”；B在走路的方法中输出“脚踏实地！”。请使用继承技术实现它们,并测试。

和上一题类似

79.类A中已有showA()方法，其功能是输出"我是A中的方法！"。在不改变类A结构的前提下，想要扩充一个输出”我是扩充的功能！“的expend()方法。请使用接口技术实现并测试。

class A implements Ikuo{
    public static void main(String[] args) {

    }
    public static void showA(){
        System.out.println("我是类A中的showA方法");
    }

    @Override
    public void expend() {

    }
}

public interface Ikuo {
    void expend();
}

80.类W中已有showA()方法，其功能是输出"我是A中的方法！"。在不改变类A结构的前提下，想要扩充一个输出”我是扩充的功能！“的expend()方法。请使用继承技术实现并测试

和上题类似

81.输入一个整数，判断是不是素数。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x= sc.nextInt();
        if (x%2!=0){
            System.out.println(x+"是素数");
        }else {
            System.out.println(x+"是偶数");
        }
    }

82.打印1~100之间的素数

    public static void main(String[] args) {
        for (int i = 1; i <=100 ; i++) {
            if (i%2!=0){
                System.out.print(i+" ");
            }
        }
    }

83.输入一个年份，判断其是不是闰年

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int year= sc.nextInt();
        if ((year%4==0&&year%100!=0)||year%400==0){
            System.out.println(year+"是闰年");
        }else {
            System.out.println(year+"不是闰年");
        }
    }

84.统计1~1000之间出现了几次数字8

    public static void main(String[] args) {
        int count=0;
        for (int i = 1; i <=1000 ; i++) {
            int x=i;
            while(x!=0){
                if (x%10==8){
                    count++;
                }
                x/=10;
            }
        }
        System.out.println(count);
    }

85.输入一个位置编号，将数组{10,11,13,14,15}该位置的数据元素删除，输出删除该数据元素后的数组。

    public static void main(String[] args) {
        int []array={10,11,13,14,15};
        int size=array.length;
        Scanner sc=new Scanner(System.in);
        int pos= sc.nextInt();
        for (int i = pos; i <array.length-1 ; i++) {
            array[i]=array[i+1];
            size--;
        }
        for (int i = 0; i <=size ; i++) {
            System.out.print(array[i]+" ");
        }
    }

86.求纳税款和实得工资数不同工资s的税率p如下：

         s < 1000           p = 0 %

         1000 <= s < 2000    p = 5 %

         2000 <= s < 3000    p = 8 %

         3000 <= s < 5000    p = 10 %

         5000 <= s          p = 15 %

要求：采用switch选择结构实现。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        double s= sc.nextDouble();
        double s1=0;
        double s2=0;
        switch ((int) (s/1000)){
            case 0:s1=s;s2=0;
            break;
            case 1:s2=s*0.05;s1=s-s2;
            break;
            case 2:s2=s*0.08;s1=s-s2;
            break;
            case 3,4:s2=s*0.1;s1=s-s2;
            break;
            default:s2=s*0.15;s1=s-s2;
            break;
        }
        System.out.println("实际工资:"+s1+"  纳税款："+s2);
    }

87.定义一个图书类，属性编号、书名、作者、单价。其功能包括获取图书信息，通过构造方法进行初始化。编写测试类进行实现。类图及输出效果如下：

类名：Book

bookNumber : String (private)

bookName: String (private)

author:String (private)

price : double (private)

Book(String bookNumber, String bookName, String author, double price)

setXxx( )：void// 设置各个属性值的方法

getXxx( )：返回值类型与对应属性类型相同// 得到各个属性值的方法

toString()：String //方法重写，将图书全部属性信息组成字符串，返回该字符串。

程序运行结果如下：

Book{bookNumber='b001', bookName='Java程序设计基础', author='韩梅', price=54.2}

Book类：

public class Book {
    private String bookNumber;
    private String bookName;
    private String author;
    private double price;

    public Book(String bookNumber, String bookName, String author, double price) {
        this.bookNumber = bookNumber;
        this.bookName = bookName;
        this.author = author;
        this.price = price;
    }

    public String getBookNumber() {
        return bookNumber;
    }

    public void setBookNumber(String bookNumber) {
        this.bookNumber = bookNumber;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookNumber='" + bookNumber + '\'' +
                ", bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

测试：

    public static void main(String[] args) {
        Book book=new Book("b001","Java程序设计基础", "韩梅", 54.2);
        System.out.println(book.toString());
    }

88.定义一个圆形类，属性包括圆心点坐标，其功能计算圆心与（0,0）点间距离，通过构造方法进行初始化。编写测试类，实现从键盘输入圆心坐标，输出圆心与（0,0）点距离。类图及输出效果如下：

类名：Circle

centerX: double (private)

centerY: double (private)

Circle(double centerX，double centerY)

Distance():double//计算圆心与（0.0）点间距离。

程序运行结果如下：

请输入圆心的X轴坐标:3

请输入圆心的Y轴坐标:-1

该圆圆心到（0,0）点的距离为:3.1622776601683795

Circle类：

public class Circle {
    private double centerX;
    private double centerY;

    public Circle(double centerX, double centerY) {
        this.centerX = centerX;
        this.centerY = centerY;
    }
   double Distance(){
        return Math.sqrt(centerX*centerX+centerY*centerY);
   }
}

测试类：

    public static void main(String[] args) {
        Circle circle=new Circle(3,3);
        System.out.println(circle.Distance());
    }

89.一个景区根据游客的不同年龄段来进行收费，编写一个游客类，能够根据游客年龄设置游客票价。价格标准为：0<age<12，票价20元；12<=age<20，票价40元；20<=age<50，票价80元；50<=age，票价35元。编写测试类，进行测试：通过无参构造方法，构造游客1，通过键盘输入游客年龄及设置票价；通过有参构造方法构造游客2，通过参数初始化年龄并设置票价，输出游客1及2的票价。类图及输出效果如下：

类名：Tourist

age：int (private)

price: int (private)

Tourist()//从键盘输入年龄，设置年龄及票价

Tourist(int age)//由形参设置年龄，设置票价

setPrice()：void// 实现根据年龄设置票价属性值

getPrice()：int// 返回票价值

程序运行结果如下：

--获取游客1的票价--

请输入年龄：12

游客1的票价：40

--获取游客2的票价--

请输入年龄：67

游客1的票价：35

测试类：

    public static void main(String[] args) {
        Tourist tourist=new Tourist(13);
        tourist.setPrice();
        System.out.println(tourist.getPrice());
    }

Tourist类：

public class Tourist {
    private int age;
    private int price;

    public Tourist() {
    }

    public Tourist(int age) {
        this.age = age;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice() {
        if (age>0&&age<12){
            price=20;
        }else if (age>=12&&age<20){
            price=40;
        } else if (age>=20&&age<50) {
            price=80;
        }else {
            price=35;
        }
    }
}

90.编写一个类Equation，该类封装了一元二次方程的属性及功能，即该类刻画方程系数的3个成员变量以及计算实根的方法，要求该类所有对象共享常数项。一元二次方程公式如下所示：：ax2+bx+c=0，其中a≠0。编写测试类，分别创建两个方程对象，进行测试求解两个方程的实根。

程序运行结果如下：

请输入该方程1的系数a、b:

1 2

请输入该方程2的系数a、b:

1 1

请输入该共享常数项c:

1

方程1的求实根结果是:-1.0,-1.0

方程2的求实根结果是:该方程没有实数根！

Equation类：

public class Equation {
private int a;
private int b;
public static int c;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }
public void jisuan(int i){
        int t=b*b-4*a*c;
        if (t>0){
            System.out.println("方程"+i+"的求实根结果是:"+((-b+Math.sqrt(t))/2*a)+"   "+(-b-Math.sqrt(t))/2*a);
        }else if (t==0){
            System.out.println("方程"+i+"的求实根结果是:"+((-b+Math.sqrt(t))/2*a));
        }else {
            System.out.println("方程"+i+"的求实根结果是:该方程没有实数根！");
        }
}
}

测试类：

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

            System.out.println("请输入该方程1的系数a、b:");
          Equation e1=new Equation();
          e1.setA(sc.nextInt());
          e1.setB(sc.nextInt());

          Equation e2=new Equation();
        System.out.println("请输入该方程2的系数a、b:");
        e1.setA(sc.nextInt());
        e1.setB(sc.nextInt());
        System.out.println("请输入该共享常数项c:");
        Equation.c= sc.nextInt();
        e1.jisuan(1);
        e2.jisuan(2);
    }

91.编写两个类：A和B，A创建的对象可以计算两个正整数的最大公约数，B创建的对象可以计算两个数的最小公倍数。已知最小公倍数=两个数乘积/两个数的最大公约数，因此要求B类中有一个成员变量是用A类声明对象。编写测试类，分别创建A和B对象，求解最大公约数和最小公倍数。

程序运行结果如下：

请输入两个正整数:24 16

最大公约数是:8

最小公倍数是:48

A：

public class A {
    public int jisuan(int a,int b){
        int t=a%b;
        if (t==0){
            return b;
        }
        while (t!=0){
            a=b;
            b=t;
            t=a%b;
        }
        return a;
    }
}

B：

public class B {
public int jisuan(int x,int y){
    return x*y/new A().jisuan(x,y);
}
}

测试：

    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入两个正整数:");
        int x= sc.nextInt();
        int y= sc.nextInt();
        System.out.println("最大公约数是:"+a.jisuan(x,y));
        System.out.println("最小公倍数是:"+b.jisuan(x,y));
    }

92.在服装销售过程中，需要对数量进行统计。定义服装类Clothes，其属性包括服装名称及服装销售数量，服装销售量为类共享数据项。该类功能包括构造服装对象及获取当前服装销售数量，每构造一次服装对象相当于销售一件服装。编写测试类，分别创建两件衣服对象，输出销售数量。

程序运行结果如下：

请输入两件销售服装的名称:李宁

anta

李宁销售后服装销售数量为：1

anta销售后服装销售数量为：2

类Clothes：

public class Clothes {
    private String name;
    public static int count=0;
    public Clothes(String name) {
        this.name=name;
        count++;
    }
public void show(){
    System.out.println(name+"销售后服装销售数量为"+count);
}
}

测试类：

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入两件销售服装的名称:");
        String name1=sc.nextLine();
        String name2=sc.nextLine();
        Clothes clothes=new Clothes(name1);
        clothes.show();
        Clothes clothes1=new Clothes(name2);
        clothes1.show();
    }

93.类Area为面积计算类，可以计算长方形、圆形及梯形面积。要求：

用方法重载的方式定义类Area中三个求解面积方法，每个方法用于求解一种图形面积。

编写测试类，创建一个Area对象，用其计算长方形、圆形及梯形面积，输出计算结果。

程序运行结果如下：

请输入长方形的长和宽：2 3

该长方形的面积是：6.0

请输入圆形的半径：2

该圆形的面积是：12.566370614359172

请输入梯形的上底、下底和高：1 2 2

该梯形的面积是：3.0

Area类：

public class Area {
    public void area(double x,double y){
        System.out.println("该长方形的面积是："+x*y);
    }
public void area(double r){
    System.out.println("该圆形的面积是："+Math.PI*r*r);
}
public void area(double x,double y,double z){
    System.out.println("该梯形的面积是："+(x+y)*z/2);
}
}

测试类：

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Area area=new Area();
        System.out.println("请输入长方形的长和宽：");
        area.area(sc.nextDouble(), sc.nextDouble());
        System.out.println("请输入圆形的半径：");
        area.area(sc.nextDouble());
        System.out.println("请输入梯形的上底、下底和高：");
        area.area(sc.nextDouble(), sc.nextDouble(), sc.nextDouble());
    }

94.圆柱体类Cylinder，属性包括底和高，底为圆形Circle类的对象，其功能包括计算圆柱体体积，构造时初始化属性值。圆形Circle类，属性包括半径，其功能包括计算圆形面积。要求：

定义圆柱体类Cylinder计算圆柱体体积时，需要调用圆形的求面积方法求解其底的面积。

编写测试类，创建一个Cylinder对象，计算其体积，输出计算结果

程序运行结果如下：

请输入圆柱体底的半径及圆柱体高：2 4

该圆柱体的体积:50.26548245743669

和上面几题类似

95.设计一个抽象类Car，它有两个子类BYD和HongQi，要求如下：

Car类有抽象方法getInfo()，用来返回车辆信息，信息类型为字符串型。

类BYD实现getInfo()方法，返回信息“BYD”。类HongQi实现getInfo()方法，返回信息“HongQi”。

编写测试类，分别创建一个BYD和HongQi对象，调用它们的getInfo()方法获取车辆信息并输出。

程序运行结果如下：

车辆信息分别为：BYD,HongQi

Car类：

public abstract class Car {
    abstract String getInfo();
}

HongQi类;

public class HongQi extends Car{
    @Override
    String getInfo() {
        return "HongQi";
    }
}

BYD类：

public class BYD extends Car{
    @Override
    String getInfo() {
        return "BYD";
    }
}

测试类：

    public static void main(String[] args) {
        HongQi hongQi=new HongQi();
        BYD byd=new BYD();
        System.out.println("车辆信息分别为：");
        System.out.println(hongQi.getInfo());
        System.out.println(byd.getInfo());
    }

96.用循环语句输出以下图形。

   public static void main(String[] args) {
        for (int i = 0; i <4 ; i++) {
            for (int j = 0; j <=i ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

97. 求1-100之间的偶数和

public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <=100 ; i++) {
            if (i%2==0){
               sum+=i;
            }
        }
        System.out.println(sum);
    }

98.定义一个圆类，圆类的属性有半径，圆类有求周长和面积的方法及构造方法，写一个测试类，能求半径为3.0的圆的周长和面积。

public class Round {
    private double r;

    public Round(double r) {
        this.r = r;
    }
    public void C(){
        System.out.println("圆的周长为："+Math.PI*2*r);
    }
    public void S(){
        System.out.println("圆的面积为："+Math.PI*r*r);
    }
}

99. 定义一个矩形类，矩形类的属性有长和宽，类内有求矩形周长和面积的方法及相应的构造方法，写一个测试类，能求边长为3.0，4.0矩形的周长和面积。

100. 定义一个正方形类，类的属性有边长，类内有求正方形周长和面积的方法及相应的构造方法，写一个测试类，能求边长为为3.0的正方形周长和面积。

99和100题和98题类似

鱼骨不是鱼翅

关注

13
点赞
踩
16

收藏

觉得还不错? 一键收藏
1
评论
大一期末——写程序100道

23. 定义一个接口A，有一个String的常量值为Java的 s，有void 的print()方法,定义一个接口B，B是A的子接口，B接口有String 的getInfo()方法,类X是接口A和B的实现类，类X的print()方法输出常量s,方法getInfo()返回“Hello!定义它的子类Dog类，子类有自己的color和构造方法和info()，测试类里创建Dog对象并调用它的info()方法，要求能输出dog对象的name、age和color。编写测试类，分别创建两件衣服对象，输出销售数量。
复制链接

扫一扫