Java 面向对象中的小测试

编写环境为IDEA
如下图所示

请按照题目的要求编写程序并给出运行结果。 
1、 设计一个学生类 Student 和它的一个子类 Undergraduate，要求如下：

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

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

 3） 在测试类中分别创建 Student 对象和 Undergraduate 对象，调用它们的 show()。 

package SanHomeworkTest;
//创建一个学生类
class Student{
   public String name; //定义变量name
   public int age; //定义变量age
   //创建一个包含两个参数的构造方法
   //这里注意构造方法名一定要和类名相同，并且没有返回值类型的声明，也不能使用return语句返回一个值
    public  Student(String name,int age){
            this.name = name;//使用this关键字访问类中的成员变量
            this.age = age;//使用this关键字访问类中的成员变量
    }
    //定义一个show方法，用来打印Student的属性信息
   public void show(){

        System.out.println("姓名："+name+","+"年龄："+age);//打印name,age的属性信息
    }
}

//定义一个Undergraduate 子类 去继承Student类
class Undergraduate extends Student{
   //定义degree属性
   public String degree;
   //定义一个含有三个参数的有参构造方法，
    public Undergraduate(String name,int age,String degree){
        super(name,age);//使用super关键字获取父类中的name和age属性
        this.degree = degree;//使用this关键字去访问类中的成员变量
    }
    //定义一个show方法，用于打印属性信息
    public void show(){
        System.out.println("姓名："+name+","+"年龄："+age+","+"学位："+degree);
    }
}

//定义一个测试类PractiseOne
public class PractiseOne {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",20);  //创建一个Student对象，并传入属性值
        Undergraduate under1 = new Undergraduate("李四",22,"学士学位"); //创建一个Undergraduate对象，并传入属性值
        stu1.show();//调用Student类中的show方法
        under1.show();//调用Undergraduate类中的show方法
    }
}

2、设计一个 Shape 接口和它的两个实现类 Square 和 Circle，要求如下：

 1）Shape 接口中有一个抽象方法 area()，方法接收有一个 double 类型的参数，返回一个 double 类 型的结果

 2）Square 和 Circle 中实现了 Shape 接口的 area()抽象方法，
 分别求正方形和圆形的面积并返回 在测试类中创建 Square 和 Circle 对象，
 计算边长为 2 的正方形面积和半径为 3 的圆形面积

package SanHomeworkTest;
//创建一个Shape接口
interface Shape{
    double area(double x); //定义一个抽象方法，接收一个double类型的参数
}

//定义一个Square类去实现Shape接口
class Square implements Shape{
//定义一个area方法，并接收一个double类型的参数，返回参数之积
    public double area(double sideLength){
            return sideLength * sideLength;
    }
}
//定义一个Circle类，去实现Shape接口
class Circle implements Shape{
//定义一个area方法，并接收一个double类型的参数，返回参数之积
    public double area(double r){
        return Math.PI * r * r ; //调用math中的PI
    }
}

//定义一个测试类PractiseTwo
public class PractiseTwo {
    public static void main(String[] args) {
        Square square = new Square(); //创建一个Square对象
        Circle circle = new Circle();//创建一个Circle对象
        double s =square.area(2); //调用Square中的area方法，并传入一个参数并将结果赋值给double类型的变量s
        double yuan = circle.area(3);//调用Circle中的area方法，并传入一个参数并将结果赋值给double类型的变量yuan
        System.out.println(s);
        System.out.println(yuan);
    }
}

3、自定义一个异常类 NoThisSoundException 和 Player 类，在 Player 的 play()方法中使用自定义异常， 要求入下： 

1）NoThisSongException 继承 Exception 类，
类中有一个无参和一个接收一个 String 类型参数的 构造方法，
构造方法中都使用 super 关键字调用父类的构造方法。

 2）Player 类中定义一个 play(int index)方法，方法接收一个 int 类型的参数，表示播放歌曲的索 引，
 当 index>10 时，paly()方法用 throw 关键字抛出 NoThisSongException 异常，
 创建异常对 象时，调用有参的构造方法，传入“您播放的歌曲不存在” 。

 3） 在测试类中创建 Player 对象，并调用 play()方法测试自定义的 NoThisSongException 异常，
 使 用 try…catch 语句捕获异常， 调用 NoThisSongException 的 getMessage()方法打印出异常信息。

package SanHomeworkTest;
//自定义一个异常类NoThisSoundException 并且继承Exception 类
class NoThisSoundException extends Exception{
    public NoThisSoundException(){     //定义一个无参构造方法NoThisSoundException
        super();//使用super关键字调用父类中的方法
    }
    //定义一个有参构造方法NoThisSoundException，接收一个String 类型的参数
    public NoThisSoundException(String message){
        super(message);//使用super关键字调用父类中的方法
    }
}

//定义一个Player类
class Player {
//定义一个play方法，并且接收一个int类型的参数，play方法中使用throw关键字抛出NoThisSoundException异常
    public void play(int index) throws NoThisSoundException{
            if (index > 10){
            throw new NoThisSoundException("您播放的歌曲不存在");//创建异常对象，调用有参构造方法，传入您播放的歌曲不存在
            }
            System.out.println("正在播放歌曲");//没有异常的话就程序正常运行
    }
}
//定义一个测试类
public class PractiseThree {
    public static void main(String[] args) {
        Player player = new Player(); //创建一个Player对象
        try {
            player.play(9); //调用Play中的play方法
        }
        catch (Exception e){
           System.out.println("异常信息为："+ e.getMessage());//抛出异常信息
        }
    }
}

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

 1）Student 类中包含姓名、成绩两个属性 
 
2）分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值.

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

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

package ObjectOriented.ThreeUnit;

 class OneTestStudent1 {
    private String name;
    private double grade;
    public OneTestStudent1(){

    }
    public OneTestStudent1(String name,double grade){
        this.name = name;
        this.grade = grade;

    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public double getGrade(){
        return grade;
    }
    public void setGrade(double grade){
        this.grade=grade;
    }
}
public class OneTestStudent{
    public static void main(String[] args) {
        OneTestStudent1 stu1 = new OneTestStudent1();
        stu1.setName("zhangsan");
        stu1.setGrade(100);
        OneTestStudent1 stu2 = new OneTestStudent1("lisi",99);
        System.out.println("姓名"+stu1.getName()+"分数"+stu1.getGrade());
        System.out.println("姓名"+stu2.getName()+"分数"+stu2.getGrade());

          
    }
}

2、定义一个 Father 和 Child 类，并进行测试。 要求如下：

 1）Father 类为外部类，类中定义一个私有的 String 类型的属性 name，name 的值为“zhangjun”。
 
  2）Child 类为 Father 类的内部类，其中定义一个 introFather()方法，方法中调用 Father 类的 name 属性。
  
   3）定义一个测试类 Test，在 Test 类的 main()方法中，创建 Child 对象，并调用 introFather()方法。

package ObjectOriented.ThreeUnit;
class Father{
    private String name="www";
    class Child{
        public void introFather(){
            System.out.println("My Father's name is "+name);
        }
    }
}

public class TwoTest {
    public static void main(String[] args) {
        Father.Child stu = new Father().new Child();
        stu.introFather();
    }
}

请按照题目的要求编写程序并给出运行结果。 
1、请编写程序，实现计算“1+3+5+7+…+99”的值。 提示：

 1) 使用循环语句实现自然数 1~99 的遍历。

 2) 在遍历过程中，通过条件判断当前遍历的数是否为奇数，如果是就累加，否则不加。 

package SanHomeworkTest;

public class Test01 {
    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);
    }
}

2、已知函数

 x+3 (x>0)
 y= 0(x= 0) 
 x2 –1 (x<0) 

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

 1) 定义一个 static 修饰符修饰的方法，方法接收一个 int 类型的参数 x，返回值为 int 类型。

 2) 在方法中使用 if…elseif..else 语句针对 x 的值进行三种情况的判断。

 3) 根据判断结果分别执行不同的表达式，并将结果赋予变量 y。

 4) 在方法的最后返回 y 的值。

 5) 在 main 方法中调用设计好的方法，传入一个 int 型的值，将方法的返回值打印。 

package SanHomeworkTest;

public class four1{
    public static void main(String args[]) {
        int y = function(0);
        System.out.println(y);
    }
    public static int function(int x) {
        int y;
        if (x > 0) {
            y = x + 3;
        } else if (x == 0) {
            y = 0;
        } else {
            y = x * x - 1;
        }
        return y;
    }
}

请编写程序，实现对数组{25,24,12,76,101,96,28} 的排序。 提示：使用冒泡排序算法。

package SanHomeworkTest;

public class four2TwoUnit {
    public static void main(String[] args) {
        int[] arr = { 25, 24, 12, 76, 101, 96, 28 };
        for (int i = 0; i < arr.length - 1; i++) {
// 定义内层循环
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) { 
                    // 比较相邻元素
// 下面的三行代码用于交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); // 打印元素和空格
        }
    }

}