【Java】Java学习笔记（2）——Java面向对象基础作业函数题

最新推荐文章于 2023-07-18 17:28:13 发布

Shaw.W

最新推荐文章于 2023-07-18 17:28:13 发布

阅读量2.8k

点赞数 7

分类专栏：练习文章标签：面向对象编程类 java

本文链接：https://blog.csdn.net/weixin_44544583/article/details/107429756

版权

练习专栏收录该内容

7 篇文章 6 订阅

订阅专栏

本人私人博客：Megalomania，大部分文章会现在博客上传，有不足之处欢迎指正。

学校小学期Java课程的练习题，留个档便于以后需要时候有例子可以回忆，写的烂的地方请多多包含

1、求两个数值之和

描述：定义一个计算器类，从键盘输入两个整数，每个整数按回车确认，调用计算器类中的add()方法计算两个整数之和，并输出结果。
代码

import java.util.Scanner;
class Computer{
	/*
	TODO：求两个数的和
    功能描述：设计方法，计算两个数之和，并返回结果
	参数说明：x，y需要计算的数
	返回值说明：将求和结果返回
	*/
	int add(int x,int y){
		int re;
		re=x+y;
		return re;
	}
}
public class Example4_6 {
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        Computer com = new Computer();
        System.out.println("输入两个整数：");
        int m = reader.nextInt();
        int n = reader.nextInt();
        int result;
	    //TODO:调用Computer中的add方法，传入参数，将结果返回给result
        result=com.add(m,n);
        System.out.println("两数之和："+result); 
    }
}

2、模拟收音机电池使用情况

描述：定义一个电池类和收音机类，电池类有电量这个成员，收音机类有耗电这个方法，当播放收音机就会耗电，现在模拟收音机电池使用情况，有一个满格的电池，让收音机使用，使用10个小时就会用完电池，输入一个整数，要使用几个小时，输出电池使用后的电量。
代码

import java.util.Scanner;
public class Example4_7 {
	public static void main(String args[]) {
		Scanner reader = new Scanner(System.in);
		System.out.println("输入使用几个小时：");
		int h = reader.nextInt();
      	Battery nanfu = new Battery(100);
      	System.out.println("南孚电池的储电量是:"+nanfu.electricityAmount);
      	Radio radio = new Radio();
      	System.out.println("收音机开始使用南孚电池");
      	radio.openRadio(nanfu,h);
      	System.out.println("目前南孚电池的储电量是:"+nanfu.electricityAmount);
   	}
}
class Battery {
	int electricityAmount;
	/*
	TODO:初始化构造方法
    功能描述：把传入的参数赋值给变量electricityAmount
	参数说明：amount为传入参数数值，int类型
	返回值说明：无
	*/
    Battery(int amount){
      	electricityAmount=amount;
    }
}
class Radio {
    void openRadio(Battery battery,int h){
    	if(h>=0 && h<=10){
    		battery.electricityAmount = battery.electricityAmount-(h*10);//TODO: 求电量=总电量-（h*10）
    	}
		else{
			//TODO:输出字符串  时间输入格式有误
            System.out.println("时间输入格式有误");
    	}
	}
}

3、求圆锥的体积

描述：定义一个圆类和圆锥类，圆锥的底是一个圆，所以圆锥类有一个成员是圆类声明的对象，圆锥通过调用方法将某个圆的引用传递给圆锥的圆类型的成员变量，设置圆锥的底的半径和高，求出圆锥的体积。
代码

import java.util.Scanner;
public class Test_1 {
   	public static void main(String args[]) {
	   	Scanner reader = new Scanner(System.in);
       	Circle circle = new Circle();            //【代码1】    
       	System.out.println("输入圆锥底的半径：");
       	circle.setRadius(reader.nextDouble());                    //【代码2】
       	Circular circular = new Circular();      //【代码3】
       	System.out.println("输入圆锥的高：");
       	circular.setHeight(reader.nextDouble());             
       	circular.setBottom(circle);              //【代码4】
       	System.out.println("圆锥的体积:"+circular.getVolme());
   	}
}
class Circle {
	double radius,area;
	void setRadius(double r) {
		radius=r;
    }
    double getRadius() {
		return radius;
    }
	/*
	TODO:计算圆的面积
    功能描述：根据数学公式，编写计算圆面积的代码，半径为radius
	参数说明：无
	返回值说明：圆的面积   
	*/
    double getArea(){
      	area=3.14*radius*radius;
      	return area;
    }
}
class Circular {
	Circle bottom;
    double height;
    void setBottom(Circle c) {
       	bottom = c;
    }
    void setHeight(double h) {
       	height = h;
    }
    double getVolme() {
        if(bottom == null)
           	return -1;
        else{
	    //TODO: 求圆锥的体积，将计算结果返回
            return bottom.getArea()*height/3.0;
        }
	}
	/*
	TODO:获取圆的半径
    功能描述：获取Circle对象的半径（radius）数值
	参数说明：无
	返回值说明：Circle对象的半径
	*/
    double getBottomRadius() {
        return bottom.getRadius();
    }
	/*
    TODO:设置圆的半径
    功能描述：把传入的参数作为圆的半径，赋值给radius字段
	参数说明：r为半径
	返回值说明：无
	*/
    public void setBottomRadius(double r){
      bottom.setRadius(r);
    }
}

4、模拟手机和SIM卡的组合关系

描述：定义一个手机类和SIM卡类，一个手机可以安装任何SIM卡，手机类中有SIM卡的成员变量，并可以调用方法更改其中的SIM卡，现在创建一个手机，给手机安装了一个SIM卡，要换一个其他SIM卡，输出原来和更换后的卡号。
代码

import java.util.Scanner;
public class Example4_9 {
   	public static void main(String args[]) {
	   	Scanner reader = new Scanner(System.in);
	   	System.out.println("输入手机卡号：");
       	SIM simOne = new SIM(reader.nextLong());
       	MobileTelephone mobile = new MobileTelephone();
       	mobile.setSIM(simOne);
       	System.out.println("原来的手机号码:"+mobile.lookNumber());
       	System.out.println("更换手机卡的号码为：");
       	SIM simTwo = new SIM(reader.nextLong());
       	mobile.setSIM(simTwo);
       	System.out.println("更换后的手机号码:"+mobile.lookNumber());
	}
}
/*
TODO:编写手机卡类 
有long型的变量number
有有参构造方法
还有一个getNumber()获取number
*/
class SIM {
	long number;
	SIM(long tmp){
		number=tmp;
	}
    void setNumber(long tmp){
        number=tmp;
    }
    long getNumber(){
        return number;
    }
}
/*
TODO:编写手机类
有SIM类声明的变量sim
有setSIM()方法设置sim
有lookNumber()方法获取sim中的number
*/
class MobileTelephone {
    SIM sim;
    void setSIM(SIM tmp){
        sim=tmp;
    }
    long lookNumber(){
        return sim.getNumber();
    }
}

5、梯形共享一个下底的问题

描述：定义一个Lader类，Lader类创建的梯形对象共享同一个下底，设置共享下底值，使用Lader类创建两个梯形，并输出两个梯形的下底。
代码

import java.util.Scanner;
public class Example4_10 {
	public static void main(String args[]) {
		Scanner reader = new Scanner(System.in);
		System.out.println("输入梯形的共享下底：");
		Lader1.bottom=reader.nextDouble();     //Lader1的字节码被加载到内存,通过类名操作类变量
		Lader1 laderOne=new Lader1();
		Lader1 laderTwo=new Lader1();
		System.out.println("laderOne的下底:"+laderOne.getBottom());
		System.out.println("laderTwo的下底:"+laderTwo.getBottom());
	}
}
class Lader1 {
	double above,height;       //实例变量，上底和高
	static double bottom;     //类变量，下底
	/*TODO：设置上底字段的值
    功能描述：把传入的参数作为上底的值，赋值给字段
	参数说明：a传入的上底值
    返回值说明：无
	*/
	void setAbove(double a) {
		above=a;
	}
	/*TODO：设置下底字段的值
   	功能描述：把传入的参数作为下底的值，赋值给字段
	参数说明：b传入的下底值
    返回值说明：无
	*/
	void setBottom(double b) {
		bottom=b;
	}
    /*TODO：获取上底
    功能描述：获取上底字段的值并返回
	参数说明：无
    返回值说明：上底的值
	*/
	double getAbove(){
		return above;
	}
    /*TODO：获取下底
    功能描述：获取下底字段的值并返回
	参数说明：无
    返回值说明：下底的值
	*/
	double getBottom(){
		return bottom;
	}
}

6、二分法查询

描述：定义一个int型数组并初始化，将数组从小到大排序，然后使用二分法判断用户从键盘输入的整数是否和数组中某个元素的值相同，即是否在数组中，最后打印输出和哪个元素值相同，或者不与数组中任何元素值相同。
代码

import java.util.*;
public class Example4_11 {
   	public static void main(String args[]) {
      	Scanner scanner = new Scanner(System.in);
      	int [] a={12,34,9,23,45,6,45,90,123,19,34};
      	//TODO:调用Arrays的sort方法排序a数组
      	Arrays.sort(a);
      	System.out.println(Arrays.toString(a));
      	System.out.println("输入整数，程序判断该整数是否在数组中:");
      	int number = scanner.nextInt();
      	/*
      	TODO:用Arrays.binarySearch(a,number)获得number数值在a数组中的序号
      	并把结果赋给int类型的index
      	*/
      	int index = Arrays.binarySearch(a,number); 
      	if(index>=0)
        	System.out.println(number+"和数组中索引为"+index+"的元素值相同");
      else
         	System.out.println(number+"不与数组中任何元素值相同");
	}
}

7、类中方法重载的实现

描述：定义一个B类，有两个相同名称的方法hello,参数不同，一个方法是将两个整数相加，另一个是将两个小数相乘，根据提示从键盘输入四个数值，调用B类中的hello方法，并将结果打印。
代码

import java.util.Scanner;
/*
TODO:在类B中编写两个方法名为hello的方法
第一个方法：参数为两个整数a,b返回两个数的和
第二个方法：参数为double型的a,b返回两个数的积
*/
class B {
    int hello(int a, int b){
        return a+b;
    }
    double hello(double a, double b){
        return a*b;
    }
}
public class Example4_12 {
    public static void main(String args[]) {
    	Scanner reader = new Scanner(System.in);
    	System.out.println("请输入两个整数：");
    	int b = reader.nextInt();
    	int a = reader.nextInt();
    	System.out.println("输入两个小数：");
    	double c = reader.nextDouble();
    	double d = reader.nextDouble();
      	//TODO:创建B对象
      	B tom=new B();
      	System.out.println("两个整数调用hello方法的结果：");
      	System.out.println(tom.hello(a,b));
      	System.out.println("两个小数调用hello方法的结果：");
      	System.out.println(tom.hello(c,d));
   }
}

8、求圆和梯形的面积

描述：定义学生类、梯形类、圆类，在梯形类和圆类中都有一个计算面积的方法，学生类中有两个获得圆面积和梯形面积的computerArea方法，测试创建一个学生zhang，设置圆的半径和梯形的上底、下底、高，调用zhang的computerArea方法，得到圆和梯形的面积，并打印输出。
代码

import java.util.Scanner;
public class Example4_13 {
  	public static void main(String args[]) {
	  Scanner reader = new Scanner(System.in);
	  System.out.println("请输入圆的半径：");
      Circle1 circle = new Circle1();
      circle.setRadius(reader.nextDouble());
      System.out.println("请输入梯形的上底、下底、高：");
      Tixing lader = new Tixing(reader.nextDouble(),reader.nextDouble(),reader.nextDouble());
      Student zhang = new Student();
      System.out.println("zhang计算圆的面积：");
      double result=zhang.computerArea(circle);
      System.out.println(result);
      System.out.println("zhang计算梯形的面积：");
      result=zhang.computerArea(lader);
      System.out.println(result);
   }
}
 class Circle1 {
    double radius,area;
	/*
    TODO:设置半径
    功能描述：初始化半径radius
    参数说明：r传入的半径值
    返回值说明：无
    */
    void setRadius(double r) {
        radius=r;
    }
    /*
    TODO:求圆的面积
    功能描述：根据求圆面积的公式，编写代码，求圆面积的值
    参数说明：无
    返回值说明：圆面积值
    */
    double getArea(){
        area=3.14*radius*radius;
        return area;
    }
}
 class Tixing {
   double above,bottom,height;
   /*
   TODO:初始化变量
   功能描述：分别初始化above、bottom、height三个变量值为a、b、h
   参数说明：a，b，h分别对应梯形的上底、下底、高
   返回值说明：无
   */
   Tixing(double a,double b,double h) {
       above=a;
       bottom=b;
       height=h;
   }
   /*
   TODO:求梯形的面积
   功能描述：根据求梯形面积的公式，编写代码求出梯形面积值
   参数说明：无
   返回值说明：梯形面积值
   */
   double getArea() {
       return 0.5*(above+bottom)*height;
   }
}
class Student {
   double computerArea(Circle1 c) {
      //TODO：调用Circle1的getArea方法获取面积
      double area=c.getArea();
      return area;
   }
   double computerArea(Tixing t) {
      //TODO：调用Tixing的getArea方法获取面积
      double area=t.getArea();
      return area;
   }
}

9、根据输入的名字初始化对象

描述：定义People1类，包含int型成员变量 leg、hand，String类型变量name，以及有参构造函数，和初始化的方法。获取键盘输入的名字，作为构造函数的参数，初始化对象，并打印对象属性值。
代码

import java.util.Scanner;
public class People1{
    int leg,hand;
    String name;
    People1(String s){
        //TODO：将参数s赋值给name
        name=s;
        this.init();
    }
    void init(){
       leg=2;
       hand=2;
       System.out.println(name+"有"+hand+"只手"+leg+"条腿");
    }
    public static void main(String args[]){
    	Scanner reader = new Scanner(System.in);
    	System.out.println("请输入名字：");
        //TODO:创建People1时，构造方法中的传入参数为输入的值
        People1 p=new People1(reader.next());
    }
}

10、大小写转换

描述：从键盘输入含有大小写字母的字符串，按回车结束，然后将字符串中的小写字母转换成大写，大写字母转换成小写，并将转换后的字符串输出。
代码

import java.util.Scanner;
public class Example4_20 { 
   public static void main(String args[ ]) { 
	   Scanner reader = new Scanner(System.in);
	   System.out.println("请输入一串英文字母（回车确认）:");
      String str = reader.nextLine();
      char a[]=new char[str.length()];
      for(int i=0;i<str.length();i++) { 
         if(Character.isLowerCase(str.charAt(i)))    
        	 //TODO: 将小写字母变成大写
             a[i]=Character.toUpperCase(str.charAt(i));
         else if(Character.isUpperCase(str.charAt(i)))
             //TODO: 将大写字母变成小写
             a[i]=Character.toLowerCase(str.charAt(i));
         else
        	 System.out.println("第"+(i+1)+"个字母"+str.charAt(i)+"输入有误");
       }
      System.out.println("大小写转换后的字母：");
      for(int i=0;i<a.length;i++)   
         /*
         TODO:输出数组a中的内容
         输出提示：System.out.print(" "+输出内容);
         */
        System.out.print(" "+a[i]);
   }
}

11、求矩形和梯形的面积

描述：定义一个矩形类和梯形类，分别求矩形面积和梯形的面积，并输出结果。
代码

import java.util.Scanner;
public class Example4_5 {
    public static void main(String args[]) {
       Scanner reader = new Scanner(System.in);
       /** TODO:创建Rect类对象ractangle **/ 
       Rect ractangle=new Rect();
       System.out.println("输入矩形的宽：");
       ractangle.width = reader.nextDouble();
       System.out.println("输入矩形的高：");
       ractangle.height = reader.nextDouble();
       double area=ractangle.getArea();
       System.out.println("矩形的面积:"+area);
       /** TODO:创建Lader类对象lader **/ 
       Lader lader=new Lader();
       System.out.println("输入梯形的上底：");
       lader.above= reader.nextDouble();
       System.out.println("输入梯形的下底：");
       lader.bottom= reader.nextDouble();
       System.out.println("输入梯形的高：");
       lader.height= reader.nextDouble();
       area=lader.getArea();
       System.out.println("梯形的面积:"+area);
      }
}
class Rect {
    double width;  //矩形的宽
    double height; //矩形的高

    double getArea() {
       /** TODO: 求矩形面积 **/
       return width*height;
    }
}
class Lader {
    double above;   //梯形的上底
    double bottom;  //梯形的下底
    double height;  //梯形的高

    double getArea() {
       /**TODO:  求梯形面积 **/
       return 0.5*(above+bottom)*height;
    }
}

12、分数运算

描述：定义一个Rational类，编写方法对两个分数做加法减法乘法除法，返回结果为分数，从键盘输入两个数的分子和分母，对这两个数求加减乘除，并输出结果。
代码

import java.util.Scanner;
public class Example4_23 {
   public static void main(String args[]) {
      Scanner reader = new Scanner(System.in); 
      Rational r1=new Rational();
      r1.setNumerator(reader.nextInt());
      r1.setDenominator(reader.nextInt());
      Rational r2=new Rational();
      r2.setNumerator(reader.nextInt());
      r2.setDenominator(reader.nextInt());
      Rational result=r1.add(r2); 
      int a=result.getNumerator();
      int b=result.getDenominator();  
      System.out.println("求和： "+a+"/"+b);
      result=r1.sub(r2);
      a=result.getNumerator();
      b=result.getDenominator();    
      System.out.println("求差： "+a+"/"+b);
      result=r1.muti(r2); 
      a=result.getNumerator();
      b=result.getDenominator();  
      System.out.println("求积："+a+"/"+b);
      result=r1.div(r2);
      a=result.getNumerator();
      b=result.getDenominator();   
      System.out.println("求商： "+a+"/"+b);
   }
}
class Rational {
   int numerator = 1 ;   //分子
   int denominator = 1; //分母
   void setNumerator(int a) {  //设置分子
      int c=f(Math.abs(a),denominator);  //计算最大公约数
      numerator = a/c; 
      denominator = denominator/c;
      if(numerator<0&&denominator<0) {
          numerator = -numerator;
          denominator = -denominator;
      }
   }
   void setDenominator(int b) {  //设置分母
      int c=f(numerator,Math.abs(b));  //计算最大公约数
      numerator = numerator/c;
      denominator = b/c;
      if(numerator<0&&denominator<0) {
          numerator = -numerator;
          denominator = -denominator;
      }
   }
   int getNumerator() {
      return numerator;
   }
   int getDenominator() {
     return denominator;
   }  
   int f(int a,int b) { //求a和b的最大公约数
      if(a==0) return 1;
      if(a<b) {
         int c=a;
         a=b;
         b=c; 
      }
      int r=a%b;
      while(r!=0) {
         a=b;
         b=r;
         r=a%b;
      } 
      return b;
   }
   Rational add(Rational r) {  //加法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b+denominator*a; //计算出新分子
      int newDenominator=denominator*b;           //计算出新分母
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational sub(Rational r) {  //减法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b-denominator*a;
      int newDenominator=denominator*b;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational muti(Rational r) { //乘法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*a;
      int newDenominator=denominator*b;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational div(Rational r)  { //除法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b;
      int newDenominator=denominator*a;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
}

13、求前n项之和

描述：从键盘输入一个为n的项数,按回车结束,计算2/1+3/2+4/3+…+(n+1)/n之和，结果用分数表示和小数，并输出。
代码

import java.util.Scanner;
public class Example4_24 {
   public static void main(String args[]) {
	   Scanner reader = new Scanner(System.in);
      int n=reader.nextInt(),k=1,a=0,b=0;
      System.out.println("前"+n+"项求和：");
      Rational sum=new Rational();
      sum.setNumerator(0);
      Rational item=new Rational();
      item.setNumerator(2);
      item.setDenominator(1);
      sum=sum.add(item);
      a=2;
      b=1;
      while(k<n) {
         //求前n项和的分子和分母
         // TODO：
         item.setNumerator(a+b);
         item.setDenominator(a);
         sum=sum.add(item);
         int temp=a;
         a=a+b;
         b=temp;
         k++;
      } 
      a=sum.getNumerator();
      b=sum.getDenominator();
      System.out.println("用分数表示:");
      System.out.println(a+"/"+b);
      double doubleResult=(a*1.0)/b;
      System.out.println("用小数表示:");
      System.out.print(doubleResult); 
   }
}
class Rational {
   int numerator = 1 ;   //分子
   int denominator = 1; //分母
   void setNumerator(int a) {  //设置分子
      int c=f(Math.abs(a),denominator);  //计算最大公约数
      numerator = a/c; 
      denominator = denominator/c;
      if(numerator<0&&denominator<0) {
          numerator = -numerator;
          denominator = -denominator;
      }
   }
   void setDenominator(int b) {  //设置分母
      int c=f(numerator,Math.abs(b));  //计算最大公约数
      numerator = numerator/c;
      denominator = b/c;
      if(numerator<0&&denominator<0) {
          numerator = -numerator;
          denominator = -denominator;
      }
   }
   int getNumerator() {
      return numerator;
   }
   int getDenominator() {
     return denominator;
   }  
   int f(int a,int b) { //求a和b的最大公约数
      if(a==0) return 1;
      if(a<b) {
         int c=a;
         a=b;
         b=c; 
      }
      int r=a%b;
      while(r!=0) {
         a=b;
         b=r;
         r=a%b;
      } 
      return b;
   }
   Rational add(Rational r) {  //加法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b+denominator*a; //计算出新分子
      int newDenominator=denominator*b;           //计算出新分母
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational sub(Rational r) {  //减法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b-denominator*a;
      int newDenominator=denominator*b;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational muti(Rational r) { //乘法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*a;
      int newDenominator=denominator*b;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
   Rational div(Rational r)  { //除法运算
      int a=r.getNumerator();
      int b=r.getDenominator();
      int newNumerator=numerator*b;
      int newDenominator=denominator*a;
      Rational result=new Rational(); 
      result.setNumerator(newNumerator);
      result.setDenominator(newDenominator);
      return result;
   }
}

14、求分数评定的最后得分

就是不能通过，很申必，我觉得代码没问题就贴上来了

描述：用流水线完成分数评定,其中InputScore类的对象负责录入分数,InputScore类组合了DelScore类的对象；DelScore类的对象负责去掉一个最高分和一个最低分,DelScore类组合了ComputerAver类对象;ComputerAver类对象负责计算平均值;Line类组合了InputScore、DelScore和ComputerAver三个类的实例,从键盘输入评委数和每位评委的评分，根据规则计算出平均分,并输出。
代码

import java.util.Scanner;
public class SingGame {
  public static void main(String args[]){
      Line line=new  Line();
      line.givePersonScore();
  }
}

class InputScore {
   DelScore del ;
   InputScore(DelScore del) {
       /** TODO: 给类成员变量del赋值 **/
	   this.del=del;
   }
   public void inputScore() {
      System.out.println("请输入评委数");
      Scanner read=new Scanner(System.in);
      int count = read.nextInt();
      System.out.println("请输入各个评委的分数");
      double []a = new double[count];
      for(int i=0;i<count;i++) {
           a[i]=read.nextDouble();
      }
      del.doDelete(a);
   }
}
class Line {
    InputScore one;
    DelScore two;
    ComputerAver three;  
    Line(){
       /** TODO: 给类成员变量one，two，three赋值 **/
    	three=new ComputerAver();
    	two=new DelScore(three);
    	one= new InputScore(two);
    }
    public void givePersonScore(){ 
       one.inputScore();
    }
}
class ComputerAver {
   public void giveAver(double [] b) {
      double sum=0;
      for(int i =0;i<b.length;i++) {  
         sum = sum+ b[i];
      }
      double aver=sum/b.length;
      System.out.print("选手最后得分"+aver);
   }
}
class DelScore {
   ComputerAver computer ;
   DelScore(ComputerAver computer) {
       this.computer = computer;
   }
   public void doDelete(double [] a) {
       /** TODO: 数组a从小到大排序 **/
       java.util.Arrays.sort(a);
      System.out.print("去掉一个最高分:"+a[a.length-1]+"，");
      System.out.print("去掉一个最低分:"+a[0]+"。");  
      double b[] =new double[a.length-2];
       /** TODO: 给b赋值，去掉最高分和最低分 **/
      for(int i=0;i<a.length-2;i++) {//去掉最高分和最低分
  		b[i] = a[i+1];
      }
      computer.giveAver(b);
   }
}

文章转载请注明本人博客地址：
转载自：Megalomania - 【Java】Java学习笔记（2）——Java面向对象基础作业函数题

Shaw.W

关注

7
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
【Java】Java学习笔记（2）——Java面向对象基础作业函数题

本人私人博客：Codewalking，大部分文章会现在博客上传，有不足之处欢迎指正。学校小学期Java课程的练习题，留个档便于以后需要时候有例子可以回忆，写的烂的地方请多多包含1、求两个数值之和描述：定义一个计算器类，从键盘输入两个整数，每个整数按回车确认，调用计算器类中的add()方法计算两个整数之和，并输出结果。代码import java.util.Scanner;class Computer{ /* TODO：求两个数的和功能描述：设计方法，计算两个数之和，并返回.
复制链接

扫一扫