Java实现一个分数类

已于 2022-08-03 21:28:21 修改
阅读量1.8k 收藏 27
点赞数 5
文章标签： java eclipse
于 2022-08-03 21:26:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58714015/article/details/126149235
版权
该博客介绍了如何使用Java编写一个分数类，包括分数的构造、约分、整数转换、基本运算（加、减、乘、除、倒数、相反数）。类中还包含了特殊值（正无穷、负无穷、NaN）的处理，并提供了比较操作。通过测试用例展示了类的功能。
摘要由CSDN通过智能技术生成

Java实验写一个分数类

（1）分数是指两个整数的比。分数本身可以构造和约分；任何整数都可以看作一个分数。
（2）单个分数可以运算，包括求倒数、求相反数、扩大、缩小等。
（3）两个分数可以运算，包括加减乘除等。

package wcq;

import java.math.BigInteger;

public class Fraction implements Comparable{

private int sign = 0;
private BigInteger numerator = BigInteger.ZERO;	//分数的分子
private BigInteger denominator = BigInteger.ZERO;	//分数的分母
public static final Fraction ZERO = new Fraction(0,1);
public static final Fraction ONE = new Fraction(1,1);
public static final Fraction NEGATIVE_INFINITY = new Fraction(-1,0);
public static final Fraction POSITIVE_INFINITY = new Fraction(1,0);
public static final Fraction NAN = new Fraction(0,0);


public Fraction(BigInteger numerator,BigInteger denominator) {
	 
	if( numerator.compareTo(BigInteger.ZERO)==-1 && denominator.compareTo(BigInteger.ZERO)==-1) {
		this.sign = 1;
	}
	else if( numerator.compareTo(BigInteger.ZERO)==1 && denominator.compareTo(BigInteger.ZERO)==1) {
		this.sign = 1;
	}
	else if( numerator.compareTo(BigInteger.ZERO)==0 && denominator.compareTo(BigInteger.ZERO)==0) {
		this.sign = 0;
		this.numerator = BigInteger.ZERO;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else if( numerator.compareTo(BigInteger.ZERO)==0 ){
		this.sign = 0;
		this.numerator = BigInteger.ZERO;
		this.denominator = BigInteger.ONE;
		return;
	}
	else if( denominator.compareTo(BigInteger.ZERO)==0 && numerator.compareTo(BigInteger.ZERO)==1 ) {
		this.sign = 1;
		this.numerator = BigInteger.ONE;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else if( denominator.compareTo(BigInteger.ZERO)==0 && numerator.compareTo(BigInteger.ZERO)==-1 ) {
		this.sign = -1;
		this.numerator = BigInteger.ONE;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else {
		this.sign = -1;
	}
	
	numerator = numerator.abs();
	denominator = denominator.abs();
	BigInteger common = numerator.gcd(denominator);
	this.numerator = numerator.divide(common);
	this.denominator = denominator.divide(common);
	
}

public Fraction(long lNumerator,long lDenominator) {
	
	if(lNumerator < 0 && lDenominator < 0) {
		this.sign = 1;
	}
	else if(lNumerator > 0 && lDenominator > 0) {
		this.sign = 1;
	}
	else if(lNumerator == 0 && lDenominator == 0) {
		this.sign = 0;
		this.numerator = BigInteger.ZERO;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else if(lNumerator == 0) {
		this.sign = 0;
		this.numerator = BigInteger.ZERO;
		this.denominator = BigInteger.ONE;
		return;
	}
	else if(lDenominator == 0 && lNumerator > 0) {
		this.sign = 1;
		this.numerator = BigInteger.ONE;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else if(lDenominator == 0 && lNumerator < 0) {
		this.sign = -1;
		this.numerator = BigInteger.ONE;
		this.denominator = BigInteger.ZERO;
		return;
	}
	else {
		this.sign = -1;
	}
	
	Long lNum = lNumerator;
	String sNum = lNum.toString();
	BigInteger bNum = new BigInteger(sNum);
	bNum = bNum.abs();
	Long lDen = lDenominator;
	String sDen = lDen.toString();
	BigInteger bDen = new BigInteger(sDen);
	bDen = bDen.abs();
	BigInteger common = bNum.gcd(bDen);
	this.numerator = bNum.divide(common);
	this.denominator = bDen.divide(common);
	
}

public Fraction(long integerValue) {
	
	if(integerValue < 0) this.sign = -1;
	else if(integerValue > 0) this.sign = 1;
	else {
		this.sign = 0;
		this.numerator = BigInteger.ZERO;
		this.denominator = BigInteger.ONE;
		return;
	}
	Long lNum = integerValue;
	String sNum = lNum.toString();
	BigInteger bNum = new BigInteger(sNum);
	bNum = bNum.abs();
	this.numerator = bNum;
	this.denominator = BigInteger.ONE;
	
}

public int getSign() {
	
	return sign;
	
}

public BigInteger getNumerator() {
	
	return numerator;
	
}

public BigInteger getDenominator() {
	
	return denominator;
	
}

public String toString() {
	
	String s = "";
	if(this.sign == 1) {
		s = "+";
	}
	else if(this.sign == -1) {
		s = "-";
	}
	else if(this.sign == 0 && this.denominator.compareTo(BigInteger.ONE)==0 ) {
		s = "0/1";
		return s;
	}
	else return s;	//NAN
	s += this.numerator.toString()+"/"+this.denominator.toString();
	return s;
	
}

public boolean isNaN() {
	
	if(this.sign == 0 && this.denominator.compareTo(BigInteger.ZERO)==0 ) {
		return true;
	}
	else return false;
	
}

public boolean isZero() {
	
	if(this.sign == 0 && this.denominator.compareTo(BigInteger.ONE)==0 ) {
		return true;
	}
	else return false;
	
}

public boolean isPositive() {
	
	if(this.sign == 1) {
		return true;
	}
	else return false;
}

public boolean isNegative() {
	
	if(this.sign == -1) {
		return true;
	}
	else return false;
}

public boolean isInfinite() {
	
	if( this.numerator.compareTo(BigInteger.ONE)==0 && this.denominator.compareTo(BigInteger.ZERO)==0 ) {
		return true;
	}
	else return false;
	
}

public Fraction clone() {
	
	Fraction frac = new Fraction(1,1);
	frac.sign = this.sign;
	frac.numerator = this.numerator;
	frac.denominator = this.denominator;
	return frac;
	
}

public Fraction abs() {
	
	if(this.sign < 0)
		this.sign = 1;
	return this;
	
}

public Fraction opposite() {
	
	Fraction frac = this.clone();
	frac.sign = 0-this.sign;
	return frac;
	
}

public Fraction reciprocal() {
	
	if(this.isZero()) {
		return Fraction.POSITIVE_INFINITY;
	}
	else if(this.isInfinite()) {
		return Fraction.ZERO;
	}
	else {
		BigInteger temp = this.numerator;
		this.numerator = this.denominator;
		this.denominator = temp;
		return this;
	}
	
}

public int absCompareTo(Fraction that) {
	
	Fraction thisone = this.abs();
	Fraction thatone = that.abs();
	if(thisone.isNaN()) {
		thisone = Fraction.ZERO;
	}
	if(thatone.isNaN()) {
		thatone = Fraction.ZERO;
	}
	if(thisone.isZero() && thatone.isZero()) {
		return 0;
	}
	else if(thisone.isInfinite() && thatone.isInfinite()) {
		return 0;
	}
	else {
		if( (thisone.numerator.multiply(thatone.denominator)).compareTo(thatone.numerator.multiply(thisone.denominator)) == 1) {
			return 1;
		}
		else if ( (thisone.numerator.multiply(thatone.denominator)).compareTo(thatone.numerator.multiply(thisone.denominator)) == 0 ) {
			return 0;
		}
		else return -1;
	}
	
}

public int compareTo(Fraction that) {	//实现接口函数
	
	if(this.sign == 1 && that.sign == -1 || this.sign == 1 && that.sign == 0) {
		return 1;
	}
	else if(this.sign == -1 && that.sign == 1 || this.sign == 0 && that.sign == 1) {
		return -1;
	}
	else if(this.sign == 1 && that.sign == 1) {
		return this.absCompareTo(that);
	}
	else if(this.sign == -1 && that.sign == -1) {
		return 0-this.absCompareTo(that);
	}
	else {	//this.sign == that.sign == 0
		return 0;
	}
	
}

private Fraction positiveAdd(Fraction that) {
	
	if(this.isInfinite() || that.isInfinite()) {
		return Fraction.POSITIVE_INFINITY;
	}
	else if(this.isZero()) {
		return that;
	}
	else if(that.isZero()) {
		return this;
	}
	else {
		Fraction frac = new Fraction(1,1);
		frac.numerator = this.numerator.multiply(that.denominator).add(that.numerator.multiply(this.denominator));
		frac.denominator = this.denominator.multiply(that.denominator);
		BigInteger common = frac.numerator.gcd(frac.denominator);
		frac.numerator = frac.numerator.divide(common);
		frac.denominator =frac.denominator.divide(common);
		return frac;
	}
	
}

private Fraction positiveSubtract(Fraction smaller) {
	
	if(this.isZero()) {
		smaller.sign = 0 - smaller.sign;
		return smaller;
	}
	else if(smaller.isZero()) {
		return this;
	}
	else if(this.isInfinite() && smaller.isInfinite()) {
		return Fraction.ZERO;
	}
	else if(this.isInfinite()) {
		return Fraction.POSITIVE_INFINITY;
	}
	else if(smaller.isInfinite()) {
		return Fraction.NEGATIVE_INFINITY;
	}
	else {
		Fraction frac = new Fraction(1,1);
		frac.numerator = this.numerator.multiply(smaller.denominator).subtract(smaller.numerator.multiply(this.denominator));
		if(frac.numerator.compareTo(BigInteger.ZERO)==-1) {
			frac.sign = -1;
		}
		else if(frac.numerator.compareTo(BigInteger.ZERO)==0) {
			return Fraction.ZERO;
		}
		frac.denominator = this.denominator.multiply(smaller.denominator);
		BigInteger common = frac.numerator.gcd(frac.denominator);
		frac.numerator = frac.numerator.divide(common);
		frac.denominator =frac.denominator.divide(common);
		return frac;
	}
	
}

public Fraction add(Fraction that) {
	
	if(this.isInfinite() || that.isInfinite()) {
		if(this.isInfinite() && that.isInfinite()) {
			if(this.sign == 1 && that.sign == 1) {
				return Fraction.POSITIVE_INFINITY;
			}
			else if(this.sign == -1 && that.sign == -1) {
				return Fraction.NEGATIVE_INFINITY;
			}
			else {
				return Fraction.ZERO;
			}
		}
		else if(this.isInfinite()) {
			return this;
		}
		else return that;
	}
	else if(this.isZero() || that.isZero()) {
		if(this.isZero()) {
			return that;
		}
		else {
			return this;
		}
	}
	else {
		Fraction frac = new Fraction(1,1);
		Integer thisISign = this.sign;
		String thisSSign = thisISign.toString();
		BigInteger thisBSign = new BigInteger(thisSSign);
		Integer thatISign = that.sign;
		String thatSSign = thatISign.toString();
		BigInteger thatBSign = new BigInteger(thatSSign);
		frac.numerator = thisBSign.multiply(this.numerator.multiply(that.denominator)).add(thatBSign.multiply(that.numerator.multiply(this.denominator)));
		if(frac.numerator.compareTo(BigInteger.ZERO)==-1) {
			frac.sign = -1;
			frac.numerator = frac.numerator.abs();
		}
		else if(frac.numerator.compareTo(BigInteger.ZERO)==0) {
			return Fraction.ZERO;
		}
		frac.denominator = this.denominator.multiply(that.denominator);
		BigInteger common = frac.numerator.gcd(frac.denominator);
		frac.numerator = frac.numerator.divide(common);
		frac.denominator =frac.denominator.divide(common);
		return frac;
	}
	
}

public Fraction subtract(Fraction that) {
	
	if(this.isInfinite() || that.isInfinite()) {
		if(this.isInfinite() && that.isInfinite()) {
			if(this.sign == 1 && that.sign == 1) {
				return Fraction.ZERO;
			}
			else if(this.sign == -1 && that.sign == -1) {
				return Fraction.ZERO;
			}
			else if(this.sign == 1 && that.sign == -1){
				return Fraction.POSITIVE_INFINITY;
			}
			else return Fraction.NEGATIVE_INFINITY;
		}
		else if(this.isInfinite()) {
			return this;
		}
		else {
			that.sign = 0 - that.sign;
			return that;
		}
	}
	else if(this.isZero() || that.isZero()) {
		if(this.isZero()) {
			return that;
		}
		else {
			return this;
		}
	}
	else {
		Fraction frac = new Fraction(1,1);
		Integer thisISign = this.sign;
		String thisSSign = thisISign.toString();
		BigInteger thisBSign = new BigInteger(thisSSign);
		Integer thatISign = that.sign;
		String thatSSign = thatISign.toString();
		BigInteger thatBSign = new BigInteger(thatSSign);
		frac.numerator = thisBSign.multiply(this.numerator.multiply(that.denominator)).subtract(thisBSign.multiply(that.numerator.multiply(this.denominator)));
		if(frac.numerator.compareTo(BigInteger.ZERO)==-1) {
			frac.sign = -1;
			frac.numerator = frac.numerator.abs();
		}
		else if(frac.numerator.compareTo(BigInteger.ZERO)==0) {
			return Fraction.ZERO;
		}
		frac.denominator = this.denominator.multiply(that.denominator);
		BigInteger common = frac.numerator.gcd(frac.denominator);
		frac.numerator = frac.numerator.divide(common);
		frac.denominator =frac.denominator.divide(common);
		return frac;
	}
	
}

public Fraction multiply(Fraction factor) {
	
	if(this.isZero() || factor.isZero()) {
		return Fraction.ZERO;
	}
	else if(this.isInfinite() || factor.isInfinite() ) {
		if(this.sign == factor.sign) {
			return Fraction.POSITIVE_INFINITY;
		}
		else return Fraction.NEGATIVE_INFINITY;
	}
	else {
		Fraction frac = new Fraction(1,1);
		frac.numerator = this.numerator.multiply(factor.numerator);
		if(this.sign != factor.sign) {
			frac.sign = -1;
		}
		frac.denominator = this.denominator.multiply(factor.denominator);
		BigInteger common = frac.numerator.gcd(frac.denominator);
		frac.numerator = frac.numerator.divide(common);
		frac.denominator =frac.denominator.divide(common);
		return frac;
	}
	
}

public Fraction multiply(long ratio) {
	
	if(this.sign == 0) return Fraction.ZERO;
	if(ratio == 0) {
		return Fraction.ZERO;
	}
	else if(ratio < 0) {
		this.sign = 0-this.sign;
		Long lRatio = 0-ratio;
		String sRatio = lRatio.toString();
		BigInteger bRatio = new BigInteger(sRatio);
		this.numerator = this.numerator.multiply(bRatio);
		BigInteger common = this.numerator.gcd(this.denominator);
		this.numerator = this.numerator.divide(common);
		this.denominator = this.denominator.divide(common);
	}
	else {
		Long lRatio = ratio;
		String sRatio = lRatio.toString();
		BigInteger bRatio = new BigInteger(sRatio);
		this.numerator = this.numerator.multiply(bRatio);
		BigInteger common = this.numerator.gcd(this.denominator);
		this.numerator = this.numerator.divide(common);
		this.denominator = this.denominator.divide(common);
	}
	return this;
	
}

public Fraction divide(Fraction divisor) {
	
	divisor = divisor.reciprocal();
	return this.multiply(divisor);
	
}

public Fraction divide(long ratio) {
	
	if(this.sign == 0) return Fraction.ZERO;
	if(ratio == 0) {
		if(this.sign == 1)	return Fraction.POSITIVE_INFINITY;
		else return Fraction.NEGATIVE_INFINITY;
	}
	else if(ratio < 0) {
		this.sign = 0-this.sign;
		Long lRatio = 0-ratio;
		String sRatio = lRatio.toString();
		BigInteger bRatio = new BigInteger(sRatio);
		this.denominator = this.denominator.multiply(bRatio);
		BigInteger common = this.numerator.gcd(this.denominator);
		this.numerator = this.numerator.divide(common);
		this.denominator = this.denominator.divide(common);
	}
	else {
		Long lRatio = ratio;
		String sRatio = lRatio.toString();
		BigInteger bRatio = new BigInteger(sRatio);
		this.denominator = this.denominator.multiply(bRatio);
		BigInteger common = this.numerator.gcd(this.denominator);
		this.numerator = this.numerator.divide(common);
		this.denominator = this.denominator.divide(common);
	}
	return this;
	
}

public static void testSimple() {
	
    Fraction sum = ZERO;
    for (int i=1; i<=100; i++) {
        int denominator = i * (i+1);
        Fraction addend = new Fraction(1, denominator);
        sum = sum.add(addend);
    }
    System.out.println(sum);
    
}

public static void testComplex() {
    java.util.ArrayList<Fraction> al = new java.util.ArrayList<Fraction>();
    int quantity = 2022;
    for (int i=1; i<=quantity; i++) {
        int denominator = i * (i+1);
        Fraction addend = new Fraction(1, denominator);
        al.add(addend);
    }
    for (int i=1; i<=quantity-1; i+=2) {
        int denominator = i * (i+2);
        Fraction addend = new Fraction(1, denominator);
        al.add(addend.opposite());
    }
    int size = al.size();
    Fraction[] fractions = new Fraction[size];
    al.toArray(fractions);
    for (int i=0; i<size; i++) {
        int pos = (int)(Math.random() * size);
        Fraction temp = fractions[i];
        fractions[i] = fractions[pos];
        fractions[pos] = temp;
    }
    Fraction sum = Fraction.ZERO;
    for (int i=0; i<size; i++)
        sum = sum.add(fractions[i]);
    System.out.println(sum);
}

public static void main(String[] args) {
	
	testComplex();
	
}

}
在这里插入图片描述输出结果

好了分享到此，不足之处，欢迎留言指正。

类的构造和对象的是使用java 分数
11-28
定义一个类Fact表示无符号有理数（分数），成员有分子（num）和分母(den) 构造函数2个 一组get方法 一组set方法 方法： 从键盘输入分数的分子分母 -对分数进行约分（分子分母同时除以最大公约数） -对两个分数进行通分（先约分） -两个分数（+-×/），结果为不可约数（先通分，然后再约分） -比较两个分数的大小，结果为boolean的值 显示分数方法 例如 7/8 定义testFact类， 创建Fact对象，并调用各个方法
JAVA分数类的实现
03-22
NULL 博文链接：https://linpz.iteye.com/blog/1005830
java:实现常见的分数运算(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-19 503
java:实现常见的分数运算(附完整源码)
java分数类_java 分数类
weixin_35081861的博客
02-16 204
classFraction{BigIntegerup,down;publicFraction(Fractionf){this.up=f.up;this.down=f.down;}publicFraction(Strings){this.up=newBigInteger(s);this.down=newBigInteger("1");}publicFraction(BigIntegera...
Java 分数
weixin_53545457的博客
12-12 354
每项是前一项的一半，如果一共有 20 项,求这个和是多少，结果用分数表示出来。类似：3/2，当然，这只是加了前 2 项而已。
java分数类_一个Java分数类.
weixin_39760619的博客
02-16 193
importjava.math.BigInteger;publicclassFraction{BigIntegernumerator,denominator,gcd;voidset(Stringn,Stringd){numerator=newBigInteger(n);denominator=newBigInteger(d);}voidsimplify(){gcd=numerat...
java实验报告——分数类
m0_69213103的博客
10-14 1025
【代码】java实验报告——分数类。
java分数类_JAVA分数类的实现
weixin_28523493的博客
02-25 820
题目：1、写一个分数类，实现分数的加、减、乘、除；2、对下面分数从小到大排序：1/2 , 2/3 , 48/62 , 70/20, 9/25我的解法如下，大家一起讨论讨论：package com.gzitc.exam;/*** 求最大公约数，最小公倍数* @author e606#qq.com**/public class MathUtil {/*** 两个数求最大公约数，可以用辗转相除法。* 始...
Java求一个分数数列的前20项之和的实现代码
08-31
在这个特定的示例中，我们要计算一个分数数列的前20项之和。这个数列是斐波那契数列的一个变种，也被称为黄金分割数列或者卢卡斯数列，它的每一项都是前两项的和，但这里的分数形式有所不同。具体来说，数列的前几项...
设计一个分数类java_Java 有理数类 分数类 Rational类的设计与实现
weixin_31533357的博客
02-23 987
要实现Rational类的加减乘除，要实现其可比较性，要覆盖toString()方法，要实现不同数据类型的转换等。package chapter14;public class Rational extends Number implements Comparable {private long numerator=0;private long denominator=1;public Ration...
java实现给出分数数组得到对应名次数组的方法
09-03
首先，我们需要创建一个类`ScoreRank`，在这个类中定义方法来处理分数数组并计算名次。在代码中，我们看到一个名为`scoreRank`的静态方法，它接收一个整型数组`score`作为参数，返回一个同样大小的整型数组`temp`，...
设计一个矩形类Rectangle(Java)
10-27
在Java编程语言中，设计一个矩形类Rectangle是一项常见的任务，它可以帮助我们更好地理解面向对象编程的概念。这个类应该能够表示二维空间中的矩形，并提供与其几何特性相关的操作。下面我们将详细探讨如何创建这样...
设计一个分数类java_网易云课堂_Java语言程序设计进阶_第1周 类和对象_1分数(示例代码)...
weixin_33628316的博客
02-23 254
1分数(10分)题目内容：设计一个表示分数的类Fraction。这个类用两个int类型的变量分别表示分子和分母。这个类的构造函数是：Fraction(int a, int b)构造一个a/b的分数。这个类要提供以下的功能：double toDouble();将分数转换为doubleFraction plus(Fraction r);将自己的分数和r的分数相加，产生一个新的Fraction的对象。注...
【Java例题】2.2 分数类
weixin_34190136的博客
04-17 263
2.定义分数类，包括分子和分母变量、构造方法、 加减乘除方法、化简方法、值计算方法和显示分子和分母的方法。 然后编写一个主类，在其主方法中通过定义两个分数对象来 显示每一个分数的分子值、分母值、化简和值， 显示两个分数加减乘除结果。 package chapter2; public class demo2 { public static void main(String[] ...
浙江大学MOOC零基础学Java第一周作业——分数
weixin_45145726的博客
02-24 381
题目内容： 设计一个表示分数的类Fraction。这个类用两个int类型的变量分别表示分子和分母。 这个类的构造函数是： Fraction(int a, int b) 构造一个a/b的分数。 这个类要提供以下的功能： double toDouble(); 将分数转换为double Fraction plus(Fraction r); 将自己的分数和r的分数相加，产生一个新的Fraction的对象。...
实现常见的分数运算 Java
TechGlide的博客
08-14 643
类来表示分数，并提供相应的运算方法和化简方法，可以方便地进行分数计算并得到准确的结果。分数运算是数学中常见且重要的计算方式，它在很多领域都有广泛的应用。本文将介绍如何使用Java编程语言实现常见的分数运算，包括分数的加减乘除以及化简等操作。首先，我们需要设计一个表示分数的类，可以包含分子和分母两个整数成员变量，并提供相应的构造方法和操作方法。本文介绍了如何使用Java实现常见的分数运算，包括分数的加减乘除以及化简操作。需要注意的是，输出的分数并没有进行化简处理，可以根据需要自行调用。方法对分数进行化简。
java的分数类
weixin_30389003的博客
12-24 150
概述 分数类在算法中非常重要, 而在java中不那么重要,java基础类库提供 了biginteger了,提供类似方式, package 组合数学; public class Fraction { private long Numerator; // 分子 private long Denominator; // 分母 public Fraction(l...
SpringBoot原理篇-SpringBoot配置优先级-Bean管理-起步依赖原理-自动配置两种方案-源码跟踪-自定义starter
最新发布
2303_78076382的博客
03-22 1388
自动配置+起步依赖：需求:自定义aliyun-oss-spring-boot-starter,完成阿里云OSS操作工具类AliyunOSSOperator的自动配置目标:引入起步依赖之后,要想使用阿里云OSS，注入AliyunOSSOperator直接使用即可。步骤:1.创建aliyun-oss-spring-boot-starter模块(依赖管理功能)2.创建aliyun-oss-spring-boot-autoconfigure模块(自动配置功能),在stater中引入模块。
<div>正确答案：</div> <% result.forEach(function(item){ %> <tr> <tr> <td>源地址:<%= item.source %></td> <td>源区域:<%= item.area %></td> <td>目标地址:<%= item.target %></td> <td>目标区域:<%= item.tarea %></td> <td>服务:<%= item.serv %></td> <td>日期:<%= item.time %></td> <td>动作:<%= item.action %></td> <td>状态:<%= item.state %></td> </tr> <br> <% student.forEach(function(ites){ %> <br> <div>您的答案：</div> <tr> <tr> <td>源地址:<%= ites.source %></td> <td>源区域:<%= ites.area %></td> <td>目标地址:<%= ites.target %></td> <td>目标区域:<%= ites.tarea %></td> <td>服务:<%= ites.serv %></td> <td>日期:<%= ites.time %></td> <td>动作:<%= ites.action %></td> <td>状态:<%= ites.state %></td> </tr> <% if(item.source==ites.source) fraction+=10; if(item.area==ites.area) fraction+=10; if(item.target==ites.target) fraction+=10; if(item.tarea==ites.tarea) fraction+=10; if(item.serv==ites.serv) fraction+=10; if(item.time==ites.time) fraction+=10; if(item.action==ites.action) fraction+=20; if(item.state==ites.state) fraction+=20; %> <br><br> 恭喜您，您的分数为： <%= fraction %> <% }) %> <% }) %> 这段代码如果stat相同fration变为红色
06-10
可以通过在代码中添加一个判断语句，来实现在状态相同的情况下将分数变为红色。例如： ``` <div>正确答案：</div> <% result.forEach(function(item){ %> <tr> <td>源地址:<%= item.source %></td> <td>源区域:<%= item.area %></td> <td>目标地址:<%= item.target %></td> <td>目标区域:<%= item.tarea %></td> <td>服务:<%= item.serv %></td> <td>日期:<%= item.time %></td> <td>动作:<%= item.action %></td> <td>状态:<%= item.state %></td> </tr> <br> <% student.forEach(function(ites){ %> <br> <div>您的答案：</div> <tr> <td>源地址:<%= ites.source %></td> <td>源区域:<%= ites.area %></td> <td>目标地址:<%= ites.target %></td> <td>目标区域:<%= ites.tarea %></td> <td>服务:<%= ites.serv %></td> <td>日期:<%= ites.time %></td> <td>动作:<%= ites.action %></td> <td>状态:<%= ites.state %></td> </tr> <% var fraction = 0; %> <% if(item.source==ites.source) fraction+=10; %> <% if(item.area==ites.area) fraction+=10; %> <% if(item.target==ites.target) fraction+=10; %> <% if(item.tarea==ites.tarea) fraction+=10; %> <% if(item.serv==ites.serv) fraction+=10; %> <% if(item.time==ites.time) fraction+=10; %> <% if(item.action==ites.action) fraction+=20; %> <% if(item.state==ites.state) { %> <% fraction+=20; %> <% if(item.state==ites.state && item.state==stat){ %> <% fraction= '<span style="color:red;">'+fraction+'</span>'; %> <% } %> <% } %> <br><br> 恭喜您，您的分数为： <%= fraction %> <% }) %> <% }) %> ``` 这里使用了嵌套的判断语句，如果item.state==ites.state 且 item.state==stat，则将 fraction 变量的值用 <span> 标签包裹，并设置颜色为红色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wucunqi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值