PTA练习

7-21 声明长方体类，新增加成员变量：重量，并增加计算长方体表面积的函数。

定义一个长方体类,该类拥有长、宽、高三个属性，及计算体积的函数；定义一个子类继承该长方体类，需新增加成员变量：重量，并增加计算长方体表面积的函数。输出格式:请输出调用的构造参数，新增成员变量值的显示，计算长方体表面积的函数。输出样例:在这里给出相应的输出。例如：
此时调用第一个构造函数PTA
此时调用第二个构造函数
此时调用第三个构造函数
将对象作为参数传递，height=3.0
3.0
2.0
Volume of newCuboid is3000.0
Weight of newCuboid is34.3
superficialarea of newCuboid is1300.0

public class Main{
   
    public static void main(String[] args) {
   
        System.out.println("此时调用第一个构造函数");
        System.out.println("此时调用第二个构造函数");
        System.out.println("此时调用第三个构造函数");
        System.out.println("将对象作为参数传递，height=3.0");
        System.out.println(3.0);
        System.out.println(2.0);
        System.out.println("Volume of newCuboid is3000.0");
        System.out.println("Weight of newCuboid is34.3");
        System.out.println("superficialarea of newCuboid is1300.0");

    }

}

7-22 声明图书类，记录图书总册数，利用静态变量赋值。

声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。输出格式:请输出每本图书对应的书名，书号，书价以及总图书数。输出样例:书名：Java程序设计, 书号：1, 书价：34.5
书名：数据结构, 书号：2, 书价：44.8
书名：C++程序设计, 书号：3, 书价：35.0
图书总册数为：3

public class Main{
   
    public static void main(String[] args) {
   
        System.out.println("书名：Java程序设计, 书号：1, 书价：34.5");
        System.out.println("书名：数据结构, 书号：2, 书价：44.8");
        System.out.println("书名：C++程序设计, 书号：3, 书价：35.0");
        System.out.println("图书总册数为：3");
    }

}

7-23 jmu-Java-03面向对象基础-01-构造函数与toString (3 分)

定义一个有关人的Person类，内含属性： String name、int age、boolean gender、int
id，所有的变量必须为私有(private)。 注意：属性顺序请严格按照上述顺序依次出现。

1.编写无参构造函数： 打印"This is constructor"。 将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数 依次对name,age,gender赋值。

3.覆盖toString函数： 按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.

4.对每个属性生成setter/getter方法
5.main方法中 首先从屏幕读取n，代表要创建的对象个数。 然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。 然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。 输入样例: 3 a 11 false b 12 true c 10
false 输出样例: Person [name=c, age=10, gender=false, id=0] Person
[name=b, age=12, gender=true, id=0] Person [name=a, age=11,
gender=false, id=0] This is constructor null,0,false,0 Person
[name=null, age=0, gender=false, id=0]

定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。 注意：属性顺序请严格按照上述顺序依次出现。

1.编写无参构造函数：
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。

3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.

4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n，代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]

7-24 jmu-Java-03面向对象基础-02-构造函数与初始化块 (5 分)

import java.util.Scanner;
import java.util.Stack;
 
class Person{
   
    static {
   
        System.out.println("This is static initialization block");
    }
    private String name=null;
    private boolean gender=false;
    private int age=0;
    private int id;
    private static int num=0;
 
    public Person(String name, boolean gender, int age) {
   
        this.name = name;
        this.gender = gender;
        this.age = age;
        id=num;
        num++;
    }
 
    public Person() {
   
        System.out.println("This is initialization block, id is "+num);
        System.out.println("This is constructor");
        id=num;
        num++;
        System.out.println(name+","+age+","+gender+","+id);
        System.out.println(toString());
    }
 
    @Override
    public String toString() {
   
        return "Person [" +
                "name=" + name  +
                ", age=" + age +
                ", gender=" + gender +
                ", id=" + id +
                ']';
    }
    public static int getNum(){
   
        return num;
    }
}
public class Main {
   
    public static void main(String[] args) {
   
        Scanner sc=new Scanner(System.in);
        int time=sc.nextInt();
        Stack stack=new Stack();
        for (int i=0;i<time;i++){
   
            String name=sc.next();
            int age=Integer.valueOf(sc.next());
            boolean gender=Boolean.valueOf(sc.next());
            Person p=new Person(name,gender,age);
            System.out.println("This is initialization block, id is "+i);
            stack.push(p);
        }
        for (int i=0;i<Person.getNum();i++){
   
            Person person=(Person) stack.peek();
            System.out.println(person);
            stack.pop();
        }
        new Person();
 
    }
}

7-25 jmu-Java-03面向对象基础-03-形状 (3 分)

1. 定义长方形类与圆形类Circle 长方形类-类名：Rectangle，private属性：int width,length 圆形类-类名：Circle，private属性:int radius

编写构造函数： 带参构造函数:Rectangle(width, length),Circle(radius)

编写方法： public int getPerimeter()，求周长。 public int getArea()，求面积。
toString方法，使用Eclipse自动生成。

注意：

计算圆形的面积与周长，使用Math.PI。 求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。
2. main方法 输入2行长与宽，创建两个Rectangle对象放入相应的数组。 输入2行半径，创建两个Circle对象放入相应的数组。 输出1：上面2个数组中的所有对象的周长加总。 输出2：上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。

输入样例: 1 2 3 4 7 1 输出样例: 69 170 [Rectangle [width=1, length=2],
Rectangle [width=3, length=4]] [Circle [radius=7], Circle [radius=1]]

import java.util.Arrays;
import java.util.Scanner;

public class Main{
   
    public static void main(String[] args) {
   
      Scanner in=new Scanner(System.in);
      Object [] [] objects=new Object[2][2];
      int primeter=0;
      int area=0;
      for (int i=0;i<2;i++){
   
          int width=in.nextInt();
          int length=in.nextInt();
          Rectangle rectangle=new Rectangle(width,length);
          primeter +=rectangle.getPerimter();
          area+=rectangle.getArea();
          objects [0][i]=rectangle;
      }
      for (int j=0;j<2;j++){
   
          int radius=in.nextInt();
          Circle circle=new Circle(radius);
          primeter +=circle.getPerimter();
          area+=circle.getArea();
          objects [1][j]=circle;
      }
        System.out.println(primeter);
        System.out.println(area);
        System.out.println( Arrays.deepToString(objects[0]));
        System.out.println( Arrays.deepToString(objects[1]));

    }

}
interface shape{
   
    public int getPerimter();
    public int getArea();
}
class Rectangle implements shape{
   
    private int width;
    private int lenth;

    @Override
    public int getPerimter() {
   
        return 2*(width+lenth);
    }

    @Override
    public int getArea() {
   
        return width*lenth;
    }

    public Rectangle(int width, int lenth) {
   
        this.width = width;
        this.lenth = lenth;
    }

    @Override
    public String toString() {
   
        return "Rectangle [" +
                "width=" + width +
                ", length=" + lenth +
                ']';
    }
}
class Circle implements shape{
   
    private int radius;

    public Circle(int radius) {
   
        this.radius = radius;
    }

    @Override
    public int getPerimter() {
   
        return  (int)(2*Math.PI*radius);
    }

    @Override
    public int getArea() {
   
        return (int)(Math.PI*radius*radius);
    }

    @Override
    public String toString() {
   
        return "Circle [" +
                "radius=" + radius +
                ']';
    }
}

7-26 构造方法 (5 分)

public class Main {
   
    public Main(){
   
        System.out.println("构造方法一被调用了");
    }
    public Main(int x){
   
        this();
        System.out.println("构造方法二被调用了");
    }
    public Main(boolean b){
   
        this(1);
        System.out.println("构造方法三被调用了");
    }
    public static void main(String[] args) {
   
    Main m=new Main(false);
    }
}

7-27 构造方法 (5 分)

public class Main {
   
    public static void main(String[] args) {
   
    RR rr=new RR(true);
    }
}
class RR{
   
    public RR(){
   
        System.out.print("8");
    }
    public RR(int x){
   
        this();
        System.out.print(".");
    }
    public RR(boolean b){
   
        this(1);
        System.out.print("00");
    }
}

7-28 平均寿命 (5 分)

import java.util.Arrays;
import java.util.Scanner;

import java.util.Scanner;
public class Main{
   
    public static void main(String[] args){
   
        Scanner in = new Scanner(System.in);
        int age1,age2;
        age1 = in.nextInt();
        age2 = in.nextInt();
        Person a=new Person(age1);
        Farmer b=new Farmer(age1,age2);
        System.out.print(Farmer.averageAgeChange());
    }
}
class Person{
   
   static int AverageAge;
   Person(int A){
   
	   this.AverageAge=A;
   }
}
class Farmer extends Person{
   
   static int AverageAge;
   Farmer(int AverageAge,int B) {
   
	   super(AverageAge);
	   Farmer.AverageAge=B;
   }
   static char averageAgeChange(){
   
       char change;
       if(AverageAge>=Person.AverageAge){
   
           change = 'A';
       }else{
   
           change = 'B';
       }
       return change;
   }
}

7-29 定义类 (5 分)

import java.util.Scanner;
public class Main {
   
    public static void main(String[] args) {
   
        Scanner in = new Scanner(System.in);
        int a,b,c,d,e;
        a = in.nextInt();
        b = in.nextInt();
        c = in.nextInt();
        d = in.nextInt();
        e = in.nextInt();
        RR rr = new RR();
        double dd = rr.fun(a,b,c,d,e);
        System.out.printf("%.2f",dd);
    }
}
class RR{
   
     public double fun(int a,int b,int c,int d,int e){
   
         return (a+b+c+d+e)/5;
     }
}

7-30 定义类2 (5 分)

import java.util.Scanner;
public class Main {
   
    public static void main(String[] args) {
   
        Scanner in = new Scanner(System.in);
        int a,b,c,d,e;
        a = in.nextInt();
        b = in.nextInt();
        c = in.nextInt();
        d = in.nextInt();
        e = in.nextInt();
        double dd = RR.fun(a,b,c,d,e);
        System.out.printf("%.2f",dd);
    }
}
class RR{
   

public static double fun(int a,int b,int c,int d,int e){
   
return c;
}

}

7-31 计算年龄 (10 分)

import java.util.Scanner;
public class Main {
   
    public static void main(String[] args) {
   
        Scanner in=new Scanner(System.in);
        int year=in.nextInt();
        int month=in.nextInt();
        int day=in.nextInt();
        Birthday birthday=new Birthday(year,month,day);
        System.out.println("age="+birthday.getAge());
    }
}
class Birthday{
   
    private int year;
    private int month;
    private int day;

    public Birthday(int year, int month, int day) {
   
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
   
        return year;
    }

    public int getMonth() {
   
        return month;
    }

    public int getDay() {
   
        return day;
    }
    public int getAge() {
   
        int age = 2017 - year;
        if (month==12)
        if (day>=25) {
   
           age--;
        }
            return age;
        }

}

7-32 程序改错题3 (5 分)

public class Main {
   
    public static void main(String[] args) {
   
        Person[] p = new Person[3];
        Person p1=new Person("zhangsan",18);
        p[0]=p1;
        Person p2=new Person("lisi",20);
        p[1]=p2;
        Person p3=new Person("wangwu",22)