ppt课件动手动脑实际验证

1关于double精度

　　源代码：
public class Doublejingdu {
public static void main(String[] args) {
System.out.println("0.05+0.01="+(0.05+0.01));
System.out.println("1.0-0.42="+(1.0-0.42));
System.out.println("4.015*100="+(4.015*100));
System.out.println("123.3/100="+(123.3/100));
}
}

实验结果：

0.05+0.01=0.060000000000000005
1.0-0.42=0.5800000000000001
4.015*100=401.49999999999994
123.3/100=1.2329999999999999

原因：

原因在于我们的计算机是二进制的。浮点数没有办法是用二进制进行精确表示。我们的CPU表示浮点数由两个部分组成：指数和尾数，这样的表示方法一般都会失去一定的精确度，有些浮点数运算也会产生一定的误差。如：2.4的二进制表示并非就是精确的2.4。反而最为接近的二进制表示是 2.3999999999999999

Double:100000000100000000000000000000000000000000000000000000000000000

Float:1000001000000000000000000000000

对于输出结果分析如下。对于都不 double 的二进制左边补上符号位 0 刚好可以得到 64 位的二进制数。根据double的表 示法，分为符号数、幂指数和尾数三个部分如下：

0 10000010111 0011000101100111100101110000000000000000000000000000

对于 float 左边补上符 号位 0 刚好可以得到 32 位的二进制数。 根据float的表示法， 也分为 符号数、幂指数和尾数三个部分如下 ：

0 10010111 00110001011001111001100

绿色部分是符号位，红色部分是幂指数，蓝色部分是尾数。

对比可以得出:符号位都是 0 ，幂指数为移码表示,两者刚好也相等。唯一不同的是尾数。

在 double 的尾数 为： 001100010110011110010111 0000000000000000000000000000 ，省略后面的零，至少需要24位才能正确表示 。

而在 float 下面尾数 为： 00110001011001111001100 ，共 23 位。

为什么会这样？原因很明显，因为 float尾数 最多只能表示 23 位，所以 24 位的 001100010110011110010111 在 float 下面经过四舍五入变成了 23 位的 00110001011001111001100 。所以 20014999 在 float 下面变成了 20015000 。
也就是说 20014999 虽然是在float的表示范围之内，但 在 IEEE 754 的 float 表示法精度长度没有办法表示出 20014999 ，而只能通过四舍五入得到一个近似值。

浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。往往产生误差不是 因为数的大小，而是因为数的精度。因此，产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运 算的时候要特别小心。

2.枚举

public class EnumTest {

public static void main(String[] args) {
Size s=Size.SMALL;
Size t=Size.LARGE;
//s和t引用同一个对象？
System.out.println(s==t); //
//是原始数据类型吗？
System.out.println(s.getClass().isPrimitive());
//从字符串中转换
Size u=Size.valueOf("SMALL");
System.out.println(s==u); //true
//列出它的所有值
for(Size value:Size.values()){
System.out.println(value);
}
}

}
enum Size{SMALL,MEDIUM,LARGE};

输出结果：

false
false
true
SMALL
MEDIUM
LARGE

3.求和

package text;

//An addition program

import javax.swing.JOptionPane; // import class JOptionPane

public class Addition {
public static void main( String args[] )
{
String firstNumber, // first string entered by user
secondNumber; // second string entered by user
int number1, // first number to add
number2, // second number to add
sum; // sum of number1 and number2

// read in first number from user as a string
firstNumber =
JOptionPane.showInputDialog( "Enter first integer" );

// read in second number from user as a string
secondNumber =
JOptionPane.showInputDialog( "Enter second integer" );

// convert numbers from type String to type int
number1 = Integer.parseInt( firstNumber );
number2 = Integer.parseInt( secondNumber );

// add the numbers
sum = number1 + number2;

// display the results
JOptionPane.showMessageDialog(
null, "The sum is " + sum, "Results",
JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); // terminate the program
}
}

4.键盘输入

源代码

package text;
/**
@version 1.10 2004-02-10
@author Cay Horstmann
*/

import java.util.*;

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

// get first input
System.out.print("What is your name? ");
String name = in.nextLine();

// get second input
System.out.print("How old are you? ");
int age = in.nextInt();

/* int i;
String value="100";
i=Integer.parseInt(value);
i=200;
String s=String.valueOf(i);*/

// display output on console
System.out.println("Hello, " + name + ". Next year, you‘ll be " + (age + 1));

}
}

5.使用BigDecimal类

源代码

import java.math.BigDecimal;

public class TestBigDecimal
{
public static void main(String[] args)
{
BigDecimal f1 = new BigDecimal("0.05");
BigDecimal f2 = BigDecimal.valueOf(0.01);
BigDecimal f3 = new BigDecimal(0.05);
System.out.println("下面使用String作为BigDecimal构造器参数的计算结果：");
System.out.println("0.05 + 0.01 = " + f1.add(f2));
System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
System.out.println("0.05 / 0.01 = " + f1.divide(f2));
System.out.println("下面使用double作为BigDecimal构造器参数的计算结果：");
System.out.println("0.05 + 0.01 = " + f3.add(f2));
System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
System.out.println("0.05 / 0.01 = " + f3.divide(f2));
}
}

5.选择结构

import java.math.BigDecimal;

public class TestBigDecimal
{
public static void main(String[] args)
{
BigDecimal f1 = new BigDecimal("0.05");
BigDecimal f2 = BigDecimal.valueOf(0.01);
BigDecimal f3 = new BigDecimal(0.05);
System.out.println("下面使用String作为BigDecimal构造器参数的计算结果：");
System.out.println("0.05 + 0.01 = " + f1.add(f2));
System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
System.out.println("0.05 / 0.01 = " + f1.divide(f2));
System.out.println("下面使用double作为BigDecimal构造器参数的计算结果：");
System.out.println("0.05 + 0.01 = " + f3.add(f2));
System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
System.out.println("0.05 / 0.01 = " + f3.divide(f2));
}
}

原文地址：https://www.cnblogs.com/zlc364624/p/9750630.html

时间： 2024-10-16 20:16:10

ppt课件动手动脑实际验证的相关文章

动手动脑（验证）

运行EnumTest.java 结论:枚举不属于原始数据类型,它的每个具体值都引用一个特定的对象.相同的值则引用同一个对象.对于枚举类型的变量,“==”和equals()方法执行的结果是等价的. 运行TestDouble.java 结果:使用double类型的数值进行计算, 其结果是不精确的. ppt第三个 第一个是字符串链接 第二个是加法

Java中常用的异常处理情况课件动手动脑

1:请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识. import javax.swing.*; class AboutException { public static void main(String[] a) { int i=1, j=0, k; k=i/j; try { k = i/j; // Causes division-by-zero exception //throw new Exception("Hello.

动手动脑例子验证

由此可以发现,double类型的数据并不是精确的,有一个误差.

06-继承与多态（动手动脑与验证）

一.继承条件下构造方法的调用 测试代码一: 1 class Grandparent 2 { 3 public Grandparent() 4 { 5 System.out.println("GrandParent Created."); 6 } 7 public Grandparent(String string) 8 { 9 System.out.println("GrandParent Created.String:" + string); 10 } 11 }

完成课件中的动手动脑的或需要验证的相关内容。

信1605-3 于丁一  20163578 为什么子类的构造方法在运行之前,必须调用父类的构造方法?能不能反过来?为什么不能反过来?   构造函数的主要作用是初始化,因为子类继承了父类,所以父类有的东西子类也有,所以在子类的构造方法运行之前必须调用父类的构造方法.不能反过来,因为子类继承父类所以要有个顺序来执行,先有父类再有子类,所以不能反过来.   请自行编写代码测试以下特性(动手动脑): 在子类中,若要调用父类中被覆盖的方法,可以使用super关键字.     //信1605-3 于丁一 2

03-方法ppt动手动脑问题及课后实验性问题总结

一.如何不使用static来进行调用函数? 1.自己定义的不需要都是static,但是要在主函数中调用就需要static了,因为main是静态 的,在类加载时就加载了.如果想用又不加可以吧自己写的方法写在一个类中调用就行.主函数一般也只是调用不做数据处理. 2.static方法是在编译的时候确定的,在类装入内存的时候也同时装入内存了.而非static方法是在类的实例化的时候装入内存的,其必须依赖于类的实例. 实例在装入堆栈的时候是会附加上指向method area的指针,所以可以在非静态方法中调

java学习——关于java课件上动手动脑问题简单的分析

问题一:关于以下的代码为什么会产生错误的问题的简单分析. 第一个动手动脑提供了一下的代码,可以发现,在Foo的这个类中只定义了一个Foo(int)类型的构造函数,在之前的学习工程中,我们并没有接触到java的构造函数的声明过程,因此,在类中没有书写构造函数的方法的时候,编译器默认继承Object类,并在编译的时候会产生一个参数为空的构造函数,然而在定义的Foo这个类的时候,给予了一个Foo(int)类型的构造方法,所以在上述Test的调用过程中,obj1并不能够调用到new Foo()这个构造函

动手动脑之多态与异常处理

动手实验一:下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么? m=d; d=m; d=(Dog)m; d=c; c=(Cat)m; 先进行自我判断,得出结论后,运行TestCast.java实例代码,看看你的判断是否正确: java中基类对象不能当做子类对象使用,需要用强制转换来实现,子类对象变量=(子类名)基类对象名:错误的代码是d=m; d=c; 错误原因:类型不匹配:不能从 Mammal 转换为 Dog. 动手实验二:运行以下测试代码 上边的程序运行结果是什么?.你如

异常处理---动手动脑及课后作业

动手动脑1:请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识. 源码: import javax.swing.*; class AboutException { public static void main(String[] a) { int i=1, j=0, k; k=i/j; try { k = i/j; // Causes division-by-zero exception //throw new Exception