• JAVA基本类库介绍


                                 

            8.1 包的概念

        包是由.class文件组成的一个集合,.class文件时可以用Java解释其解释执行的文件,它也是由Java源的文件,即.Java文件经编译而生成的。Java是一种面向对象的语言,它的特点就是重用,包就是组织和管理.class文件的一种工具,因此,它存在的目的就是帮助我们实现代码的重用。包是一种松散的概念,一般情况下,功能相同或者相关的类组织在一个包中,例如java.io包中的类都与输入、输出有关,java.applet包中的类都与applet程序有关。

    8.1.1 构建包

        一个包事实上就是一个文件夹,这个文件夹中存放着.class文件。包像目录结构一样可以由多层结构,而各层之间以“.”来分隔,如java.io,java.awt,java.awt.color等。由于Java的类经常需要在互联网上运行,所以有可能出现同名的类,程序就不知道使用哪一个类了。但如果把类都放在不同的包中,并且使包的名字独一无二,就不会出现混乱状况。

    程序中定义包用package这个关键词,它的格式如下:

    package 包名:

    例如:

    package MyJavaProgram;

    package cn.com.companyname.myname

    这个语句必须放在一个源文件的第一句,并且语句前面无空格。包名一般全部用小写。我们知道一个源文件可能有多个类,其中只有一个类是公共类,这些类经编译都会产生.class文件,上面的意思是,这个源文件中的类,经编译产生的.class文件属于一个包,名为MyJavaProgram。这就定义了MyJavaProgram包。一般把要打包的源文件放到包中,然后再包中对源文件进行编译,就把.class文件放入包中了。当然javac编译器还有几个参数,可以实现确定源文件来源和.class文件放置等功能,可以实现源文件和.class文件不在同一个目录。下面是各种参数及其解释。

    -g 生成所有debug信息

    -g:none 不生成任何debug信息

    -g:{lines,vars,source} 只生成部分debug信息

    -O 优化

    -nowarn 不生成警告

    -verbose 输出编译器的工作记录

    -deprecation 输出所有过期API的位置

    -classpath<path> 声明查找用户类库的路径

    -sourcepath<path> 声明查找源文件的路径

    -bootclasspath<path> 覆盖引导类文件路径

    -extdirs<dirs> 覆盖安装扩展路径

    -d<directory> 声明将生成的.class文件放在何处

    -enconding<encoding> 声明源文件的编码方式

    -traget<release> 未指定版本的虚拟机生成类文件

    8.1.2 包的引用

      用import语句就可以引入所需的公共类,如:

    import java.io.*;

       这个语句表示java.io中所有的公共类被引入当前包。系统先根据classpath只是的路径,然后按照包名找到所需的类,如classpath为c:packagemypakage,而包名为cn.com.companyname.myname,系统则按照以下路径去寻找所需的类:c:packagemypackagecncomcompanynamemyname,也就是把环境变量和包名相连,形成路径,然后在这个路径下寻找类。对于Java类库,由于安装时已经自动注册了路径,所以不需要添加classpath,而使用自己定义的包中的类就必须更改classpath。

    还有一种方法使用某个包中的类,就是在程序中写全它的包名,但很麻烦,而不使用import语句,如:

    java.io.FileInputStream in = new java.io.FileInputStream();

    如果我们使用了一个包中的大多数类,可是使用通配符的方式引用包,否则,最好把需要类一一列出来,这样可以节省大量系统资源。

                                 8.2 Java语言类库的结构

         Java 2平台类库1.3.1版共为程序员提供了76个包,每个包都分别负责不同的功能,除了java.lang之外,其它包的内容只要经过import语句引用,就可以在程序中使用。所有这些类的介绍和使用方法,Java都提供了极其完善的技术文档,这种机制在极大程度上释放了程序员,让他们何以把更多的时间放在对象的设计上,而不是语法和一些局部算法上。

    为了方便读者自己使用Java文档,我们先把Java提供的这些包介绍一下,读者可以根据自己的需要来查阅。其中,包名后面带”.*”的表示其中包括一系列相关的包。

    表8.1 Java提供的包

    包名 内容介绍

    java.applet 提供了创建applet需要的类,包括帮助applet访问其内容的通讯类

    java.awt.* 提供了创建用户界面以及绘制、管理图形、图像的类

    java.beans.* 提供开发Java Beans需要的类

    java.io 提供了通过数据流、对象序列以及文件系统实现的系统输入、输出

    java.lang.* Java编程语言的基本类库

    java.math 提供了简明的整数算术以及十进制算数的基本函数

    java.net 提供了用于实现网络通讯应用的所有类

    java.rmi.* 提供了与远程方法调用相关的所有类

    java.security.* 提供了设计网络安全方案需要的类

    java.sql 提供了访问和处理来自于Java标准数据源数据的类

    java.text 提供了一些类和接口用于处理文本、日期、数字以及语法独立于自然语言之外格式的消息

    java.util.* 包括集合类、事件处理模式、日期时间工具等各类常用工具包

    javax.accessibility 定义了用户界面组件之间相互访问的一种机制

    javax.naming.* 未命名服务提供了一系列类和接口

    javax.rmi.* 为用户提供了远程方法调用的应用程序接口

    javax.sound.* 提供了MIDI输入、输出以及合成需要的类和接口

    javax.swing.* 提供了一系列轻量级的用户界面组件,是目前Java用户界面常用的包

                       8.3 java.lang包中的常用类介绍

        这个包是Java语言最基本的包,没有这个包中的类,我们的编程很难,它们是编程最基本内容。这个包中的所有类都有系统自动引入,所以程序不用import语句就可以使用其中的任何一个类。这个包有4个部分:接口、类、例外和错误。

    8.3.1 Object类

        Object类是Java程序中所有类的直接或间接父类,也是类库中所有类的父类,任何一个类都是由Object类派生出来的,它是继承树上的根节点。所以它含有的属性和方法将被所有的类继承,下面就是Object类的方法,也是所有类都含有的方法:

    ● protected Object clone()throws CloneNotSupportedException

    生成当前对象的一个复制,并返回这个复制的对象,该对象类型为Object,但所有需要使用该方法的类都必须实现接口cloneable,否则,运行时将抛出CloneNotSupportedException类的例外。

    ● public final Class getClass()

    返回一个当前对象在运行期的Class类对象。

    ● public int hashCode()

    返回一个hash code value,不同的对象有不同的hash code value.

    ● public Boolean equals(Object obj)

    如果当前对象与形参对象相同则返回true,否则返回false。

    ● public String toString()

    返回一个反映这个对象信息的字符串,通常使对象所属类。

    ● public final void notify()

    这是关于多线程的方法,这个方法用来唤醒等待对向监视器的多个线程中的一个

    ● public final void notifyAll()

    这个方法是唤醒所有等待监视器的线程

    ● public final void wait(long timeout)throws InterrupedException

    这个方法是让当前线程放弃对这个对象的同步的声明,即放弃对这个对象的锁定,进入等待行列,直到由notify()或notifyAll()方法唤醒,或形参中规定的时间到期,timeout的单位是毫秒。

    ● public final void wait(long timeout,int nanos)throws InterrupedException

    这个方法比上一个多了一个形参,第二个形参的意思是nanoseconds(十亿分之一秒),这个方法的等待时间变为两个形参所指示的时间的和,时间控制更精确。

    ● public final void wait()throws InterrupException

    这个方法的含义同wait(0)

    ● protected void finalize()throws Throwable

    这个方法用来把对象从内存中清除,由圾收集器自动调用,编程者可以重载这个方法,在对象被清除时,显示某些信息。

    8.3.2 Class类

       Class类是非常特殊的,它的对象将伴随每个类。当一个类X被编译后,就有一个特殊的对象(Class对象)产生,它隐藏在X.class文件中,Class对象是由编译系统自动生成的。

    为了读者进一步理解类是在何时载入内存的,先来看一个例子:

    例8.1 类的载入时机

    SweetShop.java的源文件如下:

    class Candy{

    static{

    System.out.println("Loading Candy");

    }

    }

    classGum{

    static{

    System.out.println("Loading Gum");

    }

    }

    class Cookie{

    static{

    System.out.println("Loading Cookie");

    }

    }

    public class SweetShop{

    public static void main(String[] args){

    System.out.println("inside main");

    new Candy();

    System.out.println("After creating Candy");

    try{

    Class.forName("Gum");

    }catch(ClassNotFoundException e){

    e.printStackTrace();

    }

    System.out.println("After Class.forName("Gum")");

    new Cookie();

    System.out.println("After creating Cookie");

    }

    }

    这个程序首先定义了3个类,每个类只有一个静态初始化器,由于静态初始化器是在类载入内存时就被执行,所以可用它来指示类何时被载入内存的。然后在每个对象创建之前输入一定的提示语,,这样我们就很清楚的看到每个类何时加载内存的了。程序中Class.forName(“Gum”);依据的进一步解释看下面的部分。程序输出如下:

    inside main

    Loading Candy

    After creating Candy

    Loading Gum

    After Class.forName(“Gum”)

    Loading Cookie

    After creating Cookie

    从以上的结果可以看出,类的加载是在对象创建的时候。

    这个特殊的Class对象含有所属类的所有信息,可以通过Class类的方法提取这些信息,下面我们就介绍Class类的一些方法。

    ● public static Class forName(String className)throws ClassNotFoundException

    这个方法是静态方法,所以用Class直接调用,格式可以参考上面的例题。这个方法的形参是一个类名,方法的返回值是形参指示的类的Class对象。这个方法的结果是产生一个形参所表示的类的Class对象。如:

    class t=Class.forName(“java.lang.Thread”)

    ● public String getName()

    该方法返回Class对象代表的实体(类、接口、数组、基本数据类型等)的名字。例如,(new Object()).getClass().getName()的值是java.lang.Object,当然可以放到println()语句中输出。其中的getClass()用来得到当前对象的Class对象,同一个类的对象有相同的Class对象。

    GetName()返回的字符串中以不同的字母及符号表示该实体的信息,“[”表示数组,有几个“[”表示几维数组,以下的字母代表不同的数据类型,“L”表示类或接口。

    再看几个例子:

    (new Object[3]).getClass.getName()的值为“[Ljava.lang.Object”,它表示当前Class对象对应着一个一维数组,数组元素是java.lang.Object类的对象。

    (new int[3][4][5][6][7][8][9]).getClass().getName()的值为“[[[[[[[I”,它表示当前Class对象对应着一个七维数组,数组元素是int类简单变量。

    ● public Class getSuperclass()

    这个方法不同于Object类的方法getClass(),它返回的是一个数组,这些数组成员是Class对象,这些对象是当前类中的成员为公共或接口所对应的Class类的实例。

    ● public ClassLoader getClassLoader()

    ClassLoader是一个抽象类,在java.lang包中。任何一个类加载内存,都是通过一个对象来实现的,这个对象就是它衍生类的实例,因为类的定义都是一字节码文件形式存在,加载一个类就是读取这些字节码。

    ● public Class getComponentType()

    返回数组成员的类型,如果当前对象不是数组,返回null。

    ● public int getModifiers()

    返回类或接口的修饰语,例如public,protected,private,final,static和abstract等,但它们用一个int数表示,例如:public为0x0001,final为0x0010,abstract为0x0400,这些数字以十六进制表示,是Java虚拟机用来鉴别修饰语用的

    ● public Class getDeclaringClass()

    如果当前对象是另一个类的成员,则返回那个类的Class对象,否则为空。

    8.3.3 Math类

    Math类是一个最终类,类头定义是:public final class Math extends Object。它包含了常用的科学计算方法。这些方法都是静态方法,可以通过类名直接调用。下面我们列出其中常用的属性和方法的定义:

    ● public static final double E

    ● public static final double PI

    三角函数:

    ● public static double sin(double a)

    ● public static double cos(double a)

    ● public static double tan(double a)

    ● public static double asin(double a)

    ● public static double acos(double a)

    ● public static double atan(double a)

    弧度、角度转换如下:

    ● public static double toRadians(double angdeg)

    ● public static double toDegrees(double angrad)

    代数函数:

    ● public static double exp(double a)

    ● public static double log(double a)

    ● public static double sqrt(double a)

    ● public static double ceil(double a)

    ● public static double floor(double a)

    ● public static double random()

    以下3个方法都有其他数据类型的重载方法:

    ● public static int abs(int a)

    ● public static int max(int a,int b)

    ● public static int min(int a,int b)

    8.3.4 String与StringBuffer类

        Java提供了两个用于字符串操作的类,一个是经常用到的String,另一个是StringBuffer。字符串类提供了丰富的字符串操作方法,程序员可以方便的使用这些常用的算法和操作,而不需要自己再重复编写,这就是面向对象的好处。

    1. 为什么要使用两个类

    String类用与处理那些值不会发生改变的字符串,以前程序中的String变量,全都是其取值没有发生过变化的字符串。而StringBuffer类则用于那些可能发生变化的字符串的处理。例如,在程序中拼接字符串、从文件中读取字符串等等。由于String类对象都是常量,它的处理效率要比StringBuffer类对象高得多,因此,读者在编程时尽可能使用String类。

    下面我们来看一个简单的例子,它同时使用了String和StringBukffer,

    例8.2 用两种不同的字符串类来逆转字符串

    StringDemo.java测源程序如下:

    public class StringDemo{

    public static void main(String[] args){

    String palindrome="Dot saw I was Tod";

    int len=palindrome.length();

    StringBuffer dest=new StringBuffer(len);

    for(int i=(len-1);i>=0;i--){

    dest.append(palindrome.charAt(i));

    }

    System.out.println(dest.toString());

    }

    }

    在这个程序中,我们先创建了一个String类对象,并将字符串“Dot saw I was Tod”赋值给它,然后创建了一个和它一样长的StringBuffer类对象。利用它来进行逆转处理。这个程序的执行结果很有趣,实际上和输入字符串几乎是一样的(除了第一个字母的大写问题),即:

    doT sw I was toD

    2. 对象的创建

        一般情况下,创建一个String都是采用直接给一个String对象赋值的方法,其值用双引号括起来,如:

    String palindrome=”Dot saw I was Tod”;

    当然,也可以象创建其它对象那样,新建一个String对象出来,Java为String提供了几种比较常用的构造期。如,使用字符数组或者StringBuffer等,下面是一个使用字符数组创建String对象的例子:

    char[] helloArray={‘h’,’e’,’,’l’,’l’,’o’};

    String helloString=new String(helloArray);

    System.out.println(hellostring);

    3. String的常用方法

    String的常用方法如下:

    ● public int length()

    返回字符串长度

    ● public char charAt(int index)

    返回index位置的字符,index从0到length()-1

    ● public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

    这个方法是把字符串中的字符复制到一个字符数组中

    ● public Boolean equals(Object anObject)

    这是对Object类中同方法的重载

    ● public int compareTo(String anotherString)

    这是实现Serializable接口中的方法,如果实际字符串比形参字符串以字典排序时靠前,返回负数,相反时为正数。

    ● public Boolean startsWith(String prefix)

    ● public Boolean endsWith(String suffix)

    上面两个方法分别判断字符串是否以形参字符开始或结束。

    ● public int indexOf(int ch)

    该方法返回字符串中第一个出现形参所指示的字符的位置,如果没有该字符,返回-1。

    ● public int indexOf(int ch,fromIndex)

    从fromIndex开始查找,返回第一个是ch字符的位置,或者返回-1。

    ● public int lastIndexOf(int ch)

    返回字符串中最后一个ch字符的位置或-1。

    ● public String Substring(int beginIndex)

    返回从当前字符串中的beginIndex开始形成的新字符串。

    ● public String substring(int beginIndex,int endIndex)

    返回从当前字符串截取的新字符串,beginIndex是开始位,endIndex是结束位减1。

    ● public string concat(String str)

    把形参字符串连接到当前字符串后,字符串的加法运算就是这个方法。

    ● public String replace(char oldChar,char newChar)

    把字符串中所有相同的某个字符换成另一个。

    4. StringBuffer的常用方法

       由于StringBuffer类是可变字符串,所有它的操作主要集中在对字符串的更改上,因此先介绍它的append()和insert()方法,这两个方法都有多个重载方法,以实现不同的操作。

    ● public StringBuffer append(String str)

    从方法名就可以知道这是一个扩充字符串的方法,它的功能是把形参字符串加到当前字符串之后,形成一个新的可变字符串。例如:

    StringBuffer new StringBuffer();

    s.append(“start”);

    s.append(“le”);

    以上几个语句的结果是得到一个含有“startle”的可变字符串。

    ● public StringBuffer insert(int offset,String str)

    这个方法是在当前字符串中插入形参字符串,形成一个新的可变字符串。其中形参offset是偏移量,它指示在何处插入,0<=offset<=length().

    下面介绍该类的其它一些常用方法:

    ● public StringBuffer delete(int start,int end)

    删除start(含)到end(不含)之间的字符。

    ● public StringBuffer deleteCharAt(int index)

    删除指定位置的字符。

    ● public StringBuffer replace(int start,int end,String str)

    从start(含)到end(不含)之间的字符串以str代替。

    ● public void setCharAt(int index,char ch)

    改变指定位置的字符

    ● public StringBuffer reverse()

    使字符串逆转

    ● public int length()

    返回字符个数

    ● public int capacity()

    返回容量,通常会大于等于length()

    ● public void setLength(int newlength)

    改变字符个数,如果newLength大于原个数,则新添的字符都为空(“”)。相反,字符串中最好几个字符将被删除。形参newLength不能为负数。

    ● public String substring(int start,int end)

    提取子字符串,返回的是String类对象。

    ● public String toString()

    把可变字符串中内容变成String类对象。事实上在用println打印可变字符串内容时,就自动调用了该方法。

    在String类和StringBuffer类中,有一点值得注意,许多方法中用到的形参是用来指示字符串中的位置,假设这个形参为int index,那么,字符串的第一个字符的index值为0,第二个字符为1,依此类推。

    8.3.5 System类

        系统类是一个独特的类,它是一个final类,所有的方法都是用类变量调用的,换句话说,没有人可以实例话一个System类。System类主要提供了标准输入、输出以及一些系统环境信息。

    1. 标准输入、输出

    ● public static final InputStream in——标准输入

    这个属性是InputSream类的一个对象,关于InputStream类和下面的PrintStream类我们在java.io包中一并介绍,这些类都是关于输入、输出方面的,他们都有各自的属性和方法,我们用过的read()就是InputStream类的方法,println()和print()就是PrintStream类的方法。

    ● public static final PrintStream out——标准输出

    ● public static final PrintStream err——标准错误输出

    这些输入、输出属性可以根据其所使用的参数来自动的转换输出格式,下面的例子利用标准输出打印了几种常见数据类型的数据,它们使用的是println方法,但系统可以根据不同类型以不同的方式打印这些数据的值。

    例8.3 用标准输出打印各种类型的对象

    DataTypePrintTest.java的源程序如下:

    public class DataTypePrintTest{

    public static void main(String[] args){

    Thread objectData=new Thread();

    String stringData="Java Mania";

    char[] charArrayData={'a','b','c'};

    int integerData=4;

    long longData=Long.MIN_VALUE;

    float floatDAta=Float.MAX_VALUE;

    double doubleData=Math.PI;

    boolean booleanData=true;

    System.out.println(objectData);

    System.out.println(stringData);

    System.out.println(charArrayData);

    System.out.println(integerData);

    System.out.println(longData);

    System.out.println(floatData);

    System.out.println(doubleData);

    System.out.println(booleanData);

    }

    }

    其输出结果为:

    Thread[Thread-0,5,main]

    Java Mania

    abc

    4

    -9223372036854775808

    3.4028235E38

    3.141592653589793

    true

    我们注意到,打印一个String类型变量,系统的动作就是打印出它的内容,而打印一个Thread型变量,则系统打印它的格式为:

    类名[名称,优先级,组]

    2.系统环境信息

    System类提供了一个方法用来返回系统环境信息:

    Public static Properties getProperties(argument);

    Java虚拟机维护了一系列系统环境信息,它们都是以“键名/值”对的形式出现的,一旦Java虚拟机启动之后,系统就自动将这些变量初始化,其中包含了与运行环境相关的很多信息。

    另外,System类提供的与系统环境信息相关的方法还有:

    ● public static String setProperty(String key,String value);

    设置系统变量的值,key为键名,value为键值。

    ● public static Properties getPorperties();

    返回所有的系统环境环境。

    下面看一个例子,假设有一文本文件,叫myProperties.txt,其中只有一行:

    subliminal.message=Buy Java Now!

    我们利用这个文件来设置变量,它的名字叫做subliminal,其取值就是文本文件中存贮的内容。

    3.其它有用方法

    System类有许多方法,用这些方法可以管理Java虚拟机的运行和获得虚拟机的运行信息,下面是该类的几个方法,它们可以反映System类的一些功能。

    ● public static long currentimeMillis()

    返回系统时间,单位毫秒。

    ● public static void exit(int status)

    在用户的程序还未执行完之前,强制关闭Java虚拟机,并把状态信息status传递给操作系统,status非零时,表示非正常退出

    ● public static void ge()

    运行垃圾收集器

    以上的内容可以让我们对System类的内容有一定的了解,这个类中的属性和方法都与系统有关,而且这个类的许多方法借用了其它类的方法。

    8.3.6 数据类型类

    每一类简单数据类型都对应着一个数据类型类,例如,int对应着Integer类,double对应着Double类,这些类能把一个简单数据封装成一个类。某些场合必须使用这种数据类型类,如后面的集合类,它的成员必须是类,而不能是简单的变量。而且使用这些类能完成简单变量不能完成的工作,如将一个数字字符串转化成一个整数等。下面我们就以Integer类来说明这些类的某些方法。

    ●MAX_VALUE和MIN_VALUE规定了int类型量的最大值和最小值。

    ●构造函数:public Integer(int value)和public Integer(String s)分别把数字和数字字符串封装成Integer类。

    ● 下面几个方法是把当前数据类型类的对象所对应的int量转化成某种基本数据类型值:

    public int intValue()

    public long longValue()

    public double doubleValue()

    ● 下面是数字字符串和数字之间的转换:

    public String toString()

    public static int parseInt(String s)

    ● public static static Integer valueOf(String s)方法把s转化成Integer类对象。

                       8.4 关于Java的技术文档

         上面的内容是我们对包中的内容有了一定的了解,这一节研究JavaDOC中的类库。

    在下载完j2sdk-1_3_1-doc后,找到它下面的docs文件夹,打开index文件(HTML文件),找到API&Language Documentation下的Java2 Platfrom API Specificaion,然后选择需要的那个包,进而查看类、接口等内容。或者直接进入docs文件夹下的api文件夹,打开index(HTML文件),也可以进入选择包的界面。

    选择一个包后,可以看到包的名称以及简单描述,然后是包中的内容,分为interface summary,class summary,exception summary和error summary等,如果想看包中各类的继承结构,可以选择最上面的菜单中的tree,就可以了解包中的总体结构。当选择一个类进入后,可以看到如下的内容(Double类的说明):

    java.lang //包名

    Class.Double //类名

    Java.lang.Object //继承结构:java.lang包中的Double类的直接父类

    | //是java.lang中的Number类

    +--java.lang.Number //Number类的父类是java.lang中的Object类

    |

    +--java.lang.Double

    All Implemented Interfaces: //这个类实现的接口

    Comparable,Serializable

    然后就是属性、方法、构造函数的概述表(summary),最后是属性、方法、构造函数的详细说明。

  • 相关阅读:
    jmeter如何引用自己编写的java文件编译的jar包
    Vue+Django REST framework 打造生鲜电商项目(学习笔记二)
    mysql笔试题
    面试遇到的问题
    Idea中maven项目pom文件中已引入testng但项目文件中无法引入@Test
    记录一次TestNg+MyBatis中的SqlSession出现的问题,问题虽然解决了但尚未明白问题原因
    PyMySQL的基本操作
    MySQL循环语句
    Vue父子组件和非父子组件间的通信
    Python的静态方法和类成员方法
  • 原文地址:https://www.cnblogs.com/liangxiaofeng/p/5678370.html
Copyright © 2020-2023  润新知