Java基础教程
一. Java 简介
1.执行命令解析
1.1 javac后面跟着的是java文件的文件名，改名命令用于将java源文件编译为class字节码文件，即xxx.class的文件。
1.2 java后面跟着的是java文件中的类名，命令后面不要加.class
2.Java 简介
2.1 java三大体系
JavaSE（Java平台标准版）
JavaEE（Java平台企业版）
JavaME（Java平台微型版）
2.2 Java基础语法
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。类：类是一个模板，它描述一类对象的行为和状态。方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。
二.Java语法
1.Java基本语法
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
Java修饰符：访问控制修饰符 : default, public , protected, private；非访问控制修饰符 : final, abstract, strictfp
Java变量：局部变量，类变量（静态变量），成员变量（非静态变量）
Java枚举：
2.Java变量
2.1局部变量：
在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。访问修饰符不能用于局部变量；局部变量只在声明它的方法、构造方法或者语句块中可见；局部变量是在
栈上分配的。局部变量没有默认值，所以
局部变量被声明后，必须经过初始化，才可以使用。
2.2成员变量（实例变量）：
成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；访问修饰符可以修饰实例变量。实例变量具有默认值，数值型变量默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以构造方法中指定。
2.3类变量（静态变量）：
类变量也声明在类中，方法体之外，但必须声明为static类型。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。静态变量储存在静态存储区，很少单独使用static声明变量。静态变量在程序开始时创建，在程序结束时销毁。与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。静态变量可以通过：ClassName.VariableName的方式访问。类变量被声明为
public static final类型时，类变量名称一般建议使用大写字母。
3.源文件声明规则
当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则：
一个源文件中只能有一个public类，一个源文件可以有多个非public类。源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。如果一个类定义在某个包中，那么package语句应该在源文件的首行。如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。 import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
4.修饰符
4.1访问修饰符
默认的，也称为 default，在同一包内可见，不使用任何修饰符。私有的，以 private 修饰符指定，在同一类内可见。共有的，以 public 修饰符指定，对所有类可见。受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。
4.2非访问修饰符
static 修饰符，用来创建类方法和类变量。final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。abstract 修饰符，用来创建抽象类和抽象方法。
以上三个修饰符都不能修饰构造方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
static 修饰符：
静态变量：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被成为类变量。
局部变量不能被声明为 static 变量。
静态方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。由于他在类加载的时候就存在了，它不依赖于任何实例，所以
static 方法必须实现，也就是说他不能是抽象方法 abstract。静态方法不能调用非静态变量和非静态方法，而非静态方法可以调用静态方法和静态变量。static方法中不允许出现this，super关键字，static方法子类可以继承,而且子类可以覆盖静态方法。静态方法覆盖后不能实现多态。
final 修饰符：
final 变量：final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final对象的引用不能改变，但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法：类中的 final 方法可以被子类继承，但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。如下所示，使用 final 修饰符声明方法。
abstract 修饰符：
抽象类：抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。
抽象方法：抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。抽象方法的声明以分号结尾，例如：public abstract sample();
synchronized 修饰符：
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
transient 修饰符：
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
volatile 修饰符：
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。
5.增强for循环
for(声明语句 : 表达式){
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
6.Java Number & Math 类
6.1 Java Number类
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置 类型。Number 类属于 java.lang 包。当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。
6.2 Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。Math.sin(Math.PI/2)......
7.Java Character 类
Character 类在对象中包装一个基本类型 char 的值
8.转义序列
9.Java String 类，Java StringBuffer 和 StringBuilder 类
9.1 String类：在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
9.2
StringBuffer 和 StringBuilder 类
StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
10.Java 数组
10.1声明数组变量
dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 效果相同，但不是首选方法
10.2创建数组变量
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
10.3多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
10.4Arrays 类
它提供的所有方法都是静态的。
给数组赋值：通过 fill 方法。对数组排序：通过 sort 方法,按升序。比较数组：通过 equals 方法比较数组中元素值是否相等。查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
11.Java 日期时间
Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。Date(long millisec)
11.1 获取当前时间
Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间
11.2 使用 SimpleDateFormat 格式化日期
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。
11.3 Java 休眠(sleep)
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。
Thread.sleep(1000*3); // 休眠3秒
11.4 测量时间间隔
11.5 Calendar类
我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象：
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象：使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Calendar类对象字段类型：
如果只设定某个字段，例如日期的值，则可以使用如下set方法：
public void set(int field,int value)
c1.set(Calendar.DATE,10);
如果在某个日期的基础上加上或减去一段日期：
c1.add(Calendar.DATE, 10);
c1.add(Calendar.DATE, -10);
对象信息的获得：
Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒i
nt second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);
12Java 流(Stream)、文件(File)和IO
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
12.1读取控制台输入
Java 的控制台输入由 System.in 完成。为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedReader 对象创建后，我们便可以使用
read() 方法从控制台读取一个字符，或者用
readLine() 方法读取一个字符串。
12.2控制台输出
在此前已经介绍过，控制台的输出由 print( ) 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。
注意：
write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。
12.3读写文件
FileInputStream：该流用于从文件读取数据，它的对象可以用关键字 new 来创建：
InputStream f = new FileInputStream("C:/java/hello");
也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);
FileOutputStream：该类用来创建一个文件并向文件中写数据。如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
使用字符串类型的文件名来创建一个输出流对象：
OutputStream f = new FileOutputStream("C:/java/hello")；
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
12.4Java中的目录
创建目录：File类中有两个方法可以用来创建文件夹：
mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
mkdirs()方法创建一个文件夹和它的所有父文件夹。
读取目录:一个目录其实就是一个 File 对象，它包含其他文件和文件夹。
如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。
可以通过调用该对象上的list() 方法，来提取它包含的文件和文件夹的列表。
13Java Scanner 类
通过 Scanner 类来获取用户的输入,Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：
next() 与 nextLine() 区别
next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：
14Java 异常处理
异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
14.1 异常类型：
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
14.2 Exception 类的层次:
所有的异常类是从 java.lang.Exception 类继承的子类。Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。Error 用来指示运行时环境发生的错误。例如，JVM 内存溢出。一般地，程序不会从错误中恢复。异常类有两个主要的子类：IOException 类和 RuntimeException 类。
14.3 Java捕获异常
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
try{
// 程序代码}
catch(ExceptionName e1){
//Catch 块
}
throws/throw 关键字：如果一个方法没有捕获一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
finally关键字：finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型 等收尾善后性质的语句。
finally 代码块出现在 catch 代码块最后。
14.4声明自定义异常
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。
下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。
15继承
继承可以使用extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
super 与 this 关键字：
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
final关键字：final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
构造器：子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
16.Java 重写(Override)与重载(Overload)
16.1重写(Override)
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
方法的重写规则：
参数列表必须完全与被重写方法的相同；返回类型必须完全与被重写方法的返回类型相同；访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。父类的成员方法只能被它的子类重写。声明为final的方法不能被重写。声明为static的方法不能被重写，但是能够被再次声明。子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。构造方法不能被重写。如果不能继承一个方法，则不能重写这个方法。
16.2重载(Overload)
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。
重载规则
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；被重载的方法可以改变返回类型；被重载的方法可以改变访问修饰符；被重载的方法可以声明新的或更广的检查异常；方法能够在同一个类中或者在一个子类中被重载。无法以返回值类型作为重载函数的区分标准。
17Java 多态
17.1虚方法：
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
Salary是
Employee的子类。
当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是Employee 类 的子类
Salary 类中的 mailCheck() 方法。
17.2多态的实现方式：
方式一：重写：
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。
方式二：接口
1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。
方式三：抽象类和抽象方法
18Java 抽象类
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
在Java语言中使用abstract class来定义抽象类。
抽象方法：
如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。Abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。构造方法，类方法（用static修饰的方法）不能声明为抽象方法。抽象方法没有具体的实现（没有花括号，后面只跟一个分号）。
声明抽象方法会造成以下两个结果：
如果一个类包含抽象方法，那么该类必须是抽象类。任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
19Java 封装
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。
实现Java封装的步骤：
修改属性的可见性来限制对属性的访问（一般限制为private）对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问
20.Java 接口
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类相似点：
一个接口可以有多个方法。接口文件保存在 .java 结尾的文件中，文件名使用接口名。接口的字节码文件保存在 .class 结尾的文件中。接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
接口不能用于实例化对象。接口没有构造方法。接口中所有的方法必须是抽象方法。？？？接口不能包含成员变量，除了 static 和 final 变量。接口不是被类继承了，而是要被类实现。接口支持多重继承。
接口特性：
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
接口的实现：
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
接口的继承：
一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。
接口的多重继承：在接口的多重继承中extends关键字只需要使用一次，在其后跟着继承接口。public interface Hockey extends Sports, Event{}
21.Java 包(package)
把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。这个例子创建了一个叫做animals的包。通常使用小写的字母来命名避免与类、接口名字的冲突。package animals;为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
转载请注明原文地址: https://ju.6miu.com/read-25122.html
