最简洁完整的Java基础教程（基本语法、继承、接口、多态）

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" 语句可完成此功能。如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。