有些人写了一阵子 Java，可是对於 Java 的 package 跟 import 还是不 太了解很多人以?樵?悸 .java 档案中的 import 会让编译器把所 import 的程式通通写到编译好的 .class 档案中，或是认? import 跟 C/C++ 的
include 相似，实际上，这是错误的观念。
让我们先了解一下，Java 的 package 到底有何用处。其实，package 名称就像是我们的姓，而 class 名称就像是我们的名字 。package 名称有很多 . 的，就好像是复姓。比如说 java.lang.String，就 是复姓 java.lang，名字? String 的类别；java.io.InputStream 则是复姓 java.io，名字? InputStream 的类别。
Java 会使用 package 这种机制的原因也非常明显，就像我们取姓名一样 ，光是一间学校的同一届同学中，就有可能会出现不少同名的同学，如果不取 姓的话，那学校在处理学生资料，或是同学彼此之间的称呼，就会发生很大的
困扰。相同的，全世界的 Java 类别数量，恐怕比台湾人口还多，而且还不断 的在成长当中，如果类别不使用套件名称，那在用到相同名称的不同类别时，
就会?生极大的困扰。幸运的是，Java 的套件名称我们可以自己取，不像人 的姓没有太大的选择 ( 所以有很多同名同姓的 )，如果依照 Sun 的规范来取 套件名称，那理论上不同人所取的套件名称不会相同 ( 请参阅 "命名惯例"
的相关文章 )，也就不会发生名称?突的情况。可是问题来了，因?楹芏嗵准?拿?品浅５某ぃ?谛闯淌绞保?岫啻蚝枚
字，花费不少时间，比如说：
java.io.InputStream is = java.lang.System.
java.io.InputStreamReader isr= new java.io.InputStreamReader(is);
java.io.BufferedReader br = new java.io.BufferedReader(isr);
在zz．java中，因为引入了包a中的所有类，所以使用起来就好像是在同一个包中一样(当然首先要满足访问权限，这里假定可以访问)。
&&& 在程序中，可以引入包的所有类或若干类。要引入所有类时，可以使用通配符“*”，如：
&&& import java．lang．*；
实在是不美观又麻烦。於是，Sun 想了一个办法，就是 import。
这个 import 就是在程式一开头的时候，先说明程式中会用到那些类别的
简称，也就是只称呼名字，不称呼他的姓。首先，在档案开头写：
&&&&& import java.lang.S
&&&& import java.io.InputS
&&&& import java.io.InputStreamR
&&&& import java.io.BufferedR
这几行说明了这四个姓名的类别，在程式中只用他的名字来称呼，所以当程式
中提到 System 就是指 java.lang.System，而 InputStream 就是指
java.io.InputStream，依此类推。於是原来的程式就变成：
&&&&& InputStream = System.
&&&& InputStreamReader isr = new InputStreamReader(is);
&&&& BufferedReader br = new BufferedReader(isr);
这样看起来是不是清爽多了呢？如果这些类别用的次数很多，那就更能体会到
import 的好处了。可是这样还是不够，因?槔潦侨说奶煨裕?故腔嵊腥司醯
打太多 import 了也很浪费时间，於是 Sun 又提供了一个方法：
&&&&& import java.lang.*;
&&&& import java.io.*;&
意思就是，等一下程式中提到的没有姓名的类别，不是姓 java.lang，就是姓
java.io，如果这两个?面有同样名字的类别，而不幸的你又只用名字称呼这
个类别，那编译器仍然会跟你抱怨，因?樗?故遣恢?滥闼档恼飧隼啾鹬改且
个姓的类别。那可不可以再懒一点呢，只写：
&&&&& import java.*;&
?v史告诉我们，人可以懒，但不能太懒，这样是不行的。因?槟切├啾鹗切
java.io 而不是姓 java。就像姓『诸葛』的人应该不会喜欢你称他?椤褐睢
?樯觞N我一开始说 import 跟 #include 不同呢？因? import 的功能
到此?橹梗??幌 #include 一样，会将档案内容载入进来。import 只是请
编译器帮你打字，让编译器把没有姓的类别加上姓，并不会把别的档案的程
式码写进来。如果你想练习打字，可以不要使用 import，只要在用到类别的
时候，用它的全部姓名来称呼它就行了(就像例子一开始那样)，跟使用
import 完全没有甚?两样。
另外，虽然人不可以太懒，但是 Sun 还是帮我们多偷了一点懒。因?
java.lang 这个套件实在是太常太常太常用到了，几乎没有程式不用它的，
所以不管你有没有写 import java.，编译器都会自动帮你补上，也就
是说编译器只要看到没有姓的类别，它就会自动去 java.lang ?面找找看，
看这个类别是不是属於这个套件的。所以我们就不用特别去
import java.lang 了。
package xx.bb.
　　说明这个.java编译单元中的所有类都放到xx.bb.aa这个package里面。而对应的，必须把这个.java文件放在xx目录下bb目录下的aa目录里面。如果一个.java文件没有任何package语句，那么这个.java里面的所有类都在package的"/"下面，也称之为default package。可以看出你一般从任何java教科书上写的第一个hello world程序的那个类是在defaultpackage里面的。有了package语句，情况就复杂一点了。这个编译单元.java必须放在package名对应的目录之下。而生成的class文件也要放在对应的目录结构之下才能正常运作。
　　例如：
/* A.java */
　　package aaa.bbb.
　　public class A{
　　B b=new B();
　　/* B.java*/
　　package aaa.bbb.
　　public class B{}
　　编译时候怎么填参数呢？我根据package+文件名的格式来写，
javac aaa.bbb.ccc.A.java
　　漂亮吧？可惜不工作。非要使用合法的路径名才行：
javac aaa/bbb/ccc/A.java
　　但是你发现生成的class丢失了目录结构，直接出现在当前目录下……
　　最好的方式是
　javac -d bin aaa/bbb/ccc/A.java
　　这样就会在当前目录的bin目录下看到完整的目录结构以及放置妥当的class文件。
　　package与classpath不得不说的事
　　对于java来讲，所有需要的程序和资源都要以package的形式来组织和读取。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
import导入声明可分为两中:
1&单类型导入(single-type-import)
import java.util.ArrayL
java.util.ArrayList。
　　而用了import java.util.ArrayL的话
　　以后代码中写ArrayList就可以了，省事。import可以使用通配符*，*代表某package下所有的class，不包括子目录。
　import java.awt.*
　　不等于
　　import java.awt.*
　　import java.awt.event.*
　　如果你要简写java.awt.event下和java.awt下的类，你不能偷懒，两个都要import。
2&按需类型导入(type-import-on-demand)
import java.util.*;
以这样两种方式导入包中的任何一个public的类和接口(只有public类和接口才能被导入)
*导入声明仅导入类型而不导入子包;这就是为什么称它们为单类型导入和按需类型导入声明的原因.
*导入的类或接口的简名(simple name)具有编译单元作用域.这表示该类型简名可以在导入语句所在的编译单元的任何地方使用.这并不意味着你可以使用该类型所有成员的简名,而只能使用类型自身的简名.
例如: java.lang包中的public类都是自动导入的,包括Math和System类.但是,你不能使用简名PI()和gc(),而必须使用Math.PI()和System.gc().你不需要键入的是java.lang.Math.PI()和java.lang.System.gc().
程序员有时会导入当前包或java.lang包,这是不需要的,因为当前包的成员本身就在作用域内,而java.lang包是自动导入的.java编译器会忽略这些冗余导入声明(redundant import declarations).即使像这样
import java.util.ArrayL
import java.util.*;
多次导入,也可编译通过.编译器会将冗余导入声明忽略.
使用按需导入声明是否会降低Java代码的执行效率?绝对不会!
Java编译器产生的类文件仅包含编译单元实际使用到的类或接口的符号引用.
这是否意味着你总是可以使用按需导入声明?是,也不是!
在类似Demo的非正式开发中使用按需导入声明显得很有用.
然而,有这四个理由让你可以放弃这种声明:
1&编译速度:在一个很大的项目中,它们会极大的影响编译速度.但在小型项目中使用在编译时间上可以忽略不计.
2&命名冲突:解决避免命名冲突问题的答案就是使用全名.而按需导入恰恰就是使用导入声明初衷的否定.
3&说明问题:全名的使用是自说性的.毕竟高级语言的代码是给人看的.
4&无名包问题:如果在编译单元的顶部没有包声明,Java编译器首选会从无名包中搜索一个类型,然后才是按需类型声明.如果有命名冲突就会产生问题.
Sun的工程师一般不使用按需类型导入声明.这你可以在他们的代码中找到:
在java.util.Properties类中的导入声明:
import java.io.IOE
import java.io.printS
import java.io.printW
import java.io.InputS
import java.io.BufferedR
import java.io.BufferedW
import java.util.H
你可以看到有趣的是,她连java.util.Hashtable也导入,这可是在当前包中啊!
&在Java中，若想利用包的特性，可使用引入(import)语句告诉编译器要使用的类所在的位置。实际上，包名也是类名的一部分。例如，如果abc．FinanceDept包中含有Employee类，则该类可称作abc．FinanceDept．Employee。如果使用了import语句，再使用类时，包名可省略，只用Employee来指明该类。
&&& 引入语句的格式如下：
&&& import pkgl[．pkg2[．pkg3…]]．(类名I g-)；
&&& 例5-18
&&& 假设有一个包a，在a中的一个文件内定义了两个类xx和YY，其格式如下：
&&& package a；
&&& c|ass xx{
&&& class YY{
&&& 当在另外一个包b中的文件ZZ．java中使用a中的类时，语句形式如下：
&&& //zz．java
&&& package b；
&&& import a．*；
&&& class zz extends XX {
&&& YY Y；
&&& 在zz．java中，因为引入了包a中的所有类，所以使用起来就好像是在同一个包中一样(当然首先要满足访问权限，这里假定可以访问)。
&&& 在程序中，可以引入包的所有类或若干类。要引入所有类时，可以使用通配符“*”，如：
& import java．lang．*；
&&& 引入整个包时，可以方便地访问包中的每一个类。这样做，语句写起来很方便，但会占用过多的内存空间，而且代码下载的时间将会延长。初学者完全可以引入整个包，但是我们建议在了解了包的基本内容后，实际用到哪个类，就引入哪个类，尽量不造成资源的浪费。在向java中导入项目的时候用到import com.sun.java_cup.internal.internal_但是，这个是错误的，应该怎么解决 - ITeye问答
RT，谢谢了，希望能得到指点，谢谢
问题补充：7454103 写道不，他是个类
在api文档里你是查不到的，因为它并不是基础api所提供的，但是这个类的确是在rt.jar中。你可以到oracle的官方网站上查查看。
谢谢你的回复，但我去rt.jar这个包里看了，并没有这个类，怎么解决呢？是不是jdk版本的问题？
采纳的答案
引用
谢谢你的回复，但我去rt.jar这个包里看了，并没有这个类，怎么解决呢？是不是jdk版本的问题？
呵呵& 我帮你找到了！
你好好找找 tomcat6.0 里面也有！
实在找不到！ 明天我给你发！ 你可以Q 我& 我Q
一起研究 一起进步哈！！！
不，他是个类
在api文档里你是查不到的，因为它并不是基础api所提供的，但是这个类的确是在rt.jar中。你可以到oracle的官方网站上查查看。
已解决问题
未解决问题Java中Math类常用函数总结 - 推酷
Java中Math类常用函数总结
Java中比较常用的几个数学公式的总结：
//取整，返回小于目标函数的最大整数,如下将会返回-2
Math.floor(-1.8)；
//取整，返回发育目标数的最小整数
Math.ceil()
//四舍五入取整
Math.round()
//计算平方根
Math.sqrt()
//计算立方根
Math.cbrt()
//返回欧拉数e的n次幂
Math.exp(3);
//计算乘方,下面是计算3的2次方
Math.pow(3,2);
//计算自然对数
Math.log();
//计算绝对值
Math.abs();
//计算最大值
Math.max(2.3,4.5);
//计算最小值
Math.min(,);
//返回一个伪随机数，该数大于等于0.0并且小于1.0
Math.random
Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（以当前时间作为种子），另一个构造器需要程序员显示的传入一个long型整数的种子。
Random比Math的random（）方法提供了更多的方式来生成各种伪随机数。
import java.util.A
import java.util.R
public class RandomTest {
* @param args
public static void main(String[] args) {
// TODO Auto-generated method stub
Random rand = new Random();
System.out.println(&随机布尔数& + rand.nextBoolean());
byte[] buffer = new byte[16];
rand.nextBytes(buffer);
//生产一个含有16个数组元素的随机数数组
System.out.println(Arrays.toString(buffer));
System.out.println(&rand.nextDouble()& + rand.nextDouble());
System.out.println(&Float浮点数& + rand.nextFloat());
System.out.println(&rand.nextGaussian& + rand.nextGaussian());
System.out.println(&& + rand.nextInt());
//生产一个0～32之间的随机整数
System.out.println(&rand.nextInt(32)& + rand.nextInt(32));
System.out.println(&rand.nextLong& + rand.nextLong());
为了避免两个Random对象产生相同的数字序列，通常推荐使用当前时间作为Random对象的种子，代码如下：
Random& rand = new Random(System.currentTimeMillis());
中引入了ThreadLocalRandom
在多线程的情况下使用ThreadLocalRandom的方式与使用Random基本类似，如下程序&片段示范了ThreadLocalRandom的用法：
首先使用current()产生随机序列之后使用nextCXxx()来产生想要的伪随机序列
ThreadLocalRandom trand= ThreadLocalRandom.current();
int val = rand.nextInt(4,64);
产生4～64之间的伪随机数
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致java 数学公式这种复杂的公式 在java里面怎么编，&需要在java里面 运用哪些数学方法？是一步一步算吗？不知道math类怎么用。
这个公式不复杂啊，统共就会用到Math里面的求次方的pow函数了。因为这个属于java.lang包下的，调用方法就是Math.pow(a,b)，相当于a^b了。当然是一步一步算了，Java不是matlab，还不支持符号运算。double的精度应该够你用了，如果要用任意精度的运算，才考虑用java.math包下的BigDecimal,&BigInteger那些类，一般不需要。你的公式用java写，如下：double&&loanamount,&monthlyInterestRint&numOfY//上述变量的赋值&（略）double&result&=&(loanamount*monthlyInterestRate)/(1-1/Math.pow(1+monthlyInterestRate,&numOfYears*12));
为您推荐：
扫描下载二维码}