java中的import怎么用,java导入包import怎么写

　　包com . SSS . day . test；导入Java . util . arrays；导入静态Java . lang . math . pi；Class my scanner {/* *使用键盘输入整数* */public static void show(){ } public static void main(string[]args){ system . out . println(pi)；Java . util . date date=new Java . util . date()；Java . SQL . date date 2=new Java . SQL . date(123 l)；/* my scanner sc=new my scanner()；//自带扫描仪没有函数//Java . util . Scanner sc 2=new Java . util . Scanner(system . in)；Scanner sc2=新扫描仪(system . in)；Date Date=new Date()；//部分导入system . out . println(date)；*/} }

import导入的用法

导入与包机制有关。这里先从包说起，再来说说导入和静态导入的作用。

　　00-1010c/c的#include会在编译时将包含的内容添加到程序文件中，而java的import则不同。

　　这里，我们来看看Java包的用处。

　　包名就像我们的姓，类名就像我们的名。与包的从属关系由“.”连接，这就像一个复姓。比如java.lang.String是复姓java.lang，名称String的类别；Java.io.InputStream是一个复姓Java.io，名为InputStream的类别。

　　Java之所以能使用包的机制，原因也很明显。就像我们选名字一样，光是一个学校的同一个班就可能有很多同名同姓的同学。如果不姓，学校在处理学生资料或者互相称呼的时候会很麻烦。同样，世界上Java类的数量大概也比日本人多。如果类不使用包名，当使用同名的不同类时，会造成很大的麻烦。因此，package方法大大减少了类之间的命名冲突。

　　我们可以自己选择Java的包名，不像人家姓，没有太多选择(所以同姓的情况很多)。如果按照孙的规范来选择包名，那么不同人取的包名理论上不会相同(必要时可参考“命名约定”中的相关文章)，也不会出现名称冲突。

　　但是现在问题来了，因为很多包

　　的名称非常的长，在编程时，要使用一个类要将多个包名.类名完全写出，会让代码变得冗长，减低了简洁度。例如

java.io.InputStream is = java.lang.System.in;java.io.InputStreamReader isr= new java.io.InputStreamReader(is);java.io.BufferedReader br = new java.io.BufferedReader(isr);

显得非常麻烦，于是Sun公司就引入了import。

import

import就是在java文件开头的地方，先说明会用到那些类别。

　　接着我们就能在代码中只用类名指定某个类，也就是只称呼名字，不称呼他的姓。

　　首先，在程序开头写：

import java.lang.System;import java.io.InputStream;import java.io.InputStreamReader;import java.io.BufferedReader;

于是我们就可以在程序中这样写到：

InputStream = System.in;InputStreamReader isr = new InputStreamReader(is);BufferedReader br = new BufferedReader(isr);

一个java文件就像一个大房间，我们在门口写着在房间里面的class的姓和名字，所以在房间里面提到某个class就直接用他的名字就可以。例如：

　　System 就是指 java.lang.System，而 InputStream 就是指 java.io.InputStream。

　　但是如果一个java文件里面有多个同个姓，即包名相同的类（例如上面的InputStream，InputStreamReader，BufferedReader都是java.io中的类），我们一一写出显得比较繁杂，所以Sun就让我们可以使用

import java.lang.*;import java.io.*;

表示文件里面说到的类不是java.lang包的就是java.io包的。编译器会帮我们选择与类名对应的包。

　　那我们可不可以再懒一点直接写成下面声明呢？

import java.*;

历史告诉我们，这样是不行的。因為那些类别是姓 java.io 而不是姓 java。就像姓『诸葛』的人应该不会喜欢你称他為『诸』先生吧。这样写的话只会将java包下的类声明，而不不会声明子包的任何类。

这里注意，java.lang包里面的类实在是太常太常太常用到了，几乎没有类不用它的，所以不管你有没有写 import java.lang，编译器都会自动帮你补上，也就是说编译器只要看到没有姓的类别，它就会自动去lang包里面查找。所以我们就不用特别去 import java.lang了。

　　

一开始说 import 跟 #include 不同，是因为import 的功能到此為止，它不像#include 一样，会将其他java文件的内容载入进来。import 只是让编译器编译这个java文件时把没有姓的类别加上姓，并不会把别的文件程序写进来。你开心的话可以不使用import，只要在用到类别的时候，用它的全部姓名来称呼它就行了(就像例子一开始那样)，这样跟使用import功能完全一样。

import的两种导入声明

单类型导入(single-type-import)

　　（例:import java.util.ArrayList; ）

　　按需类型导入(type-import-on-demand)

　　（例:import java.util.*;）

　　有如下属性：

　　java以这样两种方式导入包中的任何一个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.ArrayList;import java.util.*;

多次导入,也可编译通过。编译器会将冗余导入声明忽略.

static import静态导入

在Java程序中，是不允许定义独立的函数和常量的。即什么属性或者方法的使用必须依附于什么东西，例如使用类或接口作为挂靠单位才行（在类里可以挂靠各种成员，而接口里则只能挂靠常量）。

如果想要直接在程序里面不写出其他类或接口的成员的挂靠单元，有一种变通的做法 :

　　将所有的常量都定义到一个接口里面，然后让需要这些常量的类实现这个接口（这样的接口有一个专门的名称，叫(Constant Interface)。这个方法可以工作。但是，因为这样一来，就可以从一个类实现了哪个接口推断出这个类需要使用哪些常量，有会暴露实现细节的问题。
　　

于是J2SE 1.5里引入了Static Import机制，借助这一机制，可以用略掉所在的类或接口名的方式，来使用静态成员。static import和import其中一个不一致的地方就是static import导入的是静态成员，而import导入的是类或接口类型。

　　如下是一个有静态变量和静态方法的类

package com.assignment.test;public class staticFieldsClass {static int staticNoPublicField = 0; public static int staticField = 1; public static void staticFunction(){}}

平时我们使用这些静态成员是用类名.静态成员的形式使用，即staticFieldsClass.staticField或者staticFieldsClass.staticFunction()。

　　现在用static import的方式：

//**精准导入**//直接导入具体的静态变量、常量、方法方法，注意导入方法直接写方法名不需要括号。import static com.assignment.test.StaticFieldsClass.staticField;import static com.assignment.test.StaticFieldsClass.staticFunction;//或者使用如下形式：//**按需导入**不必逐一指出静态成员名称的导入方式//import static com.assignment.test.StaticFieldsClass.*;public class StaticTest { public static void main(String[] args) { //这里直接写静态成员而不需要通过类名调用 System.out.println(staticField); staticFunction(); }}

这里有几个问题需要弄清楚：

　　Static Import无权改变无法使用本来就不能使用的静态成员的约束，上面例子的StaticTest和staticFieldsClass不是在同一个包下，所以StaticTest只能访问到staticFieldsClass中public的变量。使用了Static Import也同样如此。导入的静态成员和本地的静态成员名字相同起了冲突，这种情况下的处理规则，是本地优先。不同的类（接口）可以包括名称相同的静态成员。例如在进行Static Import的时候，出现了两个导入语句导入同名的静态成员的情况。在这种时候，J2SE 1.5会这样来加以处理：如果两个语句都是精确导入的形式，或者都是按需导入的形式，那么会造成编译错误。如果一个语句采用精确导入的形式，一个采用按需导入的形式，那么采用精确导入的形式的一个有效。大家都这么聪明上面的几个特性我就不写例子了。

　　static import这么叼那它有什么负面影响吗？

　　答案是肯定的，去掉静态成员前面的类型名，固然有助于在频繁调用时显得简洁，但是同时也失去了关于这个东西在哪里定义的提示信息，理解或维护代码就呵呵了。但是如果导入的来源很著名（比如java.lang.Math），这个问题就不那么严重了。

按需导入机制

使用按需导入声明是否会降低Java代码的执行效率?

　　绝对不会!

　　一、import的按需导入

import java.util.*;public class NeedImportTest {    public static void main(String[] args) {        ArrayList tList = new ArrayList();    }}

编译之后的class文件 :

//import java.util.*被替换成import java.util.ArrayList//即按需导入编译过程会替换成单类型导入。import java.util.ArrayList;public class NeedImportTest {    public static void main(String[] args) {        new ArrayList();    }}

二、static import的按需导入

import static com.assignment.test.StaticFieldsClass.*;public class StaticNeedImportTest {    public static void main(String[] args) {        System.out.println(staticField);        staticFunction();    }}

上面StaticNeedImportTest 类编译之后 :

//可以看出 ： //1、static import的精准导入以及按需导入编译之后都会变成import的单类型导入import com.assignment.test.StaticFieldsClass;public class StaticNeedImportTest {    public static void main(String[] args) {    //2、编译之后“打回原形”，使用原来的方法调用静态成员        System.out.println(StaticFieldsClass.staticField);        StaticFieldsClass.staticFunction();    }}

附加

这是否意味着你总是可以使用按需导入声明?

　　是,也不是!

　　在类似Demo的非正式开发中使用按需导入声明显得很有用。

　　然而,有这四个理由让你可以放弃这种声明:

　　编译速度：在一个很大的项目中，它们会极大的影响编译速度.但在小型项目中使用在编译时间上可以忽略不计。命名冲突：解决避免命名冲突问题的答案就是使用全名。而按需导入恰恰就是使用导入声明初衷的否定。说明问题：毕竟高级语言的代码是给人看的，按需导入看不出使用到的具体类型。无名包问题：如果在编译单元的顶部没有包声明，Java编译器首选会从无名包中搜索一个类型，然后才是按需类型声明。如果有命名冲突就会产生问题。Sun的工程师一般不使用按需类型导入声明.这你可以在他们的代码中找到:

　　在java.util.Properties类中的导入声明:

import java.io.IOException;import java.io.PrintStream;import java.io.PrintWriter;import java.io.InputStream;import java.io.OutputStream;import java.io.Reader;import java.io.Writer;import java.io.OutputStreamWriter;import java.io.BufferedWriter;import java.security.AccessController;import java.security.PrivilegedAction;

可以看到他们用单类型导入详细的列出了需要的java.io包中的具体类型。

　　以上为个人经验，希望能给大家一个参考，也希望大家多多支持盛行IT。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

目录

import导入的用法

import

import的两种导入声明

static import静态导入

按需导入机制

附加

相关文章阅读