在Java中，若想利用包的特性，可使用引入(import)语句告诉编译器要使用的类所在的位置。实际上，包名也是类名的一部分。例如，如果abc．Student包中含有Gui类，则该类可称作abc．Student．Gui。如果使用了import语句，再使用类时，包名可省略，只用Gui来指明该类。
1、使用格式
import pkgl[．pkg2[．pkg3…]]．(类名I g-)；
 假设有一个包a，在a中的一个文件内定义了两个类XX和YY，其格式如下：
    package a；

    class XX{}

    class YY{}
当在另外一个包b中的文件ZZ．java中使用a中的类时，语句形式如下：

    package b；

    import a．*；

    class ZZ extends XX {}
在ZZ.java中，因引入了包a中的所有类，所以使用起来就好像是在同一个包中一样。
在程序中，可以引用包的所有类或若干类。引用所有类时，可使用通配符“*”。引入整个包时，可以方便地访问包中的每一个类，但会占用过多的内存空间，代码下载的时间将会延长，因此在了解包的基本内容后，实际要用到哪个类就引用哪个类，尽量不造成资源的浪费。
实际上，程序中不一定要有引用语句。当引用某个类的类与被引用的类存储在同一物理目录下时，就可以直接使用被引用的类。
2、分类
单类型导入：import java.io.File;
按需求类型导入：import java.io.*; 对于按需类型导入，有人误解为导入一个包下的所有类，其实不然，看名字就知道，他只会按需导入，也就是说它并非导入整个包，而仅仅导入当前类需要使用的类。
  注：单类型导入和按需类型导入对类文件的定位算法是不一样的。java编译器会从启动目录(bootstrap)，扩展目录(extension)和用户类路径下去定位需要导入的类，而这些目录仅仅是给出了类的顶层目录。编译器的类文件定位方法大致可以理解为如下公式：
  顶层路径名 \ 包名 \ 文件名.class = 绝对路径
对于单类型导入很简单，因为包明和文件名都已经确定，所以可以一次性查找定位。
对于按需类型导入则比较复杂，编译器会把包名和文件名进行排列组合，然后对所有的可能性进行类文件查找定位。例如：
package com;
import java.io.*;
import java.util.*;

commons-dbutils-1.6.jar



1.commons-dbutils-1.6.jar
 操作JDBC连接数据库 并且执行sql语句 处理返回的结果集
 三个核心类
 DbUtils: 关闭资源的方法(安静的关闭 不用异常处理)
 QueryRunner: 执行sql语句 并且返回你想要的结果集
 参数: ResultSetHandler是接口(使用它的实现类 想要什么结果集 就传入什么该类的接口)
 // 插入数据
 private static void insert() throw SQLException{
     // 插入一条数据使用QueryRunner
     QueryRunner qr = new QueryRunner();
     // 获取连接 (JDBCUtil是自己写好的创建连接和关闭资源的工具类)
    Connection connection = JDBCUtil.getConnection();
    String sql = "insert into sort values (null, '显示器', 5,'这是一台显示器');
    // 插入数据
    int row = qr.update(connection.sql);
    if(row > 0){
    System.out.println("插入成功");
     }
 // 安静的关闭资源
 DbUtil.closeQuietly(connection);
}
 // 修改数据
 private static void update() throw SQLException{
     QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        // 使用占位符传入sql语句
        String sql = "update sort set sname=?, sprice=?, sdesc=? where sid=5";
        // 多参数传参 方式1 利用数组传
        // 方式2 直接传递参数 注意要和占位符号的顺序 对应
        Object[] params = {"咖啡",1000,"java里的咖啡"};
        int row = qr.update(connection, sql, "咖啡1",2000,"java里的咖啡");
        if (row > 0) {
            System.out.println("修改成功");
        }
        DbUtils.closeQuietly(connection);
 }



2.使用QueryRunner进行查询操作  给QueryRunner传入的参数不同 返回的结果集也不同
@Test
    public void select1() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        // 调用查询方法
        // 传入什么内容 该类就把数据放到什么容器中 给你返回
        Object[] objects = qr.query(connection, sql, new ArrayHandler());
        for (Object object : objects) {
            System.out.println(object);
        }
        DbUtils.closeQuietly(connection);
    }
    /*
     * ArrayListhandler
     * 查询每一条记录 放到List集合中
     * 每一条记录是一个对象数组
     */
    @Test
    public  void select2() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        List<Object[]> list = qr.query(connection, sql, new ArrayListHandler());
        for (Object[] objects : list) {
            for (Object object : objects) {
                System.out.println(object);
            }
            System.out.println();
        }
        DbUtils.closeQuietly(connection);
    }

    /*
     * BeanHandler
     * 把结果集的第一行 封装成一个JavaBean对象
     * JavaBean对象规则
     * 1.成员变量私有化
     * 2.提供空参的构造方法
     * 3.提供set/get方法
     * 符合以上规则的实体类创建出来的对象 就是一个JavaBean对象
     * 
     */
    @Test
    public void select3() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        // 要把使用哪个javabean实体类 传进去
        // 类名.class
        Sort sort = qr.query(connection, sql, new BeanHandler<>(Sort.class));
        if (sort == null) {
            System.out.println("没有该数据");
        }
        System.out.println(sort);
        DbUtils.closeQuietly(connection);
    }

    /*
     * BeanListHandler 
     * 返回全部数据
     */
    @Test
    public void select4() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        List<Sort> list = qr.query(connection, sql, new BeanListHandler<>(Sort.class));
        for (Sort sort : list) {
            System.out.println(sort);
        }
        DbUtils.closeQuietly(connection);
    }

    /*
     * ColumnListHandler
     * 返回指定列的数据 放在list中返回
     */
    @Test
    public void select5() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        List<String> list = qr.query(connection, sql, new ColumnListHandler<String>("sname"));
        for (String string : list) {
            System.out.println(string);
        }
        DbUtils.closeQuietly(connection);
    }

    /*
     * ScalarHandler
     * 只返回一个结果 多用于sql语句的聚合查询
     */
    @Test
    public void select6() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select avg(sid) from sort";
        BigDecimal query = qr.query(connection, sql, new ScalarHandler<BigDecimal>());
        System.out.println(query);
        DbUtils.closeQuietly(connection);
    }

    /*
     * MapHandler
     * 将第一条数据存放在map中 以键值对的形式 键:列名  值: 列值
     */
    @Test
    public void select7() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        Map<String, Object> map = qr.query(connection, sql, new MapHandler());
        for (String key : map.keySet() ) {
            System.out.println(key + "  " + map.get(key));
        }
        DbUtils.closeQuietly(connection);
    }

    /*
     *  MapListHandler
     *  返回全部数据 将存有数据的map存到list中 在返回去
     */
    @Test
    public void select8() throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection connection = JDBCUtil.getConnection();
        String sql = "select * from sort";
        List<Map<String,Object>> list = qr.query(connection, sql, new MapListHandler());
        for (Map<String, Object> map : list) {
            for (String key : map.keySet()) {
                System.out.println(key + "  " + map.get(key));
            }
        }
        DbUtils.closeQuietly(connection);
    }
}

连接池



  java为了解决频繁创建数据库连接和释放数据库连接的问题
  使用数据库连接池来解决 并且出了一套规范
  数据库连接规范(接口)
  javax.sql.DataSource  java扩展包
  由数据库厂商来提供的 
  常用数据库连接池 DBCP C3P0
  需要导入的jia包(dbcp中依赖pool jia包种的类)
  commons-dbcp-1.4.jar
  commons-pool-1.5.6.jar
  BasicDataSource 是 DataSource(规范类) 的实现类
  基础设置 (要使用数据库连接池 必须要设置的内容)
  mysql驱动类 com.mysql.jdbc.Driver
  访问数据库连接地址
  数据库访问用户名 和 密码
  public class DataSourceUtil {
    private static BasicDataSource dataSource = new BasicDataSource();
    static {
        // 设置dataSource
        // mysql的驱动类的权限定类名
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/myjdbc");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        // 扩展设置
        // 初始化连接数
        dataSource.setInitialSize(10);
        // 最大活动数
        dataSource.setMaxActive(8);
        // 最大空闲连接数
        dataSource.setMaxIdle(5);
        // 最小空闲连接数
        dataSource.setMinIdle(2);
    }
    // 获取数据库连接池方法
    public static DataSource getDataSource() {
        return dataSource;
    }   
}
//  测试DataSourceUtil类
public static void main(String[] args) throws SQLException {
        // 数据库连接池和QueryRunner结合使用
        QueryRunner qr = new QueryRunner(DataSourceUtil.getDataSource());
        // 插入一条数据
        String sql = "insert into sort values (null, ?, ?, ?)";
        Object[] params = {"试卷", 10, "一份万分试卷"};
        int row = qr.update(sql, params);
        if (row > 0) {
            System.out.println("插入成功");
        }
    }

Python导入包的机制辨析~
在Python中有3种方法可以引入外部模块:
import语句
from ... import ...语句
__import__函数
使用import的注意事项
优先使用import xxx的形式
有节制地使用from xxx import yyy的形式
避免使用from xxx import *的形式
为什么要这样来建议，我们可以从Python如何导入模块来分析。
Python导入模块的机制
在初始化运行环境的时候Python解释器会自动加载一些内建模块，可以通过sys.modules.items()函数查看预加载模块的信息。
当用户加载模块时会发生以下过程:
1)在sys.modules中进行搜索看看该模块是否已经存在，如果存在，则将其导入到当前局部命名空间，加载结束。
2)如果在sys.modules中找不到对应模块的名称，则为需要导入的模块创建一个字典对象，并将该对象信息插入sys.modules中。
3)加载前确认是否需要对模块对应的文件进行编译，如果需要则先进行编译。
4)执行动态加载，在当前模块的命名空间中执行编译后的字节码，并将其中所有的对象放入模块对应的字典中。
无节制使用from ... import带来的问题
(1) 命名空间冲突
由于from ... import会将导入的名字引入当前命名空间，在项目中，特别是大型项目中频繁地使用from a import ...会增加命名空间冲突的概率。
(2) 循环嵌套导入的问题
如果两个模块相互导入，在使用from ... import时就可能带来循环嵌套导入的问题，例如:
m1.py:from m2 import x2def x1(): passm2.py:from m1 import x1def x2(): pass
导入上面任何一个文件都会抛出ImportError异常。在导入m1时，遇到语句from m2 import x2，此时m2不存在与于sys.modules中，因此此时转到导入m2.py文件。然后导入m2.py时，遇到语句from m1 import x1，此时m1已经在sys.module中存在，但是在字典中找x1，但是由于m1.py的导入之前并未完成，还没有x1，于是解释器便会抛出ImportError: cannot import name x1异常。直接使用import就没有这个问题。
欢迎大家关注小编~

4.11 import 语句
如果一个类想要使用的类不和它在一个包中，那么就需要import语句来帮助完成使命


4.11.1 引入类库中的类

用户需要类库中的类就必须使用import语句

一些重要包中的类
Java.lang
包含所有的基本语言类
Java.swing
包含抽象窗口工具集中的图形、文本、窗口GUI类
Java.io
包含所有输入、输出类
Java.util
包含实用类
Java.sql
包含操作数据库的类
Java.net
包含所有实现网络功能的类

若要引用一个包中的全部类，可以使用通配符（*）来代替
例子：import Java.util.*


4.11.2 引入自定义包中的类（略）