第一天

1.关键字

在Java中关键字是不能设置成为变量名、方法名、包名、类名的！

2.标识符

程序员自己定义的名字，遵循以下规则：

1.只能以a-z和A-Z或数字或$或_组成

2.不能以数字开头，不能是关键字

3.Java的标准格式

class 文件名{ // 导入主函数是程序的入口！

public static void main(String[]字符数组args){ //相当于入口函数可是 不是

//程序

}

}

4.Java的打印

System.out.print("");

5.Java的换行打印

System.out.println("");

6.Java的 常量

常量是指在程序运行中其值不能改变的量！

7.Java中转义字符的样式与意思

转义字符的概述:

特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。

斜杠就是转义字符。

转义字符 名称 Unicode

\b Backspace （退格键） \u0008

\t Tab （Tab键盘） \u0009

\n Linefeed （换行） \u000A

\r Carriage Return（回车） \u000D

\\ Backslash （反斜杠） \u005C

\' Single Quote （单引号） \u0027

\" Double Quote （双引号） \u0022

大意

\r 表示接受键盘输入，相当于按下回车。

\n 表示换行。

\t 制表符，相当于Table键

\b 退格键，相当于Back Space

\’ 单引号

\’’ 双引号

\\ 表示一个斜跨

上述问问题解决：System.out.println("teacher said\"java is fun\"");

注意：换行符就是另起一行，回车符就是回到一行的开头，所以我们平时编写文件的回车符应该确切来说叫做回车换行符

8.变量

概述：用于储存可变的数据

特点：1.必须要有大小  2.储存一定格式的可变数据  3.必须要有名字

变量的数据类型：1.整型：byte 代表一个字节大小

short 代表两个字节的大小

int 代表四个字节的大小

long 代表八个字节的大小

如果一个数值没有采取特殊的处理，那么该整数默认的类型是int。

可以使用数值后面添加L或小写L改变默认的整数类型。

9.运算

在运算的时，数字默认的是int类型。

例外：--------------------------

short a = 3;

short b = 4;

a += b;

默认的会将结果转化为short类型所以不会产生精度问题！

第二天

一．回顾：

1.1常量：

基本数据类型常量

字符常量

整数常量的表现形式：一进制的形式来表示（二进制，八进制，十进制，十六进制）

生活中：十进制(0-9) ，星期(七进制(0-6)) ,时间(十二进制(0-11),二十四进制(0-23))

计算机是通过二进制来读取我们生活中的数据。

进制之间的转换：

十进制转为二进制：将十进制除以2，直到商为0 ，将余数从下上连接起来就是二进制

10---->1010

二进制转十进制：将二进制的每一位乘以2^n ,n从0开始，n每一次加一,在将结果相加。

1001 ----》 1*2^0 +0*2^1 +0*2^2+1*2^3 = 9

将二进制换位八进制：

方式一：二进制--->十进制--->八进制

方式二：一个八进制相当于三个二进制为，将二进制三位一分割，计算出来

010 100 101 = 245

将二进制换为十六进制：(0-9)(a(10)-f(15))

0000 1010 0101 = a5

1.2变量：

Java数据类型分为两种：

1.基本数据类型

Byte （字节） 8位（bit）

2.引用数据类型

String 字符串。

变量的声明方式：

//1.数据类型 变量名

//2.数据类型 变量名1，变量名2...

数据类型：

//数据类型的转换

//1.自动类型转换

// 小数据类型--->大数据类型转换

//2.强制类型转换

// 大的数据类型 ----> 小的数据类型。

//数据类型转换中需要注意的点：

//1.凡是short ，byte ,char 定义的变量，在做运算的时候，

//数据类型都会自动转换为int

//2.两个不同数据类型做运算，给过取决于大的数据类型。

二．运算符。

1.1算数运算符:+,-,*,/,%

1.2自增自减 ：++ ，--

1.3赋值运算符 ： = ，+=，-=，*=，/=

1.4关系运算符 ： >,<,>=,<=,== ,!=

逻辑运算符： & ,| ,! ,&& ,||

位运算符：

它是对二进制位进行计算。

位运算符是可以对十进制的整数进行计算，计算方式：将十进制转为二进制进行计算。

二进制由0和1组成，所以计算的结果要么是0，要么是1

1.5位运算符的符号：

& (与)：两者都是1的时候我就是一，其他都是0

|(或)：两者都为0时才为0 ，其他的都是1.

^(异或):两者不同为1，相同为0

~(取反)：0变为1，1变为0.

//负数的表现形式： 二进制位的最高位为1，那么这个数就是一个负数。

1111-1111 1111-1111 1111-1111 1111-1111 ： -1

0000 0000 0000 0000 0000 0000 0000 0000 ： 0

-2:1111-1111 1111-1111 1111-1111 1111-1110

-3:1111-1111 1111-1111 1111-1111 1111-1101

-4:1111-1111 1111-1111 1111-1111 1111-1100

-5:1111-1111 1111-1111 1111-1111 1111-1011

-6:1111-1111 1111-1111 1111-1111 1111-1010

-7:1111-1111 1111-1111 1111-1111 1111-1001

0000-0000 0000-0000 0000-0000 0000-0111 = 7

1111-1111 1111-1111 1111-1111 1111-1001

规律：负数所对应的正数-1 ，取反

负数所对应的正数取反+1

作用：数据进行加密

123456

0-100 a-z

24845845957512317580960 --- >123456

1.6移位操作符:对二进制位进行操作

1.6.1 >> 右移  除

1.6.2 << 左移  乘

1.6.3 >>> 无符号右移

随机数是  int a = (int)(Math.random()*范围);

第三天

数组的排序和查找！

1.查找：

前提是数组中的数都已经排好位置！

int 返回的是索引值 = Arrays.binarySearch(数组,需要查找的数字);

返回的值是：索引

如果没有的话就返回对应的插入位置-1！不过是负的！

2.排序

Arrays.sort(数组);

对当前数组进行升序排序！

数组也可以进行指定位置排序： Arrays.sort(数组,指定的排序的索引，到指定位置的索引)；

对象的创建以及属性和方法的调用！

class 对象名{

String name;

属性的类型 属性名;

public void run(){

方法的公开程度(private or public) 方法的返回 方法名 （方法的参数)

方法的实现！

}

}

在主函数里调用：

对象类名 对象名 = new 对象类名（）;

赋予属性： 对象名.属性 = ...；

调用方法： 对象名.方法名（）；

成员变量与局部变量的区别和作用：

定义：1.成员变量定义在类中，方法外；局部变量定义在方法中

作用：1.成员变量是用来描述同一类事物的公共属性的；局部变量提供一个变量给方法使用！

生命周期：1.成员变量的生命周期随对象而创建与消失；局部变量的生命周期随方法的调用而创建当方法结束消失；

初始值区分：1.成员变量是有默认值得；局部没有默认值必须初始化才能使用

判断字符串相同：str.equals("");

第四天

面向对象的理解：

核心：找合适的对象去做合适的事情

思想：尽可能的用计算机语言来描述现实生活的事物

面向对象：侧重于对象

类与对象的关系：

类：是同一类事物的抽象

对象：是类的具体实现

创建对象和指挥对象做事情：

类的结构：

class 类名{

公有属性

构造代码块

构造方法

公有方法

}

类名 对象名 = new 类名（）；

或

new 类名（）--->匿名对象 ：

特点：1.一般不会赋值，因为无法获取

2.创建出来每次都是新的对象

作用：1.书写简单，只可以调用一次！

2.可以作为实际参数在方法中调用

对象的内存分布：

1.对象的引用变量是存栈区，对象存在堆区，成员变量也是堆区

成员变量和局部变量的区别：

位置：成员：类中方法外

局部：方法中

作用域：成员：在类中都能使用

局部：只能在方法中使用

初始化：成员：有默认的值

局部：必须要初始化赋值

生命周期 ：成员：随对象的生命而存在

局部：方法调用完就消失

构造方法：初始化方法

注意点：1.方法名与类名保持一致

2.构造方法没有返回值

3.构造方法不是由自己调用而是创建对象的时候yo由Java虚拟机创建调用

4.当构造方法有参数时，创建必须要有参数！

5.可以有多个构造方法！可以重名：叫方法的重载！

6.构造方法可以调用构造方法（this（调用构造方法的参数）

注：1.this（）调用必须是构造方法的第一个语句

2.不要相互调用）

例：class 类名{

int name;

public 类名(int s){注：不能加void

name = s;

}

}

main函数

类名 对象名 = new 类名(传值);

方法可以重名---》方法的重载！

在方法重载时应注意：1.方法名必须一样

2.任何方法都可以实现

3.传入参数顺序或个数不一样！

代码块：

1.构造代码块：在一对象被构造时直接运行，

注意点：1.Java编译器在编译一个Java源文件时，会把成员变量放在最前面

2.成员变量的初始化都是在构造方法中执行的

3.一旦经过Java编译器后，构造代码块中的代码移到构造函数中去执行，放在构造函数的最前面执行

4.成员变量的初始化和构造代码块，按照当前代码的顺序来执行--->谁在后面就显示谁

例：在类里的成员变量的位置上

int id；

{

work();

}

2.局部代码块：写在方法中 也是用大括号来表示；

3.静态代码块：

this关键字：可以取到自身对象属性！

1.若成员变量与局部变量重名时，默认的是直接调用局部，通过this可以直接取到成员变量

2.在方法中不存在同名的局部变量，编译器会默认给变量前加一个this.

主函数为什么用public来定义：

public static void main(){}

1.public：main函数是由Java虚拟机（jvm）来调用的，jvm也是一个程序，为了保证jvm能够在任何情况下调用主函数。

2.static ：如果没有static main函数就需要创建一个对象来调用方法；jvm如果创建对象的话不知道该传递什么参数，所以为了避免麻烦就将方法定义为静态的！

3.void：main 是由jvm来调用的，返回值是给jvm的，jvm接受返回值没有任何意义，所以就不需要返回值。

4.main：不是关键字，main已经被约定好了这个就是入口；

5.args ：用来接收程序启动时接受传入的数据

增强for循环：foreach循环 = OC的for in 循环

for(String s : args){

分解的s  ： 数组

System.out.println(s);

}

Java会学：1.单例*    设计模式：用来解决同一类问题的解决方案（固定步骤）

2.观察者

3.mvc*

4.装饰设计模式

5.工厂模式*

Java单例设计模式：一个类只能创建出一个对象

例：

1.保证对象唯一

private static 类名对象名= new 类名(); 静态的成员变量

私有化  静态

2.私有化构造方法,阻止人用new来创建对象

private 类名(){} 注：构造方法没有返回值也不是静态的

3.提供一个静态方法来接受唯一的对象

public static 类名 getInstance(){

公开    静态  返回类  方法名

return对象名;

}

main中：类名 对象名 = 类名.getInstance();类方法创建

私 静 对--》私 构造---》公 静 法

在main中用类调用静态方法会返回一个对象，静态方法调用私有的静态的成员对象，成员对象只会调用一次私有的构造方法，往后就返回的都是一个对象

饿汉单例模式步骤：1.创建一个对象设为私有的静态成员变量，保障对象唯一推荐

2.把构造方法设为私有，防止外部创建

3.创建一个返回为当前类的静态的方法

懒汉单例设计模式 --->例:  private static 类名 对象名;-----》声明引用变量，不创建

private 类名(){}-----》私有化构造方法

public static 类名 方法名(){ -----》公开的静态的方法以便调用

if(对象名==null){  ---->在线程里不安全

对象名 = new 类名();

}

return 对象名;

}

封装：---》用于：1.框架  2.工具类  好处：1.提高数据安全性 2.操作简单 3.隐藏了方法的实现

步骤：1.使用private修饰需封装的成员变量

2.提供一个公开的方法设置或访问私有的属性

设置：通过set get方法

命名规范：public void set属性名（）；首字母要大写

public 返回的类 get属性名（）；

权限修饰符：1.public 公共的，任何都可直接访问

2.private 私有的，只能在自己类里进行访问

第五天

方法区（数据共享区）

给某个成员属性设定static，使其变成静态常量，放置于方法区，这样每创建一个都会让对象访问方法区。当被更改后再次调用属性时会发生大更改！

static String name； 只会初始化一次所以只占一个内存

静态修饰符 static：1.用来修饰成员变量

当成员变量被修饰时叫静态成员变量：只被创建一次

静态成员变量的访问方式：

1.可以用对象进行访问：对象名.静态成员变量 = “”；

2.直接通过类名进行访问：类名.变量名 = “”；

注意：1.不要认为方便就所有的变量都用static修饰

2.只能静态变量才能用类名访问，非静态只能通过对象

3.局部变量不允许被static修饰

2.用来修饰方法---->

静态方法：1.可以由类来调用  类名.方法名();

2.可以通过对象来调用  对象名.方法名();

注意：1.静态方法推荐使用类名来调用，非静态方法只能通过对象

2.静态方法可以访问静态的成员变量，不能访问非静态的成员变量；非静态的方法可以访问任何变量

原因:有可能静态方法被调用，但对象却没创建

3.静态方法可以访问静态方法，静态方法不能访问非静态方法；非静态方法可以访问任何方法

原因：有可能静态方法被调用，但对象却没创建；非静态方法只能由对象来调用，当对象被创建出来，静态方法早就存在内存中！

4.静态方法中不允许出现this关键字和super

this：表示一个方法调用者对象；原因：可能调用时没有对象

super：

public static void  方法名(){

static修饰方法

}

特点：静态的数据早于非静态的数据存在内存中

当一个方法不需要访问非静态数据是可以用 static 修饰

捕获异常：将异常的代码放置于 以下的框中

try{

异常代码

}catch(){

}

第六天

Java继承：

作用：1.优化代码减少代码的重复使用

特点：继承父类的属性和方法。单继承（多层继承）

特性：方法的复写  关键字：extends

注意：1.不要为了继承而继承，千万不要省代码，任何类都继承

2.父类的私有成员变量是不能被继承的！

3.父类的构造方法是不能被继承的！子类调用自己的构造方法时，会默认的调用父类的无参构造方法！

4.可以通过父类的构造方法来给子类赋值：

public 子类 extends 父类{

public 子类 （String name）{

super（name）；访问父类的有参构造方法不会调用父类的无参构造方法 ！

}

}

5.子类不够继承不在一个包中默认权限的成员变量

在类里赋予对象，是当前的类拥有赋予的对象！

例：class 类名 extends 父类{

继承了

}

默认权限 ：friendly（友好的） private（私有）public（公开的）prtected（受保护）

第七天

super ：关键字

解释  ：指向父类对象的引用空间！

作用  ：1.当子类与父类存在同名的成员变量时，若没有super访问的是子类的成员变量，有的话就是父类的

2.super也可以调用父类的构造方法

注意　：１．使用ｓｕｐｅｒ调用父类的构造方法，必须是子类构造方法中的第一个语句

２．ｓｕｐｅｒ只能出现在子类的方法和构造方法

3 .  super不能和this同时调用构造方法！

总结： super和this的区别：

1.代表的事物不同：this 所属方法调用者对象

super 表示父类对象的引用空间

2.使用的前提不一样： super 只能在继承的条件下才能使用

this在非继承条件下也可以使用

3.调用构造方法： super 调用父类的构造方法

this使用来调用本类的构造方法

方法的重写

作用：父类的方法满足不了子类的实现，这就需要重写父类的方法

注意：1.方法名要一致，

2.参数不要修改

instanceof（实例类型）  关键字作用：1.用来判断某一个对象是否属于某一个类

例：  对象    instabceof    类；返回boolean类型

2.instanceof  关键字的使用前提：对象指定的类有继承关系或者实现关系。

final(修饰符，最终)    关键字 类似于常量

常量的格式----》 public final static 基本数据类型 变量名；

final 修饰的变量必须要初始化！

用法： final 数据类型 成员变量；

1.当用final关键字修饰基本数据类型变量，改变量值就不会重新赋值 ，第一次的结果就为最终的结果

2.用final修饰引用数据类型对象，引用数据类型对象无法被更改

3.还可以用final修饰方法，方法就不能被重写！

4.final还可以来修饰类，那这个类就不能被继承

在调用方法时应多想想形参到底是怎么用的，去判断传入形参是地址（引用数据类型）还是值（基本数据类型）！！！

抽象类： 关键字 abstract；一个类如果被abstract所修饰，这个类就叫做抽象类！

abstract  关键字的使用：

1.如果abstract修饰方法，那么这个方法就叫抽象方法！当有子类继承与父类时必须实现abstract修饰的方法！抽象方法是没有主体（方法的实现！）---跟协议差不多

2.当有抽象方法时必须用抽象类来修饰！

3.非抽象类继承了抽象类时必须实现抽象类例的所有方法！

注意： 1.如果一个方法没有方法体，那么这个方法必须要用abstract来修饰

2.如果一个类里有抽象方法，这个类就需要abstract来修饰，抽象类

3.如果一个没抽象的类，继承了抽象类，那么这个非抽象类中必须重写所有的抽象方法

4.抽象类也可以存在非抽象方法！

5.抽象类里也可以存在构造方法！作用是让子类能过初始化父类的变量

6.抽象类不能创建对象：

原因：如果创建对象，对象就可以调用到抽象方法，但是抽象方法没有实现，调用也没意义！

使用场景：在描述事物时，发现事物存在某种行为，但这种行为不具体，这时可以抽取这种行为，声明一个没有实现的行为方式，这种行为就叫抽象的行为，这种时候需要用到抽象类！

接口：Java开发常用！

作用：用来添加拓展功能

现实：Java是单继承

注意：1.接口是个特殊的类，可定义方法和属性

2.属性默认的是final修饰的 public static final 实际上是常量

3.方法是抽象的用abstract public 修饰

4.接口不能创建对象

5.接口没有构造方法

6.接口是给类去实现的！非抽象类实现接口时，必须将接口中的方法都实现

补充abstract不能跟那些关键字一起使用：1.private  2.static  3.final

接口的定义模式 ：

用interface关键字来表示

interface 接口名{

定义在接口中的方法是不需要实现的！

在借口中的变量默认是final修饰的！

public void 方法名（）；

在接口里默认的方法是抽象方法！接口中的方法是由实现来完成

接口中不能定义非抽象方法！可以定义成员变量！

};

结构：

class 类 implements 接口名，可以添加多个

一个非抽象的类实现接口，就必须要实现接口中的所有方法，抽象类的例外，抽象的可以不实现，但继承抽象类的子类必须现实抽象类里的接口中的方法！！！

接口与接口的关系：接口是个特殊的类，一个接口可继承多个接口

第八天

面向对象----->多态：一个类具有多种的表现形态（父类的引用类型变量指向子类的对象）必须继承的情况下才有多态

引用类型的变量：1.数组 2.字符串 3.对象

父类 a = new 子类();

多态注意：1.子父类存在同名的成员变量，默认访问父类的成员变量，无论静态和非静态的！

2.子父类存在同名的非静态方法，访问的是子类的非静态方法

3.字符类存在同名的静态方法，访问的是父类的静态方法！

4.在多态情况下不能访问子类特有的成员变量和方法！

总结：多态情况下，子父类如果存在同名的成员，访问的都是父类，除了非静态方法是访问子类 ！

Java编译器的编译原理导致！

编译看左边，运行不一定看右边！

编译看左边：Java编译器在编译时会检测引用类型是否含有指定的成员，如果没有就会报错！ 引用类型 s = new 子类（）；

多态使用场景：

1.多态可用于做形式参数，可以让方法接收更多的类型

2.多态可以用于返回值，可以返回更多的数据类型

多态的另一种表现方式：

接口的引用类型指向实现类！

实现关系 ：  接口  变量 = new 接口实现对象。

可以用接口来接收对象！！在java中用的比较多

List list = new ArrayList（）；多态的使用！

内部类：一个类可以定义另外一个类，叫内部类。

内部类的文件名：外部类名$内部类名

内部类分两种：

1.成员内部类：

如何访问内部类：

方式一：在外部类中提供一个方法，通过外部类的方法来创建内部类对象！ 外部类 外部类名 = new 外部类（）；

调用外部类的方法

方法二：直接在其他类中创建内部类对象，通过对象访问！

外部类.内部类  变量名  =  new  外部类（）.new  内部类（）；

内部类使用注意：

1.如果外部类和内部类有同名的成员变量，在内部类中Java虚拟机默认访问内部类中的成员变量，可以通过“外部类.this.成员变量”来访问外部类的成员变量；

2.如果内部类中的成员被private修饰时只能用方式一来访问内部类的成员！

3.如果内部类中有变量被static修饰时那么这个内部类也必须被static修饰

内部类的好处：

1.在内部类可以直接访问外部类的所有成员。

一般在什么情况下使用外部类：

在描述a对象，发现对象中有需要有一个对象b很复杂，b又要访问a中的数据，这个时候用内部类来描述b对象会很方便

2.局部内部类：

在类的方法中定义的一个类叫局部内部类！

局部内部类只能通过第一种方法进行创建！！

局部内部类注意点：

1.如果局部内部类访问了方法中的局部变量，方法中的局部变量必须用final来修饰！

3.匿名内部类 ：没有类名的类叫匿名内部类

好处：简化书写！！用于实际参数的传递！

使用前提：匿名类必须有继承或实现关系！

在方法中

继承的父类  子类名  =  new 父类（）{------->匿名的内部类，这是个子类

重写父类中的方法

}；

第九天

异常： 在Java程序中也会出现程序不正常的情况，这个就叫异常！

Java中提供了很多异常类！

异常的体系：

Thorwable ---->所以异常和错误的父类

--->error

--->Exception

Thorwable---的使用：

主要学习的三个方法：

类完整的名称：包名+类名

1.toString（）对thorwable的简短的描述：类的完整的名称--Message的信息也会打印出来！有返回值需要System.out.println（）打印

2.getMessage（）对thorwable的详细的描述，有返回值需要System.out.println（）打印

3.printStackTrace（）打印的是异常的栈内存，系统默认的也是打印的栈内存；直接调用打印就可以了！

Erroe错误：

错误一般是Java虚拟机或者是硬件导致的问题，所以一般不会用代码来处理错误 ！

------------------------------------------------------------------------------------------------

异常才是重点内容

Exception：所有的异常都继承于Exception

异常和错误的区别：是在结尾，以Exception是异常可以用代码来处理，Erroe是错误不能用代码来处理！

异常的处理：

方式一：捕获处理

注意点：1.如果try代码处理问题处理后，会继续执行try-catch外的代码！

2.catch里的代码只有在try里的代码出现异常的时候才会出现执行！

3.一个try后面可以接多个catch块，一个try可以处理多个异常

4.try捕获异常是从小到大来捕获，否则就会报错

5.一定要把最大的异常写在最后面

捕获异常到底有什么用？

学习JavaEE时会很有用！

为什么不直接用最大的异常？

为了快速的找到错误的！

try{

可能发生异常的代码

}catch(Exception e  捕获异常的类型的变量名){

处理异常

}

方式二：抛出处理

（throw    throws）使用注意点：

1.关键字不能乱，throw 用于方法里；throws 在方法声明中

2.trow 用于方法内部抛出异常，throws用于方法生命上抛出异常

3.throw关键字后只能有一个异常，throws 可以声明多个异常

抛出异常使用注意：

1.如果在方法中抛出一个异常对象，就必须在方法声明中声明这个异常的抛出

2.如果一个方法调用抛出异常的方法，调用者就必须处理抛出的异常

3.如果一个方法抛出了异常，那么throw后面的代码就不会在执行！

4.在一种情况下只能抛出一种异常！

什么时候抛出异常，什么时候不抛？

需要通知你的调用者，你的代码可能存在问题，这时需要抛出异常。

如果你的代码是直接和用户打交道，这是就不需要抛了

自定义异常：

如何区分编译时异常和运行时异常？

只要是runtimeException或子类都是运行时异常！其他都是编译时异常！

运行时异常：可以写声明调用者也可以不做处理！

编译时异常：必须写声明！

关键字：finally块  与try一起连用

作用：无论出了什么问题，finally里的代码都会执行！

finally{

这里的代码无论出现异常！还是直接return都会执行下去！！除非jvm退出很牛逼！

}

finally非常适合做资源释放工作，这样可以保证！我的资源文件在任何时候都可以释放掉！

包的使用： Java中的包相当于电脑的文件夹！

作用：可以将编译的class放入指定的包中！防止两个java文件里的类名相同

定义包：

package 关键字定义包

package 文件夹.文件夹

javac -d . 类名.java  载入！！

java package的文件夹.java的名

如果加了包之后类与类之间的访问注意：

1.类需用public修饰

2.被访问的类需要先编译出来！

3.在其他类使用其他类的话需要用到类的全名

可以用导包来解决问题三。

导包用关键字 ：import

格式：import 包名一.包名二.....类名

import 包名.*；

好处：

1.防止同名的类文件的冲突

2.将原文件与编译后的文件分离，便于软件的发布！

注意事项：

1.一个Java类中只能定义一个包

2.包的定义一定是类描述信息的第一个语句！