Java的package和import机制讲解，让你轻松写代码

与机制相关，这里先从入手，再讲述以及 的作用。

C/C++ 里的 # 会于编译时，将其所包含的内容添加到程序文件之中，然而，Java 的情况并非如此，意思有所不同，存在差异 。

#

这里我们先了解一下Java 的 到底有何用处。 #

姓名如我们的姓呀，那-class名称就似我们的名字呢。和的附属之关系借“.”来连接哟，这仿若复姓呀。比如说java.lang.便是复姓java.lang，名字是 的类别哒；java.io.则是复姓java.io，名字是 的类别哒　。

Java采用这种机制的缘由特别 ，恰似我们获取姓名那般，仅在一所学校的同一届学生里，便极有可能涌现不少重名的学生，倘若并非基于姓氏来区分，那么学校在处理学生资料之际，或者同学相互之际的称呼方面，便定会遭遇相当大的麻烦。同样的状况下反观 范围内的 Java 类数量，其规模恐怕要多于日本人的数量，如果类别未采用名称予以区分，那么当涉及到使用相同名称的不同类时，必然会引发极为严重的困扰。所以借助这种方式，能够极大程度地减少类之间的命名冲突 。 #

Java的名称，我们能够自行选取，与人的姓不一样，没有太大的选择余地，所以出现了许多同名同姓这种情况，要是依照Sun的规范去取套件名称，那么理论上不同人所取的套件名称不会相同，需要的话请参阅“命名惯例”的相关文章，如此一来也就不会发生名称冲突的状况。

然而紧接着问题就出现了，由于诸多名称极为冗长，在进行编程操作的时候，若要运用一个类，就必须把多个包名以及类名悉数完整地写出来，如此一来会致使代码变得繁杂冗长，进而降低了简洁程度。比如说。 #

java.io.InputStream，is被赋值为，java.lang.System.in 。
创建一个对象，该对象是通过将一个输入流对象，使用字符集进行解码后生成的，表示输入流读取器，把这个对象赋值给一个变量，变量的类型是输入流读取器类型 ，这个变量的名称是isr ，而那个输入流对象是is ，。
针对输入流读取器创建一个缓冲读取器，缓冲读取器的实例是通过将属于输入流读取器的实例作为参数传入来进行创建的，而上述语句所进行的操作就是，把输入流读取器的实例当作参数用于实例初始化去创建上述提到的。
 
#
 

#

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

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

随后，在代码里，我们能够凭借类名来指明某一个类，即仅仅提及名字，而不提及它的姓 。

#

首先，在程序开头写： #

import java.lang.System;
import java.io.InputStream;
导入，Java，输入流读取器，类。，标点符号。
导入，Java，io，缓冲读取器，包，里面的，那个，类，名，叫，BufferedReader，句号。
 
#
 

#

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

InputStream = System.in;
用于输入流读取的字符流读取器对象isr，被赋予了一个基于输入流is所创建的新实例 。
首先，创建一个BufferReader ，然后，将它赋值为，一个通过对isr进行创建而得到的对象 。
 
#
 

一个Java文件好似一个大房间，我们于门口写出在房间里头的class的姓以及名字，因而在房间里头提及某个class便直接采用他的名字就行。比如：

#

换言之，所指的乃是java.lang.这一项，并且也就是说另外所指的是java.io.这一项。 #

可是倘若在一个Java文件当中存在多个有着相同“姓”的情况，也就是包名相同的类，比如上面所提及的，皆是Java.io里的类，我们逐个去写出的话会显得颇为繁杂，因而Sun便让我们能够去使用。

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

意味着那文件之中所提及的类，要么并非属于java.lang包，而是属于java.io包，要么反之。编译程序会为我们挑选出与类名相对应的那一个包来 。

#

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

import java.*;
 # 

历史向我们传达了这样的信息，如此这般是不可行的。因为那些特定的类别，其归属是姓java.io ，而非姓java 。这情形好比姓『诸葛』的人士，大概是不会乐意你称呼他作『诸』先生的吧。若按这样的方式去书写，那只会对java包下的类进行声明，却不会去声明子包的任何一个类。

#

这里需留意，Java.lang包当中的类，那真的是极其极其极为常用，几乎不存在不用它的类，所以不论你有没有书写Java.lang，编译器都会自动予以补充，也就是说，编译器只要瞧见没有起始标识的类别，它就会自动前往lang包里面去寻觅，所以我们就无需特意去添加Java.lang了。 #

当初讲，跟#不一样，缘由是的作用就此截止，它不像#那般，会把别的java文件里的内容加载进来。仅仅是在编译器编译这个java文件之际，给没有姓的类别添上姓而已，并非将别的文件程序写入。倘若你乐意可不采用，只要在用到类别的时刻，以它的完整姓名去称呼它便可(如同例子起始那般)，如此与使用功能全然相同。 #

的两种导入声明 #

有如下属性：

#

Java 导入包之中任意一个的类，还有接口，是以这样两种方式，且只有类以及接口才能够被导入 。 #

上面提及，导入声明仅仅导入声明目录之下的类，却不会导入子包，这便是为何把它们称作类型导入声明的缘由，用逗号隔开，确保句末有标点符号。

#

要导入的类或者接口的那个简名，也就是name，它是有着编译单元作用域的。这所表达的意思是，该类型的简名是能够在导入语句所处的编译单元的任何一处地方去使用的。然而，这可并不等同于你就能够去使用该类型所有成员的简名，实际上只能使用类型自身的那个简名。 #

Java.lang包里头的类都是自动给导入进来的,其中涵盖了Math以及类.然而,咱没办法去使用它们成员的简名PI()还有gc(),而是得用Math.PI()以及.gc().咱不需要键入的是java.lang.Math.PI()以及java.lang..gc()。 #

程序员有时会导入当前包，或者导入java.lang包，可这是不需要的，为啥呢？因为当前包的成员自身就在作用域内呀，并且java.lang包是自动导入的。java编译器会忽略这些冗余导入声明 。即便像这样。

#

java.util.; #

java.util.*;

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

静态导入

在Java程序当中，是不被允许去定义独立的函数以及常量的，也就是，究竟什么属性或者方法方面的使用必须要依附于某些东西呢，举例来说，使用类或者接口当作挂靠单位才可以实现（在类里边可以挂靠各种各样的成员，然而对于接口而言，里边则仅仅只能挂靠常量）。 #

若想于程序之中，不将其他类或者接口的成员挂靠单元书写出来，存在一种变通办法， :。

#

将全部的常量都界定于一个接口之中，继而让那些需要这些常量的类去实现此接口，这般的接口拥有一个特定称呼，称作(“ ”)，此方法能够运作，然而，鉴于如此一来，能够依据“一个类实现了哪个接口”推导出“这个类需要运用哪些常量”，存在“会暴露实现细节”的状况 。 #

于是，在J2SE 1.5当中，引入了“ ”这样一种机制，通过借助这一机制，能够以略掉所在的类或者接口名的途径，来运用静态成员。并且，和其中一个存在不一致的地方在于留学之路，导入的是静态成员，然而导入的却是类或接口类型。 #

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

package com.assignment.test;
公共类，静态字段类 ，这是一个类 ，名为静态字段类 ，它是公共的 。
静态的整型变量，名为静态非公共字段，其初始值为0。
定义一个公共的静态方法，该方法返回一个整型数值，此数值是一个被声明为静态的字段的值，该字段的值被设定为1 ，。
公开静态的 void 此静态功能（这里的“此”指代函数，即 staticFunction），它是空空的呢，没有返回量，仅仅是这么定义着的哟，{}。
}
 # 

平常的时候，我们去运用这些静态成员，采用的是类名.静态成员这样的形式来运用，也就是.或者.() 。 #

现在用 的方式：

//**精准导入**
要直接导入那些具体的静态变量、常量以及方法哟，得留意导入方法呢，直接写方法名就好啦，不需要括号哒。
让静态字段所属的类导入静态字段，该类位于特定包中，此包与测试相关，测试是作业的一部分，该静态字段就在这个类里，这个类名为静态字段类，现在要导入这个静态字段，用语句来实现，语句是import static，后面跟着包。
import static，com.assignment.test.StaticFieldsClass中的staticFunction ，进行导入，。逗号隔开，。句末得有标点符号，。
//或者使用如下形式：
//**按需导入**不必逐一指出静态成员名称的导入方式
什么意思呢，你所提供的这个内容并不是一个完整的、可以正常理解其确切意图的句子呀，它看起来更像是一段代码片段，只是单纯的代码片段没法按照要求进行改写呢。你确定要改写的就是这么个内容本身吗。
public class StaticTest {
公共的静态的无效的主方法，其参数为字符串数组形式的参数列表 ，它们被包含在一对中括号里 。
	    //这里直接写静态成员而不需要通过类名调用
执行标准输出打印时，打印的是静态字段的值，该静态字段名为staticField 。
        staticFunction();
    }
}
 
#
 

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

没权力去改变那没办法使用的、原本便不能使用的静态成员的约束条件，上面所举例子当中的二者之和并非处于同一个包里面，所以仅仅能够访问到其中的变量，就算使用了也还是这样的情况。

#

假如导入的静态成员跟本地的静态成员，二者名字一样从而引发了冲突，针对这样的情形下的处理规则呢，是“本地优先” 。 #

互异的类（接口）能够涵盖 name 一样的静态成员。举例而言，于开展期间，出现了“两条导入语句导入相同名称的静态成员”这般的状况。处于此情形之际，J2SE 1.5会如此予以处理： #

假设两个语句，它们要么都是精确导入的形式，要么都是按需导入的形式，在此情形下，就会致使编译错误。

要是一个语句运用的是精确导入的形式，另一个运用的是按需导入的形式，那么运用精确导入形式的那个是有效的。

大家都这么聪明上面的几个特性我就不写例子了。 #

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

确定的答复是这样的，将静态成员前边的类型名称予以去除，确实能够在频繁进行调用之际，展现出一种简洁的态势，然而与此同时，却会致使关于“此事物究竟于何处被定义”的提示性信息消失不见，如此一来，想要理解或者维护代码，那就只能呵呵了。 #

然而，要是导入的源头十分知名，举例来说像是java.lang.Math ，那么此问题便没那么严峻了 。 #

按需导入机制

#

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

绝对不会!

#

一、的按需导入

import java.util.*;
public class NeedImportTest {
    public static void main(String[] args) {
新建了一个ArrayList，将其命名为tList 。，。
    }
}
 # 

编译之后的class文件 : #

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

二、 的按需导入

导入静态的，来自那个com.assignment.test.StaticFieldsClass的，那些内容。
公共类，静态需求导入测试类，{此句为Java代码中的类声明语句，用于定义一个名为StaticNeedImportTest的类}。
    public static void main(String[] args) {
        System.out.println(staticField);
        staticFunction();
    }
}
 
#
 

上面 类编译之后 :

//可以看出 ： 
那么，首先来讲，static import所进行的精准导入，还有按需导入，在经过编译之后，它们都会转变成为import的单类型导入 。
这是语句并不需要改写，请确认需求，若有其他需求请重新提供具体内容 。此句为代码中的导入包语句，直接改写会失去原本代码意义 。
public class StaticNeedImportTest {
    public static void main(String[] args) {
    //2、编译之后“打回原形”，使用原来的方法调用静态成员
System.out.println，StaticFieldsClass的staticField被输出。
静态字段类的静态函数被调用，该函数属于静态字段这个类，它被执行了 。
    }
}
 
#
 

附加 #

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

#

是,也不是! #

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

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

编译速度，于一个规模极大的项目里，会将编译速度予以极大影响，不过于小型项目之中运用，于编译时间方面能够忽略不计。命名冲突，解决避免命名冲突这一问题的答案乃是运用全名，而按需导入恰恰是对使用导入声明初衷的否定。说明问题，终究高级语言的代码是供人去看的java班，按需导入无法看出所使用到的具体类型。无名包问题，要是在编译单元的顶部不存在包声明java班，Java编译器首先会于无名包内搜寻一个类型，接着才会是按需类型声明。如果有命名冲突就会产生问题。 #

太阳公司的工程师通常不会运用按需类型进口声明，这一点你能够于他们的代码里面寻觅到：

#

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

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;
引入，用于输入输出的字节流写入器，它是基于缓冲的字符输出流，可将字符转换为字节后写入底层输出流，属于Java。
导入，Java，用于输入输出操作的，专门处理缓冲操作的，写入器接口的，类库中的，包路径相关的，。
引入，由 Java 语言所提供的，具备安全相关功能的，名为 AccessController 的类，此操作通过导入（import）这一行为来达成，它属于安全。
引入，用于安全许可的具有特殊优势的行为的Java安全相关的类，具体是权限操作相关类。
 
#
 

#

能瞧见，他们借助单类型导入，将所需的，在java.io包里头的，具体类型，详细地罗列了出来 。 #