java无穷大

A. java的while循环里 可以使用无穷大么

可以的。

B. java中小数除以0值为无穷大，这是为什么

的确没抛出异常 java里面就是这样规定的
1f/0f结果为正无穷大
1f/-0f结果为负无穷大

C. java语言的基本词汇

1.abstract
abstract 关键字可以修改类或方法。
abstract 类可以扩展（增加子类），但不能直接实例化。
abstract 方法不在声明它的类中实现，但必须在某个子类中重写。
-示例-
public abstract class MyClass{
}
public abstract String myMethod();
-注释-
采用 abstract 方法的类本来就是抽象类，并且必须声明为 abstract。
abstract 类不能实例化。
仅当 abstract 类的子类实现其超类的所有 abstract 方法时，才能实例化 abstract 类的子类。这种类称为具体类，以区别于 abstract 类 。
如果 abstract 类的子类没有实现其超类的所有 abstract 方法，该子类也是 abstract 类。
abstract 关键字不能应用于 static、private 或 final 方法，因为这些方法不能被重写，因此，不能在子类中实现。
final 类的方法都不能是 abstract，因为 final 类不能有子类。

2.boolean
变量的值可以是 true 或 false。
-示例-
boolean valid = true;
if (valid){
<statement>
}
-注释-
boolean 变量只能以 true 或 false 作为值。
boolean 不能与数字类型相互转换。
包含 boolean 操作数的表达式只能包含 boolean 操作数。
Boolean 类是 boolean 原始类型的包装对象类。
3.break
用于提前退出 for、while 或 do 循环，或者在 switch 语句中用来结束 case 块。
-示例-
for (i=0; i<max; i++){
if (<loop finished early>){
break;
}
}
int type = <some value>;
switch (type){
case 1:
<statement>
break;
case 2:
<statement>
break;
default:
<statement>
}
-注释-
break 总是退出最深层的 while、for、do 或 switch 语句。

4.byte
byte 是 Java 原始类型。
byte 可存储在 [-128, 127] 范围以内的整数值。
-示例-
byte b = 124;
-注释-
Byte 类是 byte 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和 MAX_VALUE 常量。
Java 中的所有整数值都是 32 位的 int 值，除非值后面有 l 或 L（如 235L），这表示该值应解释为 long。

5.case
用来标记 switch 语句中的每个分支。
-示例-
int arg = <some value>;
switch (arg){
case 1:
<statements>
break;
case 2:
<statements>
break;
default:
<statements>
break;
}
-注释-
case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用，用于退出 switch 语句。
如果没有 break 语句，执行流将进入所有后面的 case 和/或 default 块。

6.catch
catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。
-示例-
try{
<可能引发异常的块>
}
catch (<java.lang.Exception 或子类> e){
<处理异常 e 的代码>
}
try{
<可能引发其他异常的块>
}
catch (FooException e){
<处理 FooException e 的代码>
}
catch (BarException e){
<处理 BarException e 的代码>
}
try{
<可能引发异常的块>
}
catch (<java.lang.Exception 或子类> e){
<处理异常 e 的代码>
}
finally{
<有异常或无异常情况下都执行的语句>
}
-注释-
开始和结束标记 { 和 } 是 catch 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。
每个 try 块都必须至少有一个 catch 或 finally 子句。
如果某个特定异常类未被任何 catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。

7.char
char 是 Java 原始类型。
char 变量可以存储一个 Unicode 字符。
-示例-
char delimiter = ';';
-注释-
可以使用下列 char 常量：
\b - 空格
\f - 换页
\n - 换行
\r - 回车
\t - 水平制表符
\' - 单引号
\" - 双引号
\" - 反斜杠
\xxx - 采用 xxx 编码的 Latin-1 字符。\x 和 \xx 均为合法形式，但可能引起混淆。
\uxxxx - 采用十六进制编码 xxxx 的 Unicode 字符。
Character 类包含一些可用来处理 char 变量的 static 方法，这些方法包括 isDigit()、isLetter()、isWhitespace() 和 toUpperCase()。
char 值没有符号。

8.class
class 关键字用来声明新的 Java 类，该类是相关变量和/或方法的集合。
类是面向对象的程序设计方法的基本构造单位。类通常代表某种实际实体，如几何形状或人。类是对象的模板。每个对象都是类的一个实例。
要使用类，通常使用 new 操作符将类的对象实例化，然后调用类的方法来访问类的功能。
-示例-
public class Rectangle{
float width;
float height;
public Rectangle(float w, float h){
width = w;
height = h;
}
public float getWidth(){
return width;
}
public float getHeight(){
return height;
}
}

9.continue
continue 关键字用来跳转到 for、while 或 do 循环的下一个迭代。
-示例-
for (i=0; i<max; i++){
<statements>
if (<done with this iteration>){
continue;
}
<statements>
}
-注释-
continue 总是跳到最深层 while、for 或 do 语句的下一个迭代。

10.default
default 关键字用来标记 switch 语句中的默认分支。
-示例-
int arg = <some value>;
switch (arg){
case 1:
<statements>
break;
case 2:
<statements>
break;
default:
<statements>
break;
}
-注释-
default 块没有隐式结束点。break 语句通常在每个 case 或 default 块的末尾使用，以便在完成块时退出 switch 语句。
如果没有 default 语句，其参数与任何 case 块都不匹配的 switch 语句将不执行任何操作。

11.do
do 关键字用于指定一个在每次迭代结束时检查其条件的循环。
-示例-
do{
<statements>
}
while (!found);
-注释-
do 循环体至少执行一次。
条件表达式后面必须有分号。

12.double
double 是 Java 原始类型。
double 变量可以存储双精度浮点值。
-示例-
double ratio = .01;
double diameter = 6.15;
double height = 1.35E03; // 1.35 * 103 或 1350.0
double height = 1e-2; // 1.0 * 10-2 或 0.01
-注释-
由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。
Java 浮点数值可代表无穷大和 NaN（非数值）。Double 包装对象类用来定义常量 MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

13.else
else 关键字总是在 if-else 语句中与 if 关键字结合使用。else 子句是可选的，如果 if 条件为 false，则执行该子句。
-示例-
if (condition){
<statements>
}
else{
<statements>
}

14.extends
extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。
-示例-
public class Rectangle extends Polygon{
}
-注释-
在上例中，Rectangle 类继承 Polygon 类的所有 public 和 protected 变量和方法。
Rectangle 类可以重写 Polygon 类的任何非 final 方法。
一个类只能扩展一个其他类。

15.false
false 关键字代表 boolean 变量的两个合法值之一。
-示例-
boolean isComplete = false;

16.final
final 关键字可以应用于类，以指示不能扩展该类（不能有子类）。
final 关键字可以应用于方法，以指示不能重写任何子类中的方法。
-示例-
public final class MyFinalClass{
}
public class MyClass{
public final String myFinalMethod()
{
<statements>
}
}
-注释-
一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类，final 意味着不能扩展类。
一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法，final 意味着不能重写方法。

17.finally
finally 关键字用来定义始终在 try-catch-finally 语句中执行的块。
finally 块通常包含清理代码，用在部分执行 try 块后恢复正常运行。
-示例-
try{
<可能引发异常的块>
}
catch (<java.lang.Exception 或子类> e){
<处理异常 e 的代码>
}
finally{
<有异常或无异常情况下都执行的语句>
}
-注释-
开始和结束标记 { 和 } 是 finally 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。
每个 try 块都必须至少有一个 catch 或 finally 子句。
如果执行 try 块的任何部分，不论是否出现异常，也不论 try 或 catch 块是否包含 return、continue 或 break 语句，都一定会执行 finally 块中的代码。
如果不出现异常，控件将跳过 try 块，进入 finally 块。
如果在执行 try 块期间出现异常，并且相应的 catch 块包含 break、continue 或 return 语句，控件将首先穿过 finally 块，之后再执行 break、continue 或 return。

18.float
float 是 Java 原始类型。
float 变量可以存储单精度浮点值。
-示例-
float ratio = .01;
float diameter = 6.15;
float height = 1.35E03; // 1.35 * 103 或 1350.0
float height = 1e-2; // 1.0 * 10-2 或 0.01
-注释-
使用此关键字时应遵循下列规则：
Java 中的浮点文字始终默认为双精度。要指定单精度文字值，应在数值后加上 f 或 F，如 0.01f。
由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。
Java 浮点数值可代表无穷大和 NaN（非数值）。Float 包装对象类用来定义常量 MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

}

D. java中怎样表示一个无穷大无穷小

Java中提供了三个特殊的浮点数值：正无穷大、负无穷大、非数，用于表示溢出和出错。

正无穷大：用一个正数除以0将得到一个正无穷大，通过Double或Float的POSITIVE_INFINITY表示。

负无穷大：用一个负数除以0将得到一个负无穷大，通过Double或Float的NEGATIVE_INFINITY表示。

非数：0.0除以0.0或对一个负数开放将得到一个非数，通过Double或Float的NaN表示。

所有的正无穷大的数值都是相等的，所有的负无穷大的数值都是相等；而NaN不与任何数值相等，甚至和NaN都不等。

publicclassjavaLesson5
{
publicstaticvoidmain(String[]args)
{
floataf=5.2325556f;
//下面将看到af的值已经发生改变,显示结果为5.2325554.
System.out.println(af);
doublea=0.0;
doublec=Double.NEGATIVE_INFINITY;
floatd=Float.NEGATIVE_INFINITY;
//将看到float和double的负无穷大是相等的。显示结果为：true。
System.out.println(c==d);
//0.0除以0.0将出现非数。显示结果为：NaN。
System.out.println(a/a);
//两个非数之间是不相等的。显示结果为：false。
System.out.println(a==Float.NaN);
//所有正无穷大都是相等的。显示结果为：true。
System.out.println(6.0/0==555.0/0);
//负数除以0.0将得到负无穷大。显示结果为：-Infinity
System.out.println(-8/a);
//下面代码将抛出除以0的异常。
//System.out.pintln(0/0);
}
}

E. java怎么判断正无穷大

好有意思的问题，如果只是程序上的实现，则通过Java.lang.****.MAX_Value等方法可以判断您的数值是否超过相关数据类型的长度。也就是说，有个标准来判断数值是否超出了限定。实际上，在计算机语言中，不论您的数值怎样使用，都必须有相应的“类型”来承载他，超出了，就会溢出。如果Java的基本数据类型不够用，还有java.math包里还有BigXXX系列的大数据对象类型，可以计算高精准的财务或天文级别数字，看看够不够用？
如果这要不行，就用String将您的数据字符化，直接数位数。如果这也不行，您可以用java.io.ByteStream将您的数据以字节的方式流化，您做个程序数位数就行了，看看多少位数算得上是无穷大？是1亿位还是1兆位？或是更大？不行让计算机运行几年，看看够不够无穷大？

F. java中数值型数据的 无穷大、无穷小 的写法

Integer：
无穷大：Integer.MAX_VALUE; (最大值：2147483647)

无穷小：Integer.MIN_VALUE;(最小值：-2147483648)

Long：
无穷大：Long.MAX_VALUE;（最大值：9223372036854775807）
无穷小：Long.MIN_VALUE;（最小值：-9223372036854775808）

Double：
无穷大：Double.MAX_VALUE;
无穷小：Double.MIN_VALUE;

Float：
无穷大：Float.MAX_VALUE;
无穷小：Float.MIN_VALUE;

G. java中nan与无穷大谁更大

1、java中没有【无穷大】
2、nan 是：not a number，表示这不是一个数字，你说呢？它是用来表示一些错误的运算结果。

H. 我在java中定义了一个二维数组，其中一些值是手动输入的，对于剩下的值有办法让他自动补为无穷大吗

没有你说的直接默认就是无穷大的方法，不过你可以走个曲线同样可以达到你要的目的
首先你要确定这个二维数组有多少行多少列，谨记不可数组越界，然后开始初始化一个由最大值填充的二维数组，然后再动态的改变里面的数值，达到自己的目的。

I. java中，if(result==无穷大)这个语句怎么写

Integer.MAX_VALUE;
Long.MAX_VALUE;
Double.MAX_VALUE;
//用这些，就可以表示正无穷大了

J. java中的符号都有那些。

算数运算符，+-*/(+=，-=，*=，、/*)
p.s. 1/0 => NaN 无穷大。
逻辑运算符，略
转义序列符（例举），\b 退格, \t 制表, \n 换行（制图、一般println）, \r 回车, \" 双引号, \' 单引号
p.s. 取决于os，并不常用。
递增/减 ++, --
赋值 =
比较 >=，<=, ==
位移 <<，>>, >>>
p.s. 图形用到
注释，// 行注释，/* */段注释
类型转换， a = (int)b; //括号。
条件， if()... == a ? true : false //三目运算。
正则表达式， 应用类，用到这再说。
先到这里。