Java从入门到精通

子主题

Java简介

Java语言的特性

搭建Java环境

初识Java

打开浏览器下载：Eclipse Downloads | The Eclipse Foundation 找到下载好的文件进行解压

下载Eclipse

熟悉Eclipse

使用Eclipse

程序调试

熟悉Eclipse开发工具

Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性与方法两部分每一个应用程序都必须包含一个main（）方法，含有main（）方法的类称为主类。        创建主类并调用其主方法        在Eclipse下依次创建项目item、包Number和类Frist。在类体中输入以下代码，实现在控制台上输出“你好 Java”。public class Frisit {    static String s1 = \"你好\"; public static void main(String[] args) {  // TODO Auto-generated method stub        String s2 = \"Java\";        System.out.println(s1);        System.out.println(s2); } }

Java主类结构

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int和long4种类型。它们具有不同的取值范围。long型需要在整数后面加L或者l(小写L)；float型则需要在小数后面添加F或f

整数类型

浮点类型简称浮点型，用来存储含有小数部分的数值。Java语言中浮点类型分为单精度浮点型类（float）和双精度浮点类型（double），它们具有不同的取值范围。

浮点类型

用于存储单个字符，占用16位（两个字节）的内存空间。在定义字符型变量时，要以单引号表示，如's'表示一个字符。查看字符与Unicode码互转的结果

字符类型

布尔类型只有true和font color=\"#ec7270\

布尔类型

在Java中有8种基本类型来存储数值、字符和布尔值，分为：数据型，字符型，布尔型。数据型又分为整数类型和浮点类型整数类型：byte、short、int、long浮点类型：float、double

基本数据类型

标识符标识符可以简单的理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。标识符由任意顺序的字母、下划线（-）、美元符号（$）、和数字组成。注：不能以数字开头；标识符要避开关键字；变量名中不能有斜杠。

关键字

标识符和关键字

其值能被改变的量称为变量。变量与常量的命名都必须使用合法的标识符。

变量与常量

使用赋值运算符同时为两个变量赋值font color=\"#a7932c\

赋值运算符

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余）。其中，“+”和“-”运算符还可以作为数值的正负值的正负符号。

算术运算符

++a：先运算后使用a++：先使用后计算

自增和自减运算符

比较运算符

true&&true==true         true&&false==false        false&&false==false

&&：两者都为真，结果就为真

&&、&：与

true||true==true        true||false==true                false||false==false

||：只要有一者为真，结果就是真

||：或

|true==false                |false==true

| ：非真即假非假即真

！：非

运行结果如下

public class Calculation { public static void main(String[] args) {  // TODO Auto-generated method stub  int boys = 15;//男生人数  int girls = 17;//女生人数  int totle = boys + girls;//总人数  boolean result1 = ((boys > girls)&&(totle>30));//男生人数多于女生，且总人数大于30  boolean result2 = ((boys > girls)||(totle>30));//男生人数多于女生，或总人数大于30  System.out.println(\"男生人数大于女生人数并且人数大于30人：\"+result1);//结果输出  System.out.println(\"男生人数大于女生人数或者人数大于30人：\"+result2); }}

使用不同的比较运算符判断两个整数的关系：     代码如下：

逻辑运算符

>>>两者都为1，结果才是1

&(按位与)：

|（按位或）：

两者相同即为0，不同则为1

^（按位异域）：

~（按位取反）：

左边最高位是符号位，最高位是0表示正数，若为1则表示负数，负数采用补码表示

整体左移空位补0，溢出去掉

font color=\"#e74f4c\

整体右移，正数补0，负数补1，溢出去掉

整体右移，空位补0，负数补1，溢出去掉

>>>，无符号右移：

移位操作

位运算符

三元运算符的使用格式为：返回值=判断公式？结果1：结果2三元运算符的运算规则为：若条件式的值为true，则整个表达式取结果1，否则取结果2.三元运算符等价于if...else语句

三元运算符

优先级由高到低的顺序依次是:增量和减量运算。算术运算。比较运算。逻辑运算赋值运算。

运算符优先级

运算符

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高排列的顺序为byte<short<int<long<float<double。隐式转换也要遵循一定的规则，在什么情况下将那种类型转换成另一种类型的数据。表3.10列出了各种数据类型隐式转换的一般规则。

隐式类型转换

也叫强制类型转换，有可能会丢失数据。当把高精度的变量的赋值给低精度的变量时，必须使用显式类型转换运算。语法如下：（类型名）要转换的值

显式类型转换

数据类型转换

Java语言基础

复合语句

条件语句

while循环语句

do...while循环语句

for循环语句

循环语句

流程图：

语法：for（表达式1；表达式2；表达式3）{        语句序列}

可以用来重复执行某条语句，直到某个条件得到满足

语法：do{        语句序列}while（条件表达式）

与while循环语句相似，区别在于while语句先判断条件是否成立再执行循环体，do...while循环语句则先执行溢出循环后，再判断条件是否成立

语法：while（条件表达式）{        语句序列}

是条件判断语句，当表达式的返回值为真是，则执行语句，重新判断条件表达式的返回值，知道返回值的结果为假时，退出循环

break语句

continue语句

循环控制

跳出本次循环

流程图

跳出当前循环

流程控制

在使用复合语句时要注意：复合语句为局部变量创建了一个作用域，该作用域为程序的一部分，在该作用域中某个变量被创建并能够被使用。否则会发生错误。

JAVA语言的复合语句是以整个块区为单位的语句，复合语句由开括号\"{\"开始，闭括号\"}\"结束。例如，在定义一类或方法时，类体就是以“{”与“}”作为开始与结束的标志，方法体同样也是以“{”与“}”作为标记。复合语句中的每个语句都是从上到下被执行。复合语句以整个块为单位，能够用在任何一个单独语句可以使用的地方，并且在复合语句中还可以嵌套复合语句。

if条件语句

switch多分支语句

条件语句可根据不同的条件执行不同的语句。条件语句包括if条件语句与Switch多分支语句。

运行结果如下：

例题：        public class TakePhone {  public static void main(String[] args) {  // TODO Auto-generated method stub  int phoneNumber = 123456789;//创建变量，保存电话号码  if (phoneNumber!= 84972266) {//如果此电话号码不是84972266   System.out.println(\"对不起，您拨打的号码不存在！\");//提示号码不存在  }  } }

语法：if{          语句序列         }

简单的if条件语句

if…else语句

if…else if多分支语句

if条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句

语法：if（条件表达式）{           语句序列1}else{         语句序列2}

语句针对于某种条件有选择地做出处理，“如果满足某种条件，就进行某种处理，否则就进行另外一种处理

运行结果如下:

例题：                                                                                                       public class Restaurant { public static void main(String[] args) {  // TODO Auto-generated method stub  System.out.println(\"欢迎光临，请问有多少人用餐?\");//输出问题提示  int count = 9;//用餐人数  System.out.println(\"回答：\"+count+\"人\");//输出答案  if(count<= 4) {//如果人数小于4人   System.out.println(\"客人请到大厅4人桌用餐\");//请到4人桌  }else if(count>4&&count<=8) {//如果人数在4~8人   System.out.println(\"客人请到大厅6桌用餐\");//  }else if(count>8&&count<=16) {//如果人数在8~16人   System.out.println(\"客人请到大厅8桌用餐\");//请到包间  }else {//当以上条件都不成立时，执行该语句块   System.out.println(\"抱歉，我们店暂时没有这么大的包间!\");//输出信息  } }}

语法：if（条件表达式）{           语句序列1}else if{条件表达式2        语句序列2}…else if（条件表达式n）{            语句序列n}

用于针对某一事件的多种情况进行处理，“如果满足某种条件，就进行某种处理，否则如果满足另一个条件则进行另一种处理

例题：import java.util.Scanner;//引入scanner类public class Zww{  public static void main(String[] args) {   Scanner sc= new Scanner(System.in);//建立扫描仪，接收控制台输入的数字  System.out.print(\"请输入成绩:\");//输出\"请输入成绩\"  int grade=sc.nextInt();//定义一个int型变量grade获取控制台输入的数字  switch(grade){//使用switch判断数字   case 10://如果等于10  case 9://如果等于9  System.out.print(\"成绩为优\");//输出成绩为优  break;//结束判断  case 8://如果等于8   System.out.print(\"成绩为良\");//输出成绩为良  break;//结束判断  case 7://如果等于7  case 6://如果等于6  System.out.print(\"成绩为中\");//输出成绩为中  break;//结束判断  case 5://如果等于5  case 4://如果等于4  case 3://如果等于3  case 2://如果等于2  case 1://如果等于1     case 0://如果等于0  System.out.print(\"成绩为差\");//输出成绩为差   break;//结束判断  default://如果不符合任何一个结果  System.out.print(\"成绩无效\");//输出成绩无效  }  sc.close();  }}

检测一个变量是否符合某个条件，如果不符合，再用另外一个检测，以此类推。switch 语句首先计算表达式的值，如果表达式的计算结果和某个 case 后面的常量值相同，则执行该 case 语句后的若干个语句直到遇到 break 语句为止。此时，如果该 case 语句中没有 break 语句，将继续执行后面 case 中的若干个语句，直到遇到 break 语句为止。

一维数组

二维数组

遍历数组

例题：font color=\"#a7932c\

1.fill（int【】a，int value）

2.fill（int【】a，int  fromlndex，int  tolndex，int  value）

填充替换数组元素

例题：  font color=\"#a7932c\

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromlndex（包括）一直到索引tolndex（不包括）。如果fromlndex=tolndex，则填充范围为空。

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：Arrays.sort(object)

对数组进行排序

该方法提供了多种重载形式，用于满足不同类型数组的复制。语法如下：copyOf（arr，int newlength）复制数组：空位补0，溢出去掉新数组名=Arrays.copOf(旧数组名，新数组长度)；

1.copyOf（）方法

复制数组部分元素：前在后不在新数组名=Arrays.copysOfRange（旧数组名，前索引，后索引）；

2.copyOfRange（）方法

复制数组

查询数组

数组的基本操作

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历二维数组需使用双层for循环，通过数组的length属性可获得数组长度。在遍历数组时，使用foreach语句可能会更简单。

1.binarySearch（Object【】a，Object   key）语法如下：查询数组：先排序再查询索引=Arrays.binrySearch（数组名，值）；

例题：import java.util.Arrays;//导入java.util.Arrays类 public class Rakel {//创建类     public static void main(String[] args) {//主方法        // TODO Auto-generated method stub        String str[]=new String[] {\"ab\

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

冒泡排序

直接选择排序

反转排序

数组排序算法

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法

例题font color=\"#a7932c\

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

数组

使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0.数组元素赋值数组【索引】=值；数组名【】

分配内存空间font color=\"#7bd144\

先声明，再用new关键词进行内存分配一维数组有下列两种形式。数组元素类型     数组名字【】；数组元素类型【】  数组名字；

数组作为对象允许使用new关键词进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。一维数组的创建有两种形式。

例题：public class Matrix {//创建类     public static void main(String[] args) {//主方法        // TODO Auto-generated method stub        int a[][]=new int[3][4];//定义二维数组        for (int i=0;i<a.length;i++){            for(int j=0;j<a[i].length;j++) {//循环遍历数组中的每一个元素                System.out.print(a[i][j]);//将数组中的元素输出        }            System.out.println();//输出空格    } }}

1.先声明，再用new关键字进行内存分配元素的类型    数组名字【】【】；数组元素的类型【】【】   数组名字；2.内存分配二维数组分配内存new  数组元素的类型【行数】【列数】二维数组分配内存同时设置初始值font color=\"#e855a4\

如果一组数组中的各个元素任然是一个数组，那么它就是一个二维数组，二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列二维数组可以看作是特殊的一维数组，因此二维数组的创建同样有两种方式。

对象是事物存在的实体，现实世界中，随处可见的一种事物就是对象。静态部分：不能动的部分，被称为“属性”动态部分:   即对象可执行的动作，称为“行为”

对象

类就是同一事物的统称，如果将现实世界中的一事物抽象成对象，类就是这类对象的统称。 类是对象的设计图；类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

类

面向对象程序设计具有以下特点：封装性、继承性和多态性。 封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。 采用封装的思想保证了类内部数据结构的完整性，提高了程序的可维护性。

封装

类与类之间同样具有关系，这种关系被称为关联。两个类之间的关系有很多种，继承是关联中的一种。设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率。继承性主要利用特定对象之间的共同属性。

继承

将父类对象应用与子类的特征就是多态。提到多态，就不得不太抽象类和接口，因为多态的实现并不依赖与具体类，而是依赖与抽象类和接口。

多态

面向对象概述

在Java中，对象的属性也称为成员变量，成员可以是任意类型，整个类中均是成员变量作用范围。public class Book{//类    private String name;//String类型的成员变量    public String getName() {//name的Getter方法        return name;    }    public void setName(String name) {//name的Setter方法        this.name=name;//将参数值赋予类中的成员变量    }    } 在Java语言中需要使用class关键词来定义类，Book是类的名称。

成员变量

在Java语言中，使用成员方法对应于类对象的行为。定义成员方法的语法格式如下：权限修饰符  返回值类型  方法名（参数类型  参数名）{....                     //方法体return  返回值；}

成员方法

权限修饰符

如果在成员方法内定一个变量，那么这个变量被称为局部变量。实际上方法中的形参也可作为一个局部变量。Book类中定义setName（String name）方法，String name这个形参就被看作是局部变量。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

局部变量

局部变量的有效范围

局部变量及其有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

this关键字

Book类中定义setName()方法代码如下：public void setName(String name){ //定义一个setName()方法this.name=name; //将参数值赋予类中的成员变量}

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键词只能在本类中使用。

类的构造方法

静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循着public、private和protected修饰符的约束。            总结以下使用static关键字要注意的几点：1、在静态方法中不可使用this关键字。2、在静态方法中不可以直接调用非静态方法。3、局部变量不可以使用static关键字声明。4、主方法必须用static声明。5、只有内部类可以使用static关键字声明。

由static修饰的变量和方法被称为静态变量和动态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员。语法如下：类名.静态类成员

静态变量和静态方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的语法如下：public static void main(String[] args) {...... //方法体}在主方法的定义中可以看到其具有以下特点：1、主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。2、主方法没有返回值。3、主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。

类的主方法

类和对象

例题：public class EggCake {        int eggcake;//鸡蛋灌饼里蛋的个数        public EggCake(int eggCount) {//参数为鸡蛋灌饼里蛋的个数的构造方法        this.eggcake=eggCount;//将参数eggCount大的值付给属性eggCount    }        public EggCake() {//无参数构造方法，默认给饼加一个蛋        //调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1        this(1);    }     public static void main(String[] args) {        // TODO Auto-generated method stub        EggCake cake1=new EggCake();        System.out.println(\"顾客不要求加蛋的数量，饼里会有\"+cake1.eggcake+\"个蛋。\");        EggCake cake2=new EggCake(2);        System.out.println(\"顾客要求加2个蛋，饼里会有\"+cake2.eggcake+\"个蛋。\");    } }

构造方法的特点如下：构造方法没有返回值。构造方法的名称要与本类的名称相同。构造方法的定义语法格式如下：public Book(){... //构造方法体}public：构造方法修饰符；Book：构造方法的名称。在构造方法中可以为成员变量赋值，这样当实例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。

在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

对象可以认为是在一类事物中抽象出某一个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中，通过new操作符来创建对象。准确的来说，可以在Java语言中使用new操作符调用构造方法创建对象。语法如下：Test test = new Test();Test test = new Test(\"a\");

对象的创建

用户使用new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应的获取了对象的属性和行为。

访问对象的属性和行为

在Java语言中，尽管一切都可以看作对象，但真正的操作标识符实际上是一个引用，那么引用在Java中是如何体现的呢？语法如下：类名 对象的引用变量一个People类的引用可以使用以下代码：People tom;引用与对象相关联的语法如下：People tom = new People();简单来说，tom是new People()”代理人“。new People().getClass();等价于：People tom = new People();tom.getClass();

对象的引用

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收，在其他语言中，需要用户手动回收废弃的对象， Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。        1、对象引用超过其作用范围，这个对象将被视为垃圾2、将对象赋值为null虽然Java的垃圾回收机制已经很完善，但垃圾回收器只能回收那些由new操作符创建的对象。由于垃圾回收不受人为控制，具体执行时间也不确定，所以 finalize()方法也就无法执行。

对象的销毁

Java是一门面向对象的程序设计语言，对象是由类实例化而来的，所有问题都通过对象来处理。对象可以通过操作类的属性和方法来解决相应的问题，所以了解对象的产生、操作和消亡是十分必要的。

类的继承

它会返回对象执行时的Class实例，然后使用实例调用getClass()方法可以取得类的名称。语法如下：getClass().getname();

getClass()方法

功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString()方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

toString()方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的是两个对象，应用内存地址是否相同，而equals()方法比较的是两个对象的实际内容。

equals()方法

Object类

子类转父类 ，子类对象赋值给父类引用。子类类型的对象直接赋值给父类类型的对象。自动类型转换   语法如下：Animal a = new dog();

向上转型

父类转子类，父类对象赋值给子类引用。可以理解为将父类类型的对象转换为子类类型的对象。但是运用向下转换，如果把一个叫抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误，这时就需要借助强制类型转换。Dog a =(Dog)new Animal();

向下转型

对象类型的转换

第二种使用方法：对象名 instanceof 接口名判断对象是否属于该接口的实现类

语法如下：对象名 instanceof 类名判断对象是否属于该类或其子类。

使用instanceof关键词判断对象类型

方法的重载

final关键词

例题：class Shape{} //图形类class Square extends Shape{} //正方形类继承图形类class Circular extends Shape{} //圆形类继承图形类public class Demo5 { public static void draw(Shape s) { //绘制方法  if(s instanceof Square) { //如果是正方形   System.out.println(\"绘制正方形\");  }else if(s instanceof Circular) { //如果是圆形   System.out.println(\"绘制圆形\");  }else { // 如果是其他类型   System.out.println(\"绘制父类图形\");  } } public static void main(String[] args) {  draw(new Shape());  draw(new Square());  draw(new Circular());  } }

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。下面代码中的这种将子类对象视为父类对象的做法称为“向上转型”。

抽象方法：修饰符  abstract  返回参数  方法名  （传入参数）；抽象方法没有方法体抽象类 ：有抽象方法的类一定是抽象类public abstract void methodName();假设父类是抽象类，子类是普通类，子类继承父类就需要被重写，如果不重写就会报错。承载这个抽象方法的抽象类必须被继承，抽象类除了被继承没有任何意义。作用：继承，制定规则 。

抽象类

所有方法都是抽象方法修饰符 interface 接口名{}实现  implementsJava语言每个类可以实现多个接口，可以单继承，多实现。Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现对各接口。修饰符 class 类名 implements 接口1，接口2，...{}

接口

抽象类与接口

继承、多态、抽象类与接口

在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定长参数方法。定义不定长参数方法语法如下：返回值 方法名(参数数据类型...参数名称)“...”  指的是不定长参数

方法名相同，参数不同（返回参数不同，传入参数不同）

修饰变量——不能被改变（常量）

final变量

修饰方法——不能被重写

final方法

修饰类——不能被继承

final类

final被译为”最后的“”最终的“，凡是被final关键词修饰过的内容都是不可改变的。

Java中每个接口或类都来自不同的类包，无论JavaAPI中的类与接口还是自定义的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。如果没有包的存在，管理程序中的类名称将是一件非常麻烦的事情。如果程序只由一个类组成，自然不会出现类名重叠的问题，但是随着程序的类的数量增多，难免会出现这一问题。编译器不会允许存在同名的类文件。解决这类问题的办法是将这两个类放置在不同的类包中。

类名冲突

在进入eclipse时复制存储的路径然后在文件管理中打开就可以直接进入eclipse保存的文件中查找里面的文件。随意点进去一个文件夹里面会出现不同的其他文件 bin保存的是class文件，src保存的是Java文件创建的包也会出现在src文件夹中。eclipse中所创建的所有类都会同步出现在这些文件中。

完整的类路径

1.在SRC节点上右击，选择new、package命令。

2.弹出Java包对话框，在name文本框中输入新建的包名，如prckage1然后单击完成（finish）按钮

3.在eclipse中创建类时，可以在新建立的包上右击选择新建new命令，作业新建的类就会保存在该包中。另外还可以在新建类时同时修改包名，就可以创建两个不同的包和类

在eclipse中创建包的步骤如下：

创建包

1.使用import关键字导入包如果在程序中使用import关键字导入com.mr.Math类

导入包

Java类包

在一个类中使用内部类，可以在内部类中直接存其所在类的私有成员变量。语法如下：

成员内部类

匿名类是只在创建对象时才会编写类体的一种写法 。匿名类的特点是”现用现写“，其语法如下：

使用匿名类时应该遵循以下原则：1、匿名类不能写构造方法2、匿名类不能定义静态的成员3、如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被Java虚拟机销毁

匿名内部类

内部包

包和内部类

try：try语句块中包含可能出现异常的程序代码catch：语句块用来获取异常信息finally：程序代码块

程序运行的结果发生了算数异常ArithmeticException（根据给出的错误提示可知，发生错误是因为在算数表达式“3/0”中，0作为除数出现）系统不在执行下去，提前结束。这种情况就是所说的异常。

在Java中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

异常概述

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型。可以通过Integer类的 parseInt(方法来实现。但如果该字符串不是数字形式，parseInt)方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

抛出异常

2.finally语句块        完整的异常处理语句一定包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行：在finally语句块中发生了异常。在前面的代码中使用了System.exit（）退出程序。程序所在的线程死亡。关闭CPU。

1.try-catch语句块

通过异常处理器的语法可知，异常处理器大致分为try-catch语句块和finally语句块。

Java语言的异常捕获结构由try、catch和finally3部分组成。其中，try语句存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码块如何退出，都将执行finally语句块。try{     //程序代码块}catch(Exceptiontype1 e){     //对Exceptiontype1 的处理}catch(Exceptiontype2 e){     //Exceptiontype2 的处理}…finally{      //程序代码块}

捕捉异常

异常的抛出与捕捉

在Java中，提供了一些异常类用来描述经常发生的异常。其中，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。

Java常见的异常类

自定义异常的抛出和捕捉：带有int型参数的方法AVG（）

创建自定义异常：//创建异常public class MyException extends Exception{//创建自定义异常，继承Exception类    public MyException(String message) {//构造方法        super(message);//父类构造方法    }}字符串ErrorMessage是要输出的错误信息。若想抛出用户自定义的异常对象，要使用throw关键字

使用Java内置的异常类可以描述创建自定义异常类在方法中通过throw关键字抛出异常对象如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续继续下一步操作。在出现异常的方法的调用者中捕获并处理异常。

自定义异常

使用throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。

使用throws关键字抛出异常

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throw关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。        throw通常用来抛出用户自定义异常。

使用throw关键字抛出异常

在方法中抛出异常

Java 中提供了常见的 RuntimeException 异常，这些异常可通过 try-catch 语句捕获

运行时异常

Java 异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则:在当前方法声明中使用try-catch 语句捕获异常。一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。

异常的使用原则

异常处理

String类

使用”+“运算符可实现连接多个字符串的功能。”+“运算符可以连接多个String对象并产生一个新的String对象。先连接一副对联的上、下联，再分行输出在控制台上。代码如下：

连接多个字符串

字符串也可以同其他基本类型进行连接。如果将字符串同其他数据类型数据进行连接，会将其他数据类型的数据直接转换成字符串。统计每天的阅读和上级时间。代码如下：

连接其他数据类型

连接字符串

使用String类的length（）方法可获取声明的字符串对象的长度。语法如下：str.length();

获取字符串长度

用两种方式判断字符串的长度

1、indexOf(String s)   该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。//查找字符串里第一次出现该元素的位置str.indexOf(\"1\")int indexof=str.indexOf(\"1\");System.out.println(indexof);2、lastIndexOf(String str)      该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf()方法时，或从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。//查找字符串里最后一次出现该元素的位置str.lastIndexOfint lastIndexOf=str.lastIndexOf(\"1\");System.out.println(lastIndexOf);

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置。

字符串查找

使用charAt()方法可将指定索引处的字符返回。//获取指定索引号的字符char charAt=str.charAt(3);System.out.println(charAt);

获取指定索引位置的字符

获取字符串信息

1、substring(int beginIndex)该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如上：font color=\"#e74f4c\

获取子字符串

rim()方法返回字符串的副本，忽略前导空格和尾部空格，语法如下：str.trim()去掉字符串首、尾的空格

去除空格

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，语法如下：font color=\"#4669ea\

字符串替换

判断字符串是否以指定的内容开始或结束

1、startsWith()方法该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：str.startsWith(String prefix)prefix：作为前缀的字符串2、endsWith()方法该方法用于判断当前字符串是否为以给定的字符串结束。语法如下：str.endsWith(String suffix)suffix：作为后缀的字符串

判断字符串的开始与结尾

判断”abc“与”ABC“是否相等

要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法 。1、equals()方法如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：str.equlas(String  otherstr)2、equalsIgnoreCase()方法       使用equlas（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍然为boolean类型。语法如下：str.equalsIgnoreCase(String otherstr)

判断字符串是否相等

判断字母b的位置。代码如下：

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：str.compareTo(String otherstr)

按字典顺序比较两个字符串

字母大小写转换

String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改为大写字母。1、toLowerCase()方法      如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：str.toLower()2、 toUpperCase()方法      如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变，语法如下：str. toUpperCase()

字母大小转换

按要求分割”192.168.0.1“

使用split()方法可以使字符串按指定的分割线字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split（）方法提供了以下两种字符串分割形式。1、split(String  sign) 该方法可根据给定的分隔符对字符串进行拆分。语法如下：str.split(String  sign)font color=\"#a23735\

字符串分割

字符串操作

格式化字符串

[^456]:代表4、5、6之外的任何字符。 [a-r]:代表a~r中的任何一个字母。 [a-zA-Z]:可表示任意一个英文字母。 [a-e[g-z]]:代表a~e或g~z 中的任何一个字母(并运算)。 [a-o&&[def]:代表字母 d、e、f (交运算)。 [a-d&&[Nbc]]: 代表字母 a、d(差运算)。

正则表达式元字符及其意义如图所示:

使用正则表达式

两种操作执行的时间差距很大。在程序中如果需要1、append()方法        该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double或者另一个字符串生成器等append(content)content:追加到字符串 生成器中的内容font color=\"#ec7270\

创建成功的字符串对象，其长度是固定的，内容不能被改变和编程。使用“+”可以达到附加新字符或者字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK新增了可变的字符序列StringBuilder类，大提高了频繁增加字符串的效率。

字符串生成器

字符串

在Java语言中，字符串必须包含在一对双引号（\"  \")之内。例如：\"23.23\"、\"ABCDE\"、\"您好\"可以通过以下语法格式来声明字符串变量：String str;String:指定该变量为字符串类型str：任意有效的标识符，表示字符串变量的名称

声明字符串

在Java3语言中，将字符串作为对象来处理，因此可以像创建其他类型对象一样来创建字符串对象。创建对象要使用类的构造方法。String类的常用构造方法如下：1、String(char a[])该方法用一个字符数组a创建对象。2、font color=\"#7bd144\

创建字符串

单个字符串可以用来char类型保存，多个字符组成的文本就需要保存在String对象中。String通常被称为字符串，一个String对象最多可以保存（2^{32}-1）个字节（占用4GB空间大小）的文本内容。

1、日期格式化

2、时间格式化     使用format()方法不仅可以完成日期的格式化，也可以实现时间格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫。

3、格式化常见的日期时间组合 格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常见的如图所示

日期和时间字符串格式化

常规类型格式化

String类的静态format()方法用于创建格式化的字符串。format()方法有两种 重载形式。font color=\"#e74f4c\

Integer类提供了以下4个常量：MAX_VALUE：表示int类型可取的最大值，即2^{31}-1MIN_VALUE：表示int类型可取的最小值，即-2^{31}SIZE：用来以二进制补码形式表示int值的位数TYPE：表示基本类型int的Class实例

Integer类

Double类主要提供了以下常量：MAX_EXPONENT：返回int值，表示有限double变量可能具有的最大指数 。MIN_EXPONENT：返回int值，表示标准化double变量可能具有的最小指数 。NEGATIVE_INFINITY：返回double值，表示保存double类型的负无穷大值的常量。POSITIVE_INFIINITY：返回double值，表示保存double类型的正无穷大值的常量。

Double类

Boolean 提供了以下3个常量:TRUE:对应基值 true 的 Boolean 对象。FALSE:对应基值false的 Boolean 对象。TYPE:基本类型boolean的Class对象。

Boolean类

Character 类提供了大量表示特定字符的常量，例如:CONNECTOR_PUNCTUATION: 返回 byte 型值，表示 Unicode 规范中的常规类别“pe”。UNASSIGNED: 返回 byte型值，表示 Unicode 规范中的常规类别“Cn”。TITLECASE_LETTER:返回 byte 型值，表示Unicode 规范中的常规类别“Lt”。

Character类

Number 类的方法分别被其各子类所实现，也就是说，在 Number 类的所有子类中都包含以上这几种方法。

Number类

包装类

在 Java 中，没有格式化的数据遵循以下原则:如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。

数字格式化

Math类

在Random类中，提供了获取各种数类机数的方法，下面列举几个常用的方法:public int nextint():返回一个随机整数。public int nextInt(int n): 返回大于等于0且小于n 的随机整数。public long nextLong():返回一个随机长整型值。public boolean nextBoolean():返回一个随机布尔型值。public float nextFloat0: 返回一个随机单精度浮点型值。public double nextDouble():返回一个随机双精度浮点型值。public double nextGaussian(): 返回一个概率察度为高斯分布的双精度浮点型值。

Random类是JDK 中的随机数生成器类，可以通过实例化一个 Random 对象创建一个随机数生成器，语法如下:Random r = new Random();用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下:Random r = new Random(seedValue);r：Random类对象。seedValue:随机数生成器的种子。

Random类

Biglnteger类中常用的几种运算方法：public BigInteger add(BigInteger val): 做加法运算。public BigInteger subtract(BigInteger val): 做减法运算。public BigInteger multiply(BigInteger val): 做乘法运算。public BigInteger divide(BigInteger val): 做除法运算。public BigInteger remainder(BigInteger val): 做取余操作。public BigInteger[] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。public BigInteger negate(): 取相反数。 public BigInteger shifLeft(intn): 将数字左移n位，如果n为负数，做右移操作。 public BigInteger shiftRight(int n): 将数字右移n 位，如果n为负数，做左移操作。public BigInteger and(BigInteger val): 做与操作。public BigInteger or(BigInteger val): 做或操作。 public int compareTo(BigInteger val): 做数字比较操作。public boolean equals(Object x): 当参数是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回 true。public BigInteger min(BigInteger val): 返回较小的数值。public BigInteger max(BigInteger val): 返回较大的数值。

将 2 转换为 BigInteger 类型，可以使用以下语句进行初始化操作:Biginteger twolnstance = new Bigintegor(\"2\")；

BigInteger类

在上述方法中，BigDecimal类中 divide0方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义如表所示。

BigDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal 实现的加、减、乘、除的方法如表下：

BigDecimal类

数字处理

Math 类中包含的三角函数方法如下:public static double sin(doublea):返回角的三角正弦。public static double cos(double a):返回角的三角余弦。public static double tan(double a):返回角的三角正切。public static double asin(doublea): 返回一个值的反正弦。public static double acos(doublea): 返回一个值的反余弦。public static double atan(doublea):返回一个值的反正切。public static double toRadians(double angdeg): 将角度转换为弧度。 public static double toDegrees(double angrad): 将弧度转换为角度。

三角函数方法

Math 类中与指数相关的函数方法如下： public static double exp(double a):用于获取e的a次方，即取。 publicstatic doublelog(doublea):用于取自然对数，即取Ina的值。 publicstatic double log10(doublea):用于取底数为10的a的对数。 public static double sqrt(doublea):用于取a的平方根，其中a的值不能为负值。public static double cbrt(double a):用于取a的立方根。font color=\"#7bd144\

指数函数方法

在具体的问题中，取整操作使用也很普遍，所以Java 在 Math 类中添加了数字取整方法。Math 类中主要包括以下几种取整方法:public static double ceil(double a):返回大于等于参数的最小整数。public static double foor(double a): 返回小于等于参数的最大整数。public static double rint(double a): 返回与参数最接近的整数，如果存在两个同样接近的整数则结果取偶数。 public staticintround(float a):将参数加上0.5后返回与参数最近的整数。 public static long round(double a): 将参数加上0.5 后返回与参数最近的整数，然后强制转换为长整型。

取整函数方法

在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下:public static double max(double adouble b):取a与b之间的最大值。font color=\"#4669ea\

取最大值、最小值、绝对值函数方法

形式调用:Math. 数学方法Math.PIMath.E

使用 Date 类的第 2种构造方法创建一个 Date 类的对象，代码如下:long timeMillis = System.currentTimeMillis();        //当前系统时间所经历的毫秒数Date date = new Date(timeMillis);Date 类的常用方法及其说明如表所示。

Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表所示。

Date类

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括 SHORT、MEDIUM、LONG 和FULL4种:SHORT:完全为数字，如 12.13.2或3:30pm。font color=\"#e9d66f\

日期时间格式化

最后对 Calendar 类的使用做出几点总结:font color=\"#e74f4c\

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected。Calendar 提供了一个类方法 getInstance()，以获得此类型的一个通用的对象。Calendar 类的getInstance()方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化，其使用方法如下:Calendar rightNow = Calendar.getlnstance();Calendar 类提供的常用字段及其说明如表所示:

Calender类

时间日期处理

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示 shell 命令，在 Windows 系统下表示 cmd 命令。Runtime 类提供 exec()方法让 Java 代码可以执行系统的命令，exec()方法有很多重载的形式，例如:Process exec(String command)Process exec(Stringl cmdarray)command:要执行的系统命令，字符串类型。 cmdarray:要执行的命令和相应的命令参数，字符串数组类型。 使用第二种重载方式的代码如下:String command] =  {\"javac\

执行本地命令

Runtime类可以通过 freeMemory()方法查看当前Java 虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。

查看内存

Runtime类

Java 输出换行的方法有以下两种:System.out.print(\"\\");//利用换行符\实现换行System.out.printIn();//空参数即可实现换行

控制台输出字符System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3 个静态对象:in、out和err。本书中的代码多次使用了这些对象，最常见的就是out 对象。在控制台输出字符串，输出的方法有两种。1.不会自动换行的print()方法print()方法的语法如下：System.out.print(\"Hello!\");此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello” 文字末尾，不会自动换行。2.可以自动换行的println()方法printin()方法在 print 后面加上了“ln”后缀 (就是 line 的简写)，语法知下:System.out.println(\"书籍是人类进步的阶梯!\");此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。println()方法与 println()方法输出的对比效果如表所示：

System类

使用Scanner类扫描控制台的代码如下：Scanner se = new Scanner(System.in);

使用 Scanner 类首先要引入该类，其语法如下:import java.util.Scanner;        //引入 Scanner类

Scanner类

常用类库

分支主题

Java从入门到精通