包是一个文件夹，它是类的一种特殊性质，可以更合理的管理大量的类文件，设置他人对类成员的访问权等。
在Java开发大型项目时，通常要把类分门别类地存到文件夹里，在将这些文件夹一起编译执行，这样的程序代码更易于维护。同时将类分割开后，对于类的使用也就有了相应的访问权限。

包（package）的基本概念
当一个大型程序由多个不同的组别或人员共同开发时，不可能保证每个人写的类名称是完全不同的，这样一来就可能出现同文件覆盖的问题。那么为了解决这样的麻烦确保程序可以正常运行，就必须通过使用package关键字来帮忙。所谓的包（package）指的就是一个文件夹，即在不同的文件夹之中可以保存同名的类文件。
包的使用方法：在类或接口当然最上面一行加上package的声明。通常包全部用小写字母命名。
package package 名称[.package 名称2.package 名称3…];

程序中如果有package语句，该语句一定是源文件中第一条可执行语句，它的前面只能有注释或空行。另外一个文件中最多只能有一条package语句。
经过package的声明之后，同一文件内的接口或类就都会被保存在相同的package中。
包的名字有层次关系，各层以点分隔。包层次必须与Java开发系统的文件系统结构相同。
若包声明如下：package java.awt.a，则文件中的接口和类都存放在…java\awt\a目录下。

package的使用
package demo.java;   //声明package，相当于将Perso类和TestPerson1类放入demo\java文件夹之下
class Person
{
    public String talk()
    {
        return"Person>>>>talk()";
    }
}
class TestPackage1
{
    public static void main(String args[])
    {
        System.out.println(new Person().talk());
    }
}

包的导入
使用包可以将功能相似的若干类保存在一个文件目录之中，但这样一来就有可能出现包之间的互相访问问题，当一个程序需要其他包中类的时候可以通过import完成导入操作。package导入方法如下
import package 名称.类名称;
若某个类需要被访问时，则必须把这个类公开出来，即此类必须声明public。通过import命令，可将某个package内的整个类导入，后续程序可直接使用类名称，而不用再写上被访问的package的名称。

若在不同的package中存在相同类名的public类，若要访问某个public类的成员时，
在程序代码内必须明确指明“被访问package的名称.类名称”。

包的导入使用范例

package demo.java.a;
public class Person
{
public String talk()  //类中的方法
{
return "Person>>>talk()";
}
}

//声明一个demo.java.b包 并调用demo.java.a中的类方法
package demo.java.b;
import demo.java.a.Peraon;
//将demo.java.a包中的Person类导入此包中
class TestPerson2
{
    public static void main(String args[])
    {
        //调用demo.java.a中的方法并输出
        System.out.println(new Person().talk());
    }
}
第一句声明一个demo.java.b包将TestPerson2类放入此包中。
第二句使用import语句，将demo.java.a包中的Person类导入到此包中。
最后一句调用demo.java.a包中的Person类中的talk()方法。

提示：如果一个项目中有几百个类时，为了方便导入可以使用“包.”的形式完成。虽然使用的是“包.”，但实际上并不表示此包之中所有类都会被导入，导入的时候也只是导入所需要的类，不需要的类是不会有任何加载的，所以分开导入和使用“*”导入从性能上讲是完全一样的。

上面程序也可以写成如下形式：

package demo.java.b;
class TestPerson3
{
public static void main(String args[])
{
//在程序中将写出所用类的具体位置
System.out.println(new demo.java.a.Person().talk());
}
}
程序中没有使用import语句，但是使用Person类
的时候使用了“包名.类名”的方式，所以在程序中也可以使用此方法来使用
非本类所在包中的类。
很多时候有可能在程序开发之中导入的包里面有同名的类，则这个时候再使用类的话就
必须写上类的完整名称“包名.类名”才可以正确操作。

JDK中常见的包

导入一个Applet程序所需要的包

package demo.java;    //声明包demo.java
import java.applet.*;   //导入java.applet中所有包
import java.awt.*;     //导入java.awt中所有包
 public class MyApplet extends Applet   //声明一个MyApplet类继承Applet类。
{
    public void paint(Graphics g)
    {
        g.drawString("世界，你好！",30,30);   //输出一行字，调用Java中自带的方法在图形化窗口输出一行字
        g.drawLine(50,50,100,100);  //画一条线，调用Java中自带的方法在图形化窗口输出一条线段
    }
}
第2，3行导入实现小窗口应用程序的包。

Applet程序必须继承一个Applet类，Java是单继承局限，所以此程序不会在用了。Applet程序和Application程序有一个最大区别：Applet不是依靠主方法运行，而Application是依靠主方法运行的，Applet已经成为了一个过去。

类成员的访问控制权限
Java中四种访问控制权限，private，default，protected，public。
private：如果一个成员方法或成员变量名前使用private访问控制符，那么这个成员只能在这个类内部使用。
default：如果一个成员方法或成员变量名前没有使用任何访问控制符，那么这个成员拥有的是默认的(default)访问控制符。默认的访问控制成员可以被这个包中的其他类访问。如果一个子类与其父类位于不同包中，子类也不能访问父类中的默认访问控制成员。
protected：如果一个成员方法或成员变量名前使用protected访问控制符，那么这个成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问。
public：如果一个成员方法或成员变量名前使用了public访问控制符，那么这个成员可以被所有的类访问，不管类与被访问类是否在同一个包中。

类成员的访问控制权限使用范例

范例1
package demo.java.b;
import demo.java.a.*; //通过导入demo.java.a.*;而导入所需要的Person类
public class Student extends Person
{
public Student(String name)
{
this.name=name;   //Stude类访问Person类中的name属性
}
public String talk()
{
return "Person>>talk()，"+this.name;
}
}

范例

package demo.java.c;
import demo.java.b.*;
class TestPackage
{
public static void main(String args[])
Student s=new Student("javafans");
s.name="javafans";  //通过对象调用受保护的属性
System.out.println(s.talk());
}
}

Java命名规范
JDK中类的声明，方法的声明，常量的声明有一定规律
1，包名中的字母一律小写，如demo.java。
2，类名、接口名应当使用名词，每个单词首字母大写。如TestPerson。
3，变量名（属性名）第一个单词小写，后面单词的首字母大写。如newLxh。
4，方法名的第一个单词小写，后面每个单词大写，如talkMySelf()。
5，常量名中的每个字母一律大写，如COUNTRY。

打包工具>>>jar命令的使用
jar文件即java archive file的缩写，其应用与Java息息相关。jar文件就是一种压缩文件，与常见的ZIP压缩文件格式兼容，习惯上称之为jar包。如果开发者开发了许多类，当需要把这些类提供给用户时，通常都会将这些类压缩到jar文件中，以jar包的方式提供给用户使用。只要别人的classpath环境变量的设置中包含这个jar文件，Java虚拟机就能自动在内存中解压这个jar文件，把这个jar文件当做一个目录，在这个jar文件中去寻找所需要的类名及包名所对应的目录结构。
jar命令是Java中提供的一个非常有用的一个命令，可以用来对大量的类（.class文件）进行压缩，然后存为.jar文件。jar压缩文件可以方便管理大量的类文件，，进行压缩也减少了文件所占的空间。

只要在命令行中使用以下命令就可以将一个包打成一个jar文件。
jar-cvf create.jar demo

-c：创建新的存档
-v：生成详细输出到标准输出上。
-f：指定存档文件名。
create.jar：是生成jar文件的名称。
demo：要打成jar文件的包

单例设计模式

package demo.java.b
class Singleton
{
private static Singleton inst=new Singleton();   //实例化对象
private Singleton(){}  //此时类中不会再生成无参的什么都不做的构造
public static Singleton getInst()
{
return inst;
}
public void print()
{
System.out.println("HelloWorld");
}
}
class Test1
{
public static void main(String args[])
{
Singleton inst=null;   /声明对象
inst=Singleton.getainst();
inst.print();
}
}

如果想要产生类的实例化对象，那么一定要调用构造方法，如果把一个类的构造方法卡死了，那么就表示外部无法调用此构造，就意味着外部无法产生实例化对象。同时在类内部定义的本类实例化对象使用的是static定义，static特点是在全局数据区之中保存，是一个公共属性。那么不管外部声明多少个对象实际上只是取得了唯一的一个实例化对象。这样的设计模式称之为单例设计模式。

多例设计模式
多例设计模式指的是一个类可以定义指定多个对象，不管是单例还是多例，构造方法都不可以使用public定义。

public demo.java.d;
classSex  //性别
{
private String title;  //保存信息
private static final Sex MALE=new Sex("男");
private static final Sen FEMALE=new Sen("女");
private Sex(String title)
{
this.title=title;
}
public static Sex getInst(int ch)
{
switch(ch)
{
case 0:
return MALE;
case 1:
return FEMALE;
default:
return null;
}
}
public String toString()
{
return this.title;
}
}
public class Test
{
public static void main(String args[])
{
System.out.println(Sex.getInst(0));
}
}