Java基础--异常、包、Eclipse介绍

admin管理员组

文章数量:1531424

第一讲 异常

一、异常的概述
1、异常：就是程序在运行时出现不正常情况
异常的由来：异常是Java中的重要机制，也使用了面向对象的思想，进行了封装。我们通常使用的异常类。而异常类中所描述的就是程序中可能出现的错误或者问题
2、问题分为两类：一种是严重的问题，一种非严重的问题。

对于严重的，java通过Error类进行描述。
    对于Error一般不编写针对性的代码对其进行处理。

对与非严重的，java通过Exception类进行描述。
    对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

Throwable
    |--Error
    |--Exception

3、异常的处理

java 提供了特有的语句进行处理。
try
{
    需要被检测的代码；
}
catch(异常类 变量)
{
    处理异常的代码；(处理方式)
}
finally
{
    一定会执行的语句；
}

4、异常体系的特点

 1、异常体系中的所有类以及建立的对象都具备可抛性。
 2、也就是说可以被throw和throws关键字所操作。
 3、只有异常体系具备这个特点。

二、异常的分类
1、异常分两类

 1、编译时被检测异常
              该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。

实例：
class Demo
{
    //算数异常
    int div(int a ,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
                                                            //1--->在功能上通过throws的关键字
                                                            //声明了该功能有可能出现问题
                                                            //相当于声明我这个功能有问题
    {

            //在造一个异常
            int [] arr=new int[a];//数组越界异常
            System.out.println(arr[4]);
            return a/b;//new AritchmeticException
    }
}
class ExceptionDemo 
{
    public static void main(String[] args)   // throws  Exception//给他的上一层
    {
        Demo demo=new Demo();
        //不论出现啥情况都使用try  catch----》预先的处理方式
        //最基本的方式
        try
        {
            //new AritchmeticException
            int x=demo.div(2,0);//出现异常的地方
            System.out.println("x="+x);
        }
        catch (ArithmeticException e)
            //Exception e=new ArithemicException();
        {
            System.out.println("被除零");
            System.out.println(e.getMessage());//by zero
            System.out.println(e.toString());//异常名称：异常信息
            e.printStackTrace();//异常名称：异常信息，异常出现的位置
                                        //其实jvm默认的异常处理机制，就是调用printStackTrace方法
                                        //打印异常的堆栈的跟踪信息
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("数组越界！！！");
        }

    //  int x=demo.div(4,1);//这个情况必须抛出去，不然出错
                                        //如果int x=demo.div(4,0);又会出现问题，所以主函数的抛出也会影响程序的运行，因为它抛给jvm，jvm也无法处理程序就挂了
        //System.out.println("x="+x);
        System.out.println("over!");

    }
}


 2、运行时异常(编译时不检测)，一般是RunTimeException异常
实例：
package cn.itcast;

public class ExceptionDemo {
    public static void main(String[] args) {
        double x=ExceptionDemo.DivisionDemo(1, 0);//出现by zero异常，但是编译通过，程序停止
        System.out.println(x);

    }

    //定义除法方法
    private static  double DivisionDemo(int a,int b)
    {
        return a/b;
    }
}

三、异常的格式和注意事项
1、异常的格式

    a、try
             {
             }
             catch ()
             {
             }
        b、try
             {
             }
             finally
             {
             } 
        c、try
             {
             }
             catch ()
             {
             }
             finally
             {
             } 
 实例：c的格式，分母不能是负数
class FuShuException extends Exception//异常的自定义
{
    FuShuException(String msg)
    {
        super(msg);
    }
}
class Demo1
{
    int div(int a,int b) throws FuShuException
    {
        if(b<0)
        {
            throw new FuShuException("出现除数是负数！！！");
        }
        return a/b;
    }
}
class  ExceptionDemo1
{
    public static void main(String[] args) 
    {
        //用try catch  finally处理
        Demo1 d=new Demo1();
        try{
                int x=d.div(4,-1);
                System.out.println("x="+x);
            }catch(FuShuException e)
            {
                System.out.println(e.toString());
                System.out.println("出现负数异常");
            }finally{
                    System.out.println("over");一定执行
            }

    }

}
注意：
        1）finally中定义的通常是关闭资源代码。因为资源必须释放。
        2）如果在一个功能中，定义了一些必须要执行的代码，可以用try{}finally{}的方式，将一定执行的代码放在finally代码块中。
        3）finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
2、throw和throws的用法
        throw定义在函数内，用于抛出异常对象。
        throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开，如：int div(int a,int b) throws FuShuException
        当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。
        注意：RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
3、调用者对抛出信息的处理
        当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。
        一般情况下，函数内出现异常，函数上需要声明。在功能上通过throws的关键字声明了该功能有可能会出现异常类型。
特殊之处：
        Exception中有一个特殊的子类异常RuntimeException 运行时异常。
                1） 如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。
                2）如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过。
        之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
         如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。
对捕获到的异常对象进行常见方法操作：
        String getMessage（）；//获取异常的信息。返回字符串。
        toString（）；//获取异常类名和异常信息，返回字符串。
        printStackTrace();//获取异常类名和异常信息，以及异常出现在程序中的位置.返回值void.
                                //其实JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。
        printStackTrace(PrintStream s)//通常用该方法将异常内容保存在日志文件中，以便查阅。

四、自定义异常
1、因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对这些特有的问题可以按照java中的面向对象思想。将特有的问题，进行自定义的异常封装。定义类继承Exception或者RuntimeException
1，为了让该自定义类具备可抛性。
2，让该类具备操作异常的共性方法。
这就叫做自定义异常。
当自定义了异常类继承Exception后，如果未在类中定义异常信息，那么通过toString方法打印出来的结果就只有自定义的异常类名，不会显示异常信息。那么应该如何定义异常信息呢？
要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。
2、继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

Throwable
     |--Erroe
     |--Exception
          |--RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性
只有这个体系中的类和对象才可以被throws和throw操作。

3、自定义负数异常

class FuShuException extends Exception //getMessage();
{
    private int value;

    FuShuException()
    {
        super();
    }
    FuShuException(String msg,int value)
    {
        super(msg);
        this.value = value;
    }

    public int getValue()
    {
        return value;
    }

}



class Demo
{
    int div(int a,int b)throws FuShuException
    {
        if(b<0)
            throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。

        return a/b;
    }
}


class  ExceptionDemo3
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,-9);
            System.out.println("x="+x);     
        }
        catch (FuShuException e)
        {
            System.out.println(e.toString());//打印异常信息
            //System.out.println("除数出现负数了");
            System.out.println("错误的负数是："+e.getValue());
        }



        System.out.println("over");

    }
}

五、异常的好处和原则
1、异常的好处

好处：
        1、将问题进行封装。
        2、将正常流程代码和问题处理代码相分离，方便于阅读。

2、异常的原则

原则：
        1、处理方式有两种：try或者 throws。
        2、调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
        3、多个catch时，父类的catch放到最下面。否则编译会报错，因为其余的catch语句执行不到。
        4、catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

3、 如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生后和本功能相关的问题提供出去，让调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。这样就好比在给别人转账时，如果ATM机出现故障，这时可以另外找地方去转，也可以告诉对方，转账不成功。
如：

try  
{  
         throw new AException();  
}  
catch (AException e)  
{  
         // 对AException处理。  
         throw new BException();  
}  

4、异常的注意事项
1、问题在内部被解决就不需要声明。
2、catch是用于处理异常。如果没有catch就代表异常没有被处理，如果该异常是检测时异常。那么必须声明。
3、异常在子父类覆盖中的体现

1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类

    Exception 
          |--AException(父类抛出这个异常)
                |--BException（继承）
    CException
        子类只能抛出  A、B,不能抛出C
        如果子类真的出现C异常，那么子类必须内部处理，不能抛出
    2、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子类
    3、如果父类或者接口的方法中没有异常抛出，那么子类覆盖方法时也不可以抛出异常，
            如果子类方法发生了异常，就必须要进行try处理，绝对不能抛


实例：class AException extends Exception  
{  
}  

class BException extends AException  
{  
}  

class CException extends Exception  
{  
}  

/*上面代码的继承关系 
Exception  
    |--AException 
        |--BException 
    |--CException 
*/  
class Fu  
{  
    void show()throws AException  
    {  
    }  
}  

class Test  
{  
    void function(Fu f)  
    {  
        try  
        {  
            f.show();  
        }  
        catch (AException e)  
        {  
        }  
    }  
}  

class Zi extends Fu  
{  
    void show()throws CException  
    {  
        //如果这里子类抛出CException，父类中的catch就无法处理，  
        //这样就会导致编译失败，所以子类只能继承父类中的异常或子集  
    }  
} 

六、自定义异常练习（Exception）

实例：

/*
毕老师用电脑上课。

开始思考上课中出现的问题。
比如问题是
    电脑蓝屏。
    电脑冒烟。

要对问题进行描述，封装成对象。


可是当冒烟发生后，出现讲课进度无法继续。

出现了讲师的问题：课时计划无法完成。


*/

class LanPingException extends Exception
{
    LanPingException(String message)
    {
        super(message);
    }
}

class MaoYanException extends Exception
{
    MaoYanException(String message)
    {
        super(message);
    }
}


class NoPlanException extends Exception
{
    NoPlanException(String msg)
    {
        super(msg);
    }
}

class Computer
{
    private int state = 3;
    public void run()throws LanPingException,MaoYanException
    {
        if(state==2)
            throw new LanPingException("蓝屏了");
        if(state==3)
            throw new MaoYanException("冒烟了");

        System.out.println("电脑运行");
    }
    public void reset()
    {
        state = 1;
        System.out.println("电脑重启");

    }
}

class Teacher
{
    private String name;
    private Computer cmpt;

    Teacher(String name)
    {
        this.name = name;
        cmpt = new Computer();

    }

    public void prelect()throws NoPlanException
    {
        try
        {
            cmpt.run();         
        }
        catch (LanPingException e)
        {
            cmpt.reset();
        }
        catch (MaoYanException e)
        {

            test();
            throw new NoPlanException("课时无法继续"+e.getMessage());

        }
        System.out.println("讲课");
    }
    public void test()
    {
        System.out.println("练习");
    }

}



class ExceptionTest 
{
    public static void main(String[] args) 
    {
        Teacher t = new Teacher("毕老师");
        try
        {
            t.prelect();
        }
        catch (NoPlanException e)
        {
            System.out.println(e.toString());
            System.out.println("换老师或者放假");
        }

    }
}

七、自定义RuntimeException异常练习

实例：
/*
异常的练习：
        图形的面积
*/

class NoValueException extends RuntimeException
{
    NoValueException(String message)
    {
        super(message);
    }
}
 interface Shape
{
    void getArea();
}
class Rec implements Shape
{
    private double len,wid
    Rec(double len,double wid)
    {
        if(len<=0||wid<=0)
        {
            throw new NoValueException("出现非法值");
        }
        else
        {
            this.len=len;
            this.wid=wid;
        }
    }
    public void getArea()
    {
        System.out.println(len*wid);
    }
}
//圆形的面积
class Circle implements Shape
{
    private int radius;
    public static final double PI=3.14;
    Circle(int radius)
    {
        if(radius<=0)
        {
            throw new NoValueException("非法");
        }
        else
        {
            this.radius=radius;
        }
    }
    public void getArea()
    {
        System.out.println(radius*radius*PI);
    }
}

class ExceptionTest
{
    public static void main(String[] args) 
    {
        Rec r=new Rec(3,4);
        r.getArea();
    }
}

第二讲 包

一、package
1、定义包

使用package关键字在类的第一条语句定义包名
包名必须全部小写, 一般用域名

2、编辑带包的类和默认包

1、编辑带包的类
javac -d <目录> 源文件名.java
例如: javac -d . Person.java 编译到当前目录
2、默认包
如果一个类没有加上package关键字定义包名, 它是在一个默认的包中,以前我们使用的类都没有定义包, 默认都在同一个包中, 互相直接可以直接访问
如果两个类定义了包, 并且是相同的包, 也可以直接访问

3、包的作用

   1、为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。
   2、对类文件进行分类管理，可以将相关的一些类放在同一个包中。
   3、给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：a.Demo demo=new a.Demo（）；
   4、包的出现可以将java的类文件和源文件相分离。

4、包的访问权限

        1、要访问其他包中的类，需要定义类的全称：包名.类名。
        2、包如果不在当前路径，需要使用classpath设定环境变量，为JVM指明路径。
        3、被访问的包中的类权限必须是public的。
        4、类中的成员权限：public或者protected。protected是为其他包中的子类提供的一种权限。类公有后，被访问的成员也要公有才可以被访问。不同包中的子类可以直接访问父类中被protected权限修饰的成员。同一个包中，protected只作用为覆盖。

注：一个.java文件里面，不能出现两个以上的公有类或者接口。因为被public修饰的类名必须与java文件名相同。

四种权限：

5、包的导入

        1、可以简化类名。在调用其他包中的类时，需要写类的全称，也就是连同包名一起书写。当类存在多层包中时，如：haha.hehe.pack.Demo，使用import导入后，使用其类时，就可以不加包名了。导入格式如：import haha.hehe.pack.Demo;
        2、一个程序文件中只有一个package，可以有多个import。import导入的是包中的类，不导入包中的包。
        3、注意事项：
               a，在导入包时，如果包中有很多类，可以使用通配符 *来替代包中的所有类。但是，建议不要使用通配符 * ，因为将不需要使用的类导入后，会占用内存空间。所有在编写程序时，要使用包中的哪些类，就导入哪些类。
               b，定义包名不要重复，可以使用url来完成定义，url是唯一的。如：package cn.itheima.Demo。
               c，导入的不同包中有相同类时，必须写类的全名以区分，否则将会报错。

6、jar包
1）、jar包概述

   类越来越多，我们可以用包来装，当包越来越多时，我们可以将包进行压缩。而java中用jar这个工具来对包进行压缩。压缩后的后缀名为jar。
jar.exe工具的一些命令：
        创建jar包
                jar  -cvf  mypack.jar packa packb
        查看jar包
                jar  -tvf  mypack.jar  [>定向文件]
        解压缩
                jar  -xvf  mypack.jar
        自定义jar包的清单文件
                jar –cvfm  mypack.jar mf.txt  packa packb
jar包的好处：
        1、 可以将多个包进行压缩到为一个文件。方便项目的携带。
        2、 方便于使用，只要在classpath设置jar路径，即可以执行jar包中的java程序。
        3、 数据库驱动，SSH框架等都是以jar包体现的。

2）、练习

实例：

package pack;
import packa.*;
class JarDemo 
{
    public static void main(String[] args) 
    {
        DemoA a = new DemoA();
        a.show();
        System.out.println("Hello jar pack!");
    }
}

第三讲 Eclipse介绍

一、Eclipse概述

(1)eclipse的由来
A：由IBM一个小组开发。投资4千万美元.
(2)eclipse的特点
A：完全由Java语言编写的工具。
B：不需要安装
C：免费的，eclipse
D：开源的
E：扩展性非常强
(3)eclipse和MyEclipse的区别
A：MyEclipse是基于eclipse加入了一些用于开发Web的插件,并对这些自己开发的插件进行收费。
B：特点 MyEclipse集成性很好。收费。
(4)在使用eclipse之前，系统中必须要先有JDK或者JRE。

A:因为eclipse就是用Java语言编写的程序，所以需要jvm的解释执行。

B：对于高版本的MyEclipse，内部已经集成了JDK。所以安装后，它会用自己的JDK来执行MyEclipse。

(5)解压eclipse,双击打开,选择工作空间

第一:如果在Use this as the default and do not ask again这句话前面打勾意思就是下次启动的时候会默认选择这个指定好的,不会再有这个提示
第二:如果还想再换工作空间路径,通常有很多人会这样做,就是把eclipse的压缩包再重新解压一下,但是我们还可以这样做
Windows-->Preferences-->General-->Startup and Shutdown-->Workerspaces-->Prompt for workspace on startup前面打勾,重启eclipse就可以了
(6)Eclipse的安装与汉化 重点

A：解压即可。
B：汉化的方式：
直接解压，并覆盖即可。但是不建议这样做，这样做的，如果我不想汉化，想还原起来就麻烦了。
步骤如下：
在eclipse目录下建立文件夹links
在links下面建立一个文件名字任意。比如 cn.txt(文件名随意起)
在cn.txt中写如下内容(根据你插件包的位置而定)path=D:\china\eclipse
启动或者重新启动eclipse。

二、Eclipse组成

整体叫做视图，每一个小窗口叫做视窗。在eclipse中要想爽一下，必须先有项目(工程)。
(1)视图，视窗
(2)视图就是某些视窗的组合。
A：Java视图
B：Debug视图
C：JavaEE视图
(3)视图还原
在视图操作中，我有可能有误操作。这个时候怎么办？
Window--Reset重置视图

三、Java透视图

(1)Package Explorer 包资源管理器
A：该视图中显示当前工作空间中的所有项目以及项目中的文件。但不显示项目下bin目录中的运行文件。
B：可以直接在该视图中创建项目，包，类，接口等。
(2)Outline 大纲视窗
A：该视图中显示当前代码视图中源文件中定义的类或者接口。以及定义的所有成员。
B：当代码过长时，查找代码中的某一个类或者成员，在该视窗中是最方便的。
C：在代码中出现多次的名称要同一更改，也可以在该视窗中完成。同时其他代码如果使用了该变量，那么也会一并改变。
(3)Console 控制台视窗
A：用于显示程序的运行结果，相当于DOS命令。
B：如果有多个控制台同时运行。比如：服务器端和客户端。可以通过控制台上的小屏幕按钮进行控制台的切换。
C：通过点击小方框，进行控制台的强制停止，相当于DOS中的Ctrl+C。
(4)Hierarchy 层次视窗
A：用于显示类之间的层次(继承)关系。
B：在当前类上，按F4就可以切换到该视窗，并查看层次关系。
查看原码，当前类上F3，或者Ctrl+鼠标点击

4、工作空间的基本配置

注意：在工作空间的设置对于该空间中的所有项目都有效。更换了工作空间，需要重新设置。
(1)配置Java的编译和运行环境版本
windows--perference-Java
Compiler 设置成5.0以上，要和运行环境版本一致。
Installed JREs：可以指定多个jre环境，但是仅有一个是当前执行的。要和编译器一致，或者高于编译器版本。
如果采用高版本编译，用低版本jre运行，会出现异常。
(2)代码视窗加上行号。
A：首选项--常规--编辑器--文本编辑器
B：在当前类中，左侧，右键。Show Line Numbers
(3)调整字体
windows--perference(首选项)-General(标准)--Appearance(外观)--Color and Fonts(颜色和字体)
右边选择Java。编辑即可。
字体选择 Courier New 比较标准，个人爱好
(4)取消悬浮提示

在首选项设置面板中
Java--Editor--Hovers。
右边将Combined Hover勾去掉。

这样代码的悬浮框就不会自动出现了。

如果想看提示，将光标悬浮在代码上，按F2即可。
(5)取消默认注释
在首选项设置面板中
Java--Code Style--Code Templates
右边选择Code，将不希望出现默认注释的代码块中的注释去掉。
(6)类名高亮 可以这样配置在“java”→“enditor”→“syntac”，右边展开“java”→“classes”，勾上“Enable”这个选项，选择自己喜欢的颜色即可。
(7)preference->general->editors->texteditor selection backgroud color

五、Eclipse常用的快捷开发操作

(1)创建面板 定义类和接口，权限，父类已经实现的接口等。

syso:然后alt+/就能出现输出语句(回车 到行尾,shift+回车 到下行的行首),如果单独敲回车就是到下行的行首
main:然后alt+/就能出主方法
自己也可以定义。
步骤:windows--perference-Java-Editor-Templates--New
(2)常用的快捷键 (A,E,F必须掌握)

A：alt+/ 内容辅助键,补充类或者接口名，帮我们起变量名，new 后面直接提示等。
B：ctrl+/ 单行注释，再按一次，取消单行注释
C：ctrl+shift+/ 对选中的区域进行多行注释的封装
D：ctrl+shift+\ 用于取消多行注释，只要光标在多行注释中即可
E：ctrl+shift+o 对使用了其他包中的类或者接口进行自动导入
F：ctrl+shift+f 对代码进行格式化
G: ctrl + alt + 上键 向上复制当前行或选中行
H: ctrl + alt + 下键 向下复制当前行或选中行
I：alt+上键 向上移动当前行或者选中行
J：alt+下键 向下移动当前行或者选中行
K：ctrl+d 删除当前行，或者删除选中行
L：ctrl+shift+x 将选中部分的字母大写
M：ctrl+shift+y 将选中部分的字母小写
N：ctrl+1 光标放在编译中出现红色波浪线提示的内容上，在该快捷键可以获取建议的处理方式

六、代码生成的快捷键alt+shift+s

出现source
1：在区域中右键
2：alt+shift+s
(1)私有字段的get/set 重点 (2)构造方法 (3)重写父类方法 重点 @Override 注解 表明此方法是重写父类的.

(4)添加注释 /** 回车 (5)方法的重构 右键--refactor--Extract Method

int sum = a + b;
System.out.println(sum);

选中a+b 扩展可以生成带返回值的。

七、Debug调试

注释找错误
输出打印调试程序
程序不是写出来的,是改出来的.
(1)让我们调试程序更加方便
(2)想要调试，需要在程序中加入断点
(3)运行debug as，打开debug视图
(4)快捷键
f5:跳入
f6:跳过
f7:跳出
(5)清除断点
在Breakpoints视窗中清除指定断点或者所有断点。

八、打jar包，导入jar包，及jar包的使用

1：打jar包。
选中项目--右键--Export--Java--jar--next--自己写jar包的名字和选择路径--finish.
2:jar包的使用。
导入jar包
1:单独添加jar，
把jar复制,然后粘贴到项目路径下
一定要把jar添加至classpath路径中.
怎么添加呢?
右键jar包--添加构建路径 项目下：.classpath文件中可以看到
如果,这写jar不用了,那么,就从构建路径中把jar包移除.
选中项目--右键--首选项--Java Build Path--library--选中其中的jar包,给remove.
2:为了方便管理多个jar包。
通常建立一个目录，名字建立定义为lib。
将jar都存放在该目录下
如果要使用jar包，只要将该jar导入到eclipse的classpath路径下。
右键至添加构建路径 项目下：.classpath文件中可以看到

九、导入已有的项目

空白区域--右键--import--General--Existing Project into Workspace--选中你的项目目录--finish--OK
删除项目中有两种。 选中和不选中删除硬盘上的项目.
请不要选中删除硬盘上的项目。

本文标签： 异常基础JavaEclipse