Chapter 01  

Getting Started

一、核心概念

1.什么叫类？

类就是某一种事物的一般性的集合体，是相同或相似的各个事物共同特性的一种抽象。

2.什么叫对象？

在面向对象概念中，对象（Object）是类的实例（instance）。对象与类的关系就像变量与数据类型的关系一样。

3.类的核心特性有哪些？

类具有封装性、继承性和多态性。

封装性：

类的封装性为类的成员提供公有、缺省、保护和私有等多级访问权限，目的是隐藏类中的私有变量和类中方法的实现细节。

继承性：

类的继承性提供从已存在的类创建新类的机制，继承（inheritance）使一个新类自动拥有被继承类（父类）的全部成员。

多态性：

类的多态性提供类中方法执行的多样性，多态性有两种表现形式：重载和覆盖。

4.方法

对象中的方法表达了对象所具有的行为。方法实际上就是函数。

5.属性

一个对象的属性是能够被外界或对象所处的环境所感知或操纵的数据或状态。

6.Java是什么？

Java是一门易于变成的跨平台编程语言，同时又是一个开发、应用、执行和部署平台。Java包括Java编程语言，开发工具和环境、Java类库等。Java语言是由美国Sun公司开发的一种完全面向对象的程序设计语言。Java语言由C++语言发展起来，但比C++语言简单。Java语言具有简单、与平台无关、高效、健壮、安全、多线程等特点，它是当前网络编程的首选语言。

Java既是一门编程语言又是一个平台。

7.为什么要用Java？

最主要的原因是Java与平台无关，一次编译，处处运行，以及它的易于编程的特性。

8.用Java开发程序的步骤是怎么样的？

编写源代码（*.java）→编译（javac *.java）→执行（java *.class）

9.Java的环境变量

由于Java是平台无关的，安装JDK时Java不会自动设置路径，也不会修改注册表，需要用户自行设置环境变量，但不需要修改注册表。

JAVA_HOME:JDK的安装路径；

CLASSPATH：JVM装载、class字节码文件时的搜索路径；

PATH：系统的环境变量，命令的搜索路径。

path变量指出Java提供的可执行文件的路径；

class path变量指出Java包的路径（for Windows）

set path=%path%;

C:"Program Files"jdk1.5.0"bin;

set classpath=.;

C:"Progam Files"jdk1.5.0"lib

10.JVM是什么？

JVM，Java Virtual Machine，Java虚拟机，是一个逻辑的操作系统，它屏蔽了硬件和平台信息，JVM能将字节码文件（*.class）解释并执行。正是这种独立执行的方式，使得Java具有与平台无关的特性。

11.类的加载过程

类加载器（class loader）加载字节码到内存，JVM内存数据区将对象状态放置在堆区，各线程使用的变量放在栈区，类的特征放在方法区。

然后进行字节码验证（Byte code verifer），再执行。

二、常用Java命令

1.＄javac <opitions><source files>

编译源代码

2.＄java <options> class [args]

执行类文件（Byte code 文件）

3.＄jdb <options> <class> <arguments>

调试命令

4.＄javadoc [options] [packagenames] [sourcefiles] [@files]

生成Javadoc文档

5.＄jar {ctxu} {jar -flie} [manifest -flie] [-c directory] fiels…

解压缩jar文件命令

c:创建新的压缩文件(create)

t:列出清单（tail）

u:更新压缩文件（update）

v:显示压缩过程（view）

f:压缩文件的名称（filename）

m;按照清单指定信息进行压缩

三、语法与规范

1. 一个源文件只有一个public类；

2.public源文件可以有多个类定义；

3.源文件名字必须与public类名一致

4.包名必须在第一行（except annotation）

注释通常放在第一行，定义了包，则包定义放在第一行（包用来区分同名的类以及组织类）；

5.包名可以有零个或一个，但不可以有多个；

6.源文件如果带包的话，最好存放在包结构对应的目录下。

Chapter 02

Identifiers，Keywords and Types

1．标识符：

       定义：

       程序语言中用于标识变量名、方法名、类名的字符串。

       begin with character"_" or "$"。

       Case sensitive

 编码规范：

       类名：

       首字母大写，每一个单词的首字母也大写(驼峰格式)，并且取有意义的单词或单词的联合。

       方法名：

       首字母小写，每一个单词的首字母也大写，方法名最好取动名词，并且取有意义的单词或单词的联合。

       变量名：

       首字母小写，每一个单词的首字母也大写。

       常量名：

       每一个字母都要大写。如果常量名是由两个或几个字母的联合，用下划线联接。

2．关键字：

       程序语言当中，程序已经使用，用户不得再使用的单词。一般keywords都是小写。

3．数据类型：

        基本类型：boolean byte char double float int long short

基本类型不是对象，所以基本类型没有方法，需要使用包装类才能使基本类型有自己的方法。

Example：

public class Test(){

private int i=10;

public void f(){

for(int k=0;k<i;k++){

          i--;

System.out.println(i);

        }

}

public static void main(String[] args ){

f();

}

}

API: println

public void println()

Terminate the current line by writing the line separator string. The line separator string is defined by the system property line.separator, and is not necessarily a single newline character ('"n').

请问：print语句一共运行几次？

答案：编译报错

        整型：byte short int long

        浮点型：float double（浮点型由基数、指数、尾数组成，默认情况下是double型）

        布尔型：boolean

        另一分类方法：布尔型（boolean）和数值型

        cast：

        隐式转换：由大到小;

        强制转换：由小到大（强制转换的前提是两种类型必须有继承关系）

        char：

        字符编码：

            将字符按照某种规则转换成数字。

            ASCII码：美国国家信息标准编码，一个字节来表示英文中所用的字符。

            ISO8859-1：国际标准化组织把一个字节来表示英文中所用的字符。

            GB2312：大陆编码标准，6000多个。

            GBK：大陆编码标准，20000多个。

            Unicode：二个字节，表示所有字符，60000多个，Unicode组织提出，

                  Java采用Unicode编码，几乎包含所有字符。

        String：

        字符串，是一个类，不是一个基本类型。

        String，要用" "进行赋值表示。

        default data type ： int

       引用类型： 类，接口，数组

             类：

               定义： 从对象中抽象出来的一个模板，在模板中有方法特征和属性特征，可以

                通过类来创建相应的实例。

               结构：

               package [packagenames];

               import <class or package>;

               修饰符 class类名{

                   修饰符 属性类型 属性名

                   修饰符 构造器名

                   修饰符 返回类型 方法名(参数类型 参数名)

          main方法执行过程：

         1．先到方法区搜索Student。class对象(此对象它描述了Student类的方法特征及静态成员等)，如果搜索不到则去加载Student的字节码文件;

         2．通过classpath查找对应的Student字节码文件，找不到就返回错误：类找不到;

         3．将字节码文件的二进制数据转换为class对象放置于方法区，加载完成;

        4．验证字节码文件;

         5．在堆区划分空间，放置Student对象;

         6．在栈(stack)区放置引用类型变量stu，stu值的Student对象的地址;

         7．Student对象存放class对象的地址;

         8．通过stu引用类型变量的值找到Student对象，通过Student对象存放class对象的地址找到对应的study方法，然后执行;

         9．释放资源，JVM运行结束。

         基本类型于引用类型的区别：

    （1）引用类型存放的是对象的地址；基本类型存放的是变量的实际值。

    （2）引用类型变量可用指向复杂的数据结构。 

    （3）引用类型变量可用使用"."操作，来访问它所指向的对象的方法或者属性。

Chapter 03

Expressions and Flow Control

1．表达式：

     Definition：运算符和操作数按照一定的规则组成的语句。

     运算符：

     (1)赋值运算符

     (2)比较运算符

     (3)相等运算符

     (4)移位运算符

       对一个数的二进制位进行移位操作。

       左移(<<)   Description：×2的n次方

       Example：3(10)=00000011(2)

       右移(>>)   Description：/2的n次方

        Example：3>>2=?

         移动的时候，对于最高位，复制符号位。

       无条件右移(>>>)

            在移动的时候，对于最高位(符号位)，不复制最高位（符号位）。

            负数右移的位数越小，值越大。

        Example：-12>>>1=?

     (5)位运算符

         对一个数值的二进制位进行操作。

         ~ ：取反

 ^ ：异或

 | ：或  

&：与

     (6)逻辑运算符

         &&：短路与操作

     (7)条件运算符

         Syntax:

? ：

2．变量的作用域：

     Definition：变量生存的时间。

(1)变量的分类：

        类的成员变量

①类的静态成员变量

    Example：Student类的带static修饰的属性

    类的静态成员变量的生命周期：

        从类加载开始，到类被卸载结束。静态成员初始化以后放在方法区。

②类的实例成员变量

Student类的不带static修饰的属性。

变量初始化以后放在堆区。

实例变量的生命周期：

  A．从对象生成开始，到对象被回收时结束。

B．类的实例成员变量在对象初始化的时候，会赋默认值。

          基本类型number type：0，Boolean：false，character type ：'"u0000'

          引用类型：null，如String

C．先按照B的规则赋给一个初始值，然后构造器的赋值过程会覆盖掉初始值。

        局部变量

           定义：指方法或代码块中定义的变量。

           JVM中的某个线程调用方法的时候，将局部变量压入栈区开始，方法调用结束，（2）局部变量

    Definition：局部变量是方法或代码块中定义的变量。

           局部变量从栈区(stack)弹出结束。

           局部变量在使用前必须要赋值。

 （3）方法的参数

            例如：for(int i=0;i<10;i++)，add(int i1，int i2)

 （4）异常的参数

        例如：try...catch(Exception e)

3．流程控制：

    if语句：

         A．三种典型的格式;

         B．布尔表达式只能赋值true or false

    switch语句：

         A．switch条件值只能是byte，short，char，int;

         B．case语句后，要加break;

         C．default语句可选，最多只能有一个，可以放在任何位置

    for语句：

    while语句;

    do while语句

    break语句：跳出当前循环;如果有标号(label)，会执行循环之后的语句

    continue语句：跳出当前语句，如果有label，会执行标号处的语句。

    label（标号）：类似于goto语句，跳到另一个地方（尽量不要使用）。

Chapter 04

Array

一、数组是什么？

1.基本概念：

Definition：数组就是相同类型元素的线性集合。

Array is a collection of the same data.

An array is object.

对数组的理解：

数组是一个对象，是一个指向数组的引用对象。

2.Syntax

Array Copy

二、为什么要使用数组？

三、数组主要用在哪些地方？数组不能用在哪些地方？

四、怎么样使用数组？如何更好地使用数组？应该选择怎样的数组（Array，ArrayList，LinkedList，Vector）

1.数组的使用：

 A．declare

int [] a=new int[3](声明一个数组类型的成员变量，并创建一个数组)

int[] a={};

int a[]={};

int a[][]={}

 B．create

Sample：a=new int[3];

        int[] a={1,2,3};

Advanced Feature:

a．在堆中分配连续内存空间；

b．对数组元素赋缺省值；

c．在栈中存放a引用类型变量，并指向堆中的数组

Tips：数组创建的过程

创建长度为2的数组，堆中分配空间，给数组元素赋默认值。

     C．initialize（初始化）

     Example：a[0]=1；

2．多维数组：

规则的二维数组

不规则的二维数组

(1) declare

 Example: int[][] a1;

          int[]a2 [];

          int a3 [][];

(2)create

 Example：a1=new int[2][];

           a1[0]=new int[3];

         a1[1]=new int[2];

         a1[2]=new int[1];

(3) initialize:

   for (int i=0;i<a1.lengh;i++){

      for(int j=0;j<a1[i].length;j++){

         a1[i][j]=default value;

      }

   }

Advanced Features

(1) 数组下标不要越界（否则JVM throws RuntimeException，在C++当中甚至会导致内存数据破坏，系统崩溃）；

（2）Mistake：

     int[3] a;

Explanation：声明数组却不创建数组。

 （3）与数组相关的工具类

System.arraycopy(scource,begin,dest,begin,source length)

PS：1）source会覆盖dest对应位置的元素；

2）dest的空间应该是足够的，否则会报数组越界

Chapter 05

Objects and Classes

Basic concepts in OOP

Encapsulation:隐藏实现过程，对外提供公开一致的接口、使软件易于更新与维护。

Polymorphism：一个事物自动获得另一事物的状态行为的机制。

Inheritance：一个类自动获得另一个类的属性或者方法的过程。

1.类的结构

    类名

       属性名

           静态属性

           实例属性：必须依赖于对象/实例

       方法

           静态方法

           实例方法

       构造器

           缺省构造器

           带参的构造器

        静态代码块

        实例代码块

2.参数传递

    对于基本类型，将实际参数的值原样的复制一遍传值;

    对于引用类型，将引用类型变量的地址值复制给实参。

3.Where can we use “this”？

   A.实例变量于局部变量同名，用this。实例变量名来和局部变量加以区分;

   B.在构造器的重载的时候，用this来调用其他的构造器;

   C.在实例方法中，用来将当前对象的引用传递给另外的方法。

4.方法的重载

   A.方法名要相同;

   B.在一个类中，多个方法具有不同的方法签名(参数类型/参数个数/参数顺序)，方法可以重载

   C.返回类型不作要求

5.类的初始化的过程：

 类的静态成员在类被加载的时候进行初始化!

 (1) 在堆中分配空间;

 (2) 给对象的属性赋默认值

      boolean=false;

      基本类型=0;

      引用类型=null;

 (3) 调用构造器

     构造器可能会初始化属性值;

 （4）进一步赋值

 6.构造器

              类中提供的用于初始化对象的特殊的方法，这个方法

              与类名相同，无返回值

              缺省构造器？

              A.类中没有提供构造器，JVM会提供一个不带参的缺少构造器

              B.类中有带参的构造器，JVM不会提供了。

 7.封装 继承 多态

 (1) 封装

         A.将类的实现细节隐藏起来

         B.对外提供一致的接口

         C.提高系统的维护性

  (2) 继承（Inheritance）

      定义：

      一个类自动获得另一个类的属性或者方法的过程。

      使用：

     public void class A extends SubA{

      }

      A.单根继承

      B.所有的类都是object的子类

      C.类没有显示地继承另外一个类，则缺省继承了object

      基本规则

      A.构造器不能被继承

      B.子类初始化时会默认情况下调用父类缺省的构造器

      C.子类调用父类的带参的构造器，则父类可以不用缺省构造器

      怎样使用继承：

      A.区分"Has-a"与"Is-a"；

      B.子类要扩充父类的功能；

      C.子类需要大量置换父类的功能时，不应该使用继承；

      D.不要从工具类（一些辅助运算的方法）中继承。

      继承的优缺点

      优点：

      1.继承是最容易的复用代码的形式

      2.修改父类的功能是，子类可以自动获得新的功能

      缺点：最大的缺点是打破封装，继承只是类型（静态）复用。

      PS：静态类型的复用，牺牲了类的自由。

父类的引用类型变量可以调用子类的实例，反之则不成立，即子类可当父类用。

（3）多态：

      A．编译时，编译器检查声明类型(类型/方法信息)

      B．运行时，JVM对实例方法和引用变量实际引用的对象动态绑定，对静态方法和引用变量声明的类型静态绑定。

      C．类的属性在编译阶段绑定。

 8．instanceof：

    判断实例是否为某个类型的或者其子类型的实例

    A.只能在父子类进行比较;

    B.null可以进行比较，结果为false;

    C.判断实例的类型时，一般从子类开始，然后是父类

9．override：

    方法覆盖是值子类重写父类中的方法。

    子类要想override父类的方法有以下条件：

    A.方法名相同

    B.方法签名相同

    C.返回值相同

    D.子类的修饰符>=父类的修饰符

    E.子类抛出的异常要小于父类抛出的异常

F.父类中抽象方法可以被子类通过两种途径覆盖：

    1）子类实现父类的抽象方法；

    2）子类重新声明父类中的抽象方法。

10．Casting

    1.子类可用作为父类用：

       引用类型为类的变量可以指向子类型的实例

    2.引用类型为子类的变量不可以指向父类型的实例

         A、可用强制转换

           SubA a=(SubA)new A()'

         B、编译能通过，但运行出错

    3.在使用casting的时候，先使用instanceof判断实例类型。如果为真，则可强制转换。    

11．依赖关系

 A.一个类中的方法，其局部变量类型是另外一个类，则这两个类具有依赖关系

 B.一个类中的方法调用另外一个类的静态的方法，则A依赖B，记作A->B

 C.一个类的方法中的参数是另一个类的静态方法。

Advanced Features：

1．在Java中，类的定义与实现必须一次完成，成员、方法都必须定义在类之中。

2．方法的局部变量是另一个类。

3．this

   The order“this”point to the current class or object.

this是一个keyword，表示对象中指向自身的一个引用，在实例方法中用来指代当前对象。

this的主要用途：

4．private只能被当前public类访问，不能通过其他类访问。

5．Encapsulation can enhance maintainability．

   封装能够增强系统的可维护性。

6．方法签名

   方法签名就是指方法的参数类型、顺序或者个数不一致。

   方法签名不一致，方法就可以被重载。

7．类的初始化过程  

      (1)先对父类初始化(先初始化实例成员，包括属性和代码块<无static修饰>，初始化构造器)

      (2)再对子类初始化

      (3)如果有静态成员(静态属性和静态代码块)，从父类到子类，先执行类的加载并且初始化这些静态成员。

8．Constructor(构造器)

   Constructor can not be inherited．构造器不能被继承。

   Java程序员为对象提供初始化的构造器是一个良好的编程习惯。

   构造器存在的唯一目的就是初始化。

   如果存在多个构造器，就可以被重载。

   如果不指定构造器，JVM就会提供缺省的构造器。

   如果自定义的类中没有构造器，JVM会提供无参的default修饰的构造器。

   如果类中已有带参的构造器，JVM不会提供默认的构造器。

9．继承，是静态复用或者说是类型复用的机制。

带有继承关系的类的初始化过程

（1）如果有static属性修饰的代码块，则从父类到子类，先执行类的加载，并且初始化这个静态成员；

（2）如果没有static成员，则先初始化父类实例成员和构造器，再初始化子类实例成员和构造器。

10．为什么要使用继承？

（1）继承者（子类）要扩展父类的功能

11．父类的引用类型可以指向其子类的实例：

sample:

B b=new SubB();

子类SubB可以当父类B来用。

但是，很显然地，父类B不能当子类用，我们可以把这种错误的继承行为比喻成“乱伦”。

12．Single Inheritance：

(1) 任何子类都只能有一个父类；

（2）所有的类都是Object的子类；

（3）如果说一个类不继承任何子类，会自动隐藏“extends Object”。

13．构造器是怎么样运行的？

子类的构造器默认情况下会调用父类的构造器，如果子类的构造器指定调用父类带参的构造器，则父类可以不提供缺省的构造器。

14．Polymorphism

在多态中当中，类的属性在编译阶段确定，在编译阶段绑定。

静态方法不能override。

静态方法不能用实例方法重置。

静态方法覆盖静态方法，调用的不是声明类型时定义的方法。

15．keyword:：instanceof

description：判断某个实例是否为某个类型的实例或者其子类的实例。

    Syntax:

<examplename> instance of <typename>

16．casting：

父类不可以当子类用，即使类型匹配+强制转换，也会throws NumberFormatException。

17．方法覆盖

   父子类之间满足一下条件可以override：

   （1） 方法名、方法签名一致；

   （2） 子类修饰符的限定范围不能小于父类的修饰符

   （3） 如果子类抛出的异常类型与父类抛出的异常类型有继承关系，那么子类异常类型不能是其父类异常类型的父类或更高，否则子类的Exception 会抢先throws，导致父类Exception失效。

18．Polymorphism运行机制：

在类编译阶段，编译器会检查类型是否匹配（检查声明类型、方法等）。在运行阶段，JVM会调用实例的对应方法，先检查父类方法，后检查子类方法。然后编译器会检查实例声明的类型。

19．什么是OOP？OOP相对于面向过程编程有哪些优点？

OOP，Object-Oriented Programming，面向对象编程不同于面向过程编程：

（1）OOP关注对象和角色，也就是事物的本质

     1）OOP把客观世界中的对象抽象成对应的类；

     2）通过类构造实例；

     3）通过依赖、继承、实现等形式建立对象间的通信关系

（2）OOP易于扩展，增加或改变业务的功能，无需大幅改动改变源代码

（3）OOP易于建模，OOP就是软件架构师在计算机高级语言中对客观世界的抽象和再现，人们可以很好地理解和建立起计算机中的抽象模型

面向过程编程：

关注的是事物的行为、实现步骤、实体的操作；

面向过程编程的代码是分散的，不具备良好的架构和设计理念；

应对变化的能力很差，往往牵一发而动全身。

例如在一个象棋游戏程序中，OOP关注棋盘、棋手和规则三个对象以及它们之间的关系，而不关心下棋的各种各样的步骤。

20．static成员常用来提前做全局的初始化工作。

21．super

   （1）调用父类的属性；

（2）调用父类的方法；

（3）子类与父类有同名的方法，子类可用super.methodname来区分是父类的方法；

22．怎样使用抽象类？

（1）尽可能把可以共用的方法和逻辑放到抽象类中；

（2）属性应尽可能放到子类中。

Chapter 06

Advanced Language and Features

1.final

    final修饰的类不能被继承;

    final修饰的方法不能被override

    final修饰的变量是常量,常量不可修改,但有例外:

       实例常量:

       A.若定义时为赋值,则可以在构造器或者实例代码块中赋值

       B.构造器或者代码块赋值只能有一个

       静态常量:

            若定义时没有赋值,可在静态代码块中赋值

2.抽象类:

     定义:

         具有部分实现的类.

     格式:

       abstract class(){

       }

     使用:

         1.不能实例化

         2.可有零到多个抽象方法

         3.可有构造器

         4.具体类继承抽象类时,必须实现所有的抽象方法

         5.抽象类可以间接地被子类调用其构造器,并且在内存中分配空间,间接实例化

         6.抽象类可以有静态方法,可以返回其子类的实例

         7.抽象类可以被执行

     抽象类使用注意事项:

         1.把各个类中可以共用的方法和逻辑放到抽象的父类中,越多越好

         2.属性应该尽可能地放在子类中

     模板方法的使用:

         1.在抽象的父类中定义高层的业务逻辑final method( ){ };

         2.在抽象类父类中定义抽象的方法:abstract step1(); abstract step2();......

         3.子类实现相应的抽象方法

         4.调用者调用final方法

         5.抽象方法的扩展可以在final方法中加入前置或者后置方法(这些方法应该是实例方法,提供空的实现)

     为什么要使用抽象类?

     里氏代换:基类(父类)能够出现的地方,子类一定能够出现.

     大部分情况下,是从大多数对象中抽象出的属性和方法,是为了方便代码的复用.

     抽象类的存在,就是为了继承.

     怎样使用抽象类?

     A.在抽象类中共有的代码和逻辑,应该尽量地多.共用的业务逻辑(具体方法)应该;尽可能地放在抽象类中.

     B.属性尽可能放在具体类中.

3. interface（接口）

     一 什么是接口?

     (1) 接口应该是一个规范(宏观)

     (2) 接口是一种抽象类型:

            (1)属性是常量,一定要赋值

            (2)方法是抽象方法

            (3)没有构造器

            (4)接口支持casting

            (5)类中,接口中定义内部的接口

            A implements ID.IE:不必要实现ID中的方法

             A implements ID:不必要实现IE中的方法

             类中定义的接口,可以有修饰符

            (6)接口可以继承多个接口

            (7)实现接口的类必须要实现所有的方法,如果是抽象类可以选择实现部分的方法

            (8)如果又要继承类又要继承接口:

             A extends SuperA implements I1,I2

        接口没有任何实现,但有抽象方法(默认为abstract和public))和属性(默认为常量 public staitc final)

              格式:

                  interface IA{

                  //不能有构造器

                  //属性必须赋值

                  String str="Hello";    //省略了public static final

                  //方法必须是抽象方法

                  void f();           //default : public final  

        为什么要使用接口?抽象类和接口如何区别,有了抽象类为什么还要使用接口?

        答：

        (1)接口不能有构造器,但是抽象类可以;

        (2)一个抽象类一次只可以被实现一个,而接口可以多个

        (3)一个抽象类可以被一个类继承,而接口可以多个

        (4)如果只有抽象类没有接口,就会导致不同设计类型无法匹配

        (5)类以后要继承其他的类,所以目前不能继承,但可以用接口

        (6)两种完全不同的类型,从逻辑上说不应该继承,但可以用接口转化成另一种类型

     (3)为什么要使用接口?

           (1)可插入性的保证,可以随意更换接口的实现类;

           (2)接口可以解决多重继承的问题

           sample:

            A extends B implement I1,I2,

           一个类可以转化成多种类型,继承永远只能是一种类型

           (3)接口使规范的制订者 实现者 使用者分开

               规范的制订者:国家"组织或机构对方法的特征(methodname,return type,aguments),

               负责声明抽象方法

               规范的实现者:implements

               使用者:

               分开的好处:使各个变化独立实现

 4. 接口的基本使用

      (1)实现接口的类,必须要实现其所有的方法

             具体类:全部实现

             抽象类:部分实现甚至可以不实现

             Tips:

             实现:implements

      (2)一个类可以实现多个接口

          Syntax:

          classname implements <interfacename1,interfacename2>;

      (3)一个接口可以继承另外一个接口,并且可以多个,还可以多重继承

      (4)接口可做类型的声明,支持类型转换(Casting)

      sample:

         IA a;

         a=new AImpl;

      (5)接口定义在另外的一个类或者接口里

      (6)接口的常用的用法

        1) 常量接口:public static final,直观 方便 代码精简

        2) 标识接口:没有任何的方法的空的接口:唯一的作用就是用来标识类型

5. 接口与抽象类的区别

      1) 接口没有任何的实现,而抽象类它可以有部分的实现也可以没有;

      2) 如果需要复用或者共享部分代码,应该用抽象类而不是接口;

      3) 继承无法解决类型的转换问题,接口就是为了解决这一问题而产生的

      (Java的单继承是接口产生的根本原因) 接口是一种抽象的第三方规范,跟对象没什么直接关系。

     6．访问控制:

     （1）包的作用

 A.区别同名的 类

        B.访问控制

        C.组织类

   （2）import

      A. 一个类要使用其他包中的类,需要引入

      B. "*"可以引入包中的所有的类,但不会引入子包

      C. 引入包是,引入到类名

   D.位置

7．Object中的方法

     (1) equals()

     (2)toString()

     (3)hashCode()

     (4)clone()

8．Inner classes

   (1)静态内部类

   (2)成员内部类

  (3)方法内部类

     1)不能用修饰符

     2)只能访问其所在方法的常量

     3)如何调用方法内部类中的方法

   (4)匿名内部类

      1)没有类名

      2)格式

      3)内部类的作用:

           封装

           多重继承

           内外部类之间可以方便地访问

           简化编程

      4)包装类:

          把基本类型转化成一个类

          转换类型的方法

          hashCode

          MIN_VALUE MAX_VALUE

          在需要将基本类型包装为一个类的时候,比如collection方法

9. Collection Framework

      一组类和接口,用来方便地管理对象

   (1)组成部分:

     Collection

     Map

     Iterator(迭代器)

     其它: Collections类

   (2)Collection

       Set

       A.无序,不允许重复元素

       HashSet

          主意自定义类,要实现equals hashCode

       TreeSet

         排序

         A.类实现Comparable接口

         B.提供一个实现Comparator接口的比较器(高优先级)

       List

       A.有序

       B.允许重复

         ArrayList

           基于数组,长度可以动态地变化

           查询的效率比较高(相对LinkerList)

         LinkerList

            基于链表实现

            插入与删除效率高

Advanced Features：

Inheritance

The intrinsic reason of using interface is single inheritance.

使用接口最本质的原因是Java的单继承特性。

 Polymorphism：

可以把一个子类对象当做一个父类对象看，只能调用父类中有的属性和方法。

      如果子类覆盖了父类的方法，那么把子类对象当父类看时，调用子类覆盖后的方法。

       Animal() eat()

       |               |

     狮子             马

   eat() 吃肉          eat()吃草

   左边：把它当什么看，右边：对象本身

 什么时候可以强转：认为有可能强转时才能转。

 Animal a=new Dog();

 Dog d=a;           //编译时出错不兼容类型

 Dog d=(Dog) a;     //认为有可能对的情况才会通过编译

 Animal b=new Cat();

 instanceof 是用于判断一个对象是否属于某个类型，常用在强制类型转换之前。

1 static 修饰符：

 static：静态的，可以修饰：

 (1)属性：静态属性，全类公有，常叫做类变量，和具体对象无关，无多态，类名去访问，类加载的时       候初始化，像动物园动物个数。不是某个具体对象的行为。

 (2)方法：静态方法中只能访问类的静态成员(包括静态属性和静态方法)，非静态方法中可以

     问静态方法的属性和成员。 工具类的对象都是static的 (java。math就是工具类)

 (3)代码块注：初始代码块是在类中而不再任何方法之内的代码块。被static修饰的代码块称静      态代码块，静态初始代码块在类加载的时候运行一次。

2 变量：

 局部变量

 实例变量 非静态    属性

 类变量    静态      属性

3 类加载：虚拟机从磁盘上将字节码文件中的内容通过I/O流读到内存的过程。在虚拟机的生命周   期中一个类只被加载一次，什么时候加载什么时候运行。类的对象在类加载的时候被创建。 注：   Java命令的作用是启动JVM。

4 final修饰符，可以修饰：

 (1)属性：表示这个属性的值不可变。 例：身份证号 赋值时间两种：

          在定义时赋值，一般和static合用，不加也相当于static， 加上static省空间

          在构造方法中赋值，每个对象的值可以不一样。但值给定了，就不能变。

 (2)方法：表示这个方法不能被覆盖

 (3)类：表示这个类不能被继承。

 (4)方法中的局部变量：局部变量值不可变，常量。

5 abstract： 抽象的，可以修饰：

 (1)方法：只有定义，没有实现， public abstract void move(); //用分号代替一对大括号

 (2) 类：含抽象方法的类必须是抽象类，但抽象类不一定含抽象方法。

 抽象类不能实例化，即不能构造对象不能new。   Animal a1 =new Animal() //error!!!

 抽象类可以定义引用。让子类覆盖，抽象类作用，就是让子类继承。构造方法不能抽象。

 注意：abstract不能和final 合用

6 接口 interface：一个特殊的抽象类

 使用接口不能理解成继承接口，而应该理解为实现接口，关键字：implements

 接口里的属性都是公开静态的属性;方法都是公开的抽象方法。接口没有构造方法。

 例1： abstract class Myclass{            例2： interface IA{

          public static final int A=10;              int A=10;

          public static final int B=20;              int B=20;

          public abstract void m1();                 void m1();

           public abstract void m2();                 void m2();

     }                                            }

   例1 和 例2 是等价的。

 接口和接口间存在继承关系，接口之间可以多继承，之间用逗号隔开。

 一个类在继承另外一个类时还可以实现接口，要先写继承后写实现。

 class1 extends class2

 class implements interface1

 interface extendsinterface1

 把接口当成功能模块，标准

 标准的制定者和标准的实现者分开。

7 对象相等判断：equals方法

   写equals方法原则：

 (1) 满足自反性 a.equals(a) 必须为真

 (2) 传递性 a.equals(b) b.equals(c) -> a.equals(c) 为真

 (3) 对称性 a.equals(b) 为真， 那么b.equals(a) 为真

 (4) 一致性 对象属性不改变时，返回值要一致。

Chapter 07

Advanced language Feature

Static Class Variables

Static Methods

静态方法不需要实例就可以调用。

类、静态方法不能访问非静态成员。

静态方法不能被非静态方法覆盖。

Static Initiation Block

静态代码块在创建对象的时候就已经初始化，而实例代码块是在程序运行的时候才起作用。

Exceptions

一、什么是异常？

1.Definition

JVM将程序运行中的不正常情况的现场信息打包成一个对象（异常类对象），并且将此对象抛出，交由相应的方法或者对象来处理。

Advanced Feature

1.发生错误以后会抛出一个异常对象

2.异常记录了：错误的原因

             指出了错误的位置，打印了错误的“栈”信息（异常使用方法调用栈结构），异常处理的机制是“责任链”机制，即子类取默认值，不处理，则交由父类处理，直至追究到JVM，然后抛给用户。

2.Syntax

二、为什么要处理异常？

最本质的原因是让程序能执行完毕。

对待异常最基本的处理：

无论出现什么异常，必须采取措施，想方设法让程序执行完毕。

三、Syntax

getMessage();

PrintStackTrace();

Advance Feature:

Error、Exception是Throwable的子类

Error：错误，程序运行中发生的系统异常，此种异常当前程序一般无法解决。

如何捕获异常：

try…catch()语句可以捕获异常。

catch（）可以没有，不过一定要接finally语句。

Syntax：

try{

    code which may make a mistake

}

catch（possible exception type<options>）{

body of method

}

受查异常：编译器强迫必须捕获并处理的异常

非受查异常：对于此种异常，编译器不要求捕获

为什么非受查异常编译器不要求捕获？

1.low-grade mistake，程序员完全可以避免的错误；

2.当错误发生是你捕获异常也无济于事

Exception包括RuntimeException与受查异常，其他为非受查异常。

四 处理异常

1.Exception type:抛出异常或者该异常的父类;

2.测试代码在try与catch()语句之间

step1:将有可能出错的代码放在try...catch()语句之间

step2:在catch()中捕获异常,异常类型可以声明是其父类

step3:在catch()中处理异常

五 如何处理异常

1.交给自己处理,交由当前方法处理

2.交给别人处理,由调用该方法的方法来处理

3.自己处理一部分,然后调用系统的异常方法

交给调用方法的处理步骤:

step1:在方法后申明可能出现的异常(throws Exception type)

step2:该方法不用再作其它异常处理

step3:调用方法必须处理被调用方法申明的异常

Tips:

   被调用方法声明的异常类型不能小于调用方法声明的异常类型

对于throw,注意事项:

(1)throw抛出的异常可以是另外一种类型的异常

为什么要throw的抛出异常类型要进行异常转换?

   首先,throw抛出的异常类型可以是throw抛出的异常类型的同类和其父类;

   其次,如果程序员throw抛出的异常类型转换为其父类,目的是进行异常处理;

  更深一个层次,抛出的异常类型为父类,然后进行异常处理包括:

       写入日志文件,

       对异常采取措施使程序能够执行完毕,而不是throw,

       向后台发送讯息,

       打印异常信息(比如BLException)

    不要放过被捕获的异常,捕获的异常如果不处理就会被抛出.  

此时throws声明声明的异常应该是抛出异常,throw异常和throws异常类型应该保持一致

(2)throw语句后不能再有其他代码,throw后面的代码永远不会被执行

六 多重异常

在try...catch()语句中可能不只抛出一个异常,但是每一时刻只能抛出一种异常.

Syntax:

try{

   }catch(Exception type1){

   method body1

   }catch(Exception type2){

   method body2

   }

   多重异常处理应注意的问题:

   (1)对可能抛出的每一种异常分别用catch()来处理

   (2)catch()语句处理多重异常应该遵从从子类到父类的顺序?

   为什么?

   多重异常是多个异常的集合,如果异常A是异常B的父类,那么先处理了异常A,就不可能抛出子类的异常.

   (3)多重异常也可以用多种异常的父类型来处理

      声明异常的父类来抛出异常可以用instanceof来判断异常类型,然后处理各类捕获的异常

      未捕获异常:异常捕获遗漏的异常.

七 finally

   用于资源的释放,一般用在异常处理语句

   finally的使用:

   (1)finally用于资源的释放

   (2)在异常处理当中,finally语句一定会被执行

  (3)finally语句中如果有return语句,正常运行先执行finally,再执行return语句返回.   

     当异常发生时,先执行catch语句捕获异常.如果没有catch语句,则执行finally语句以及其他语句.

   (4) try语句后面一般接catch语句,然后没有catch语句,一定有finally语句.

   (5) finally当中的return语句会overload正常的返回结果,并且有可能丢失异常.

   因此不要在finally语句中使用return语句.

  （6）finally语句中，方法可以被overload，但不可以override。

八 自定义异常

   1.为什么要自定义异常?

   (1)Java程序员可以定义更多的方法来处理异常

   自定义异常类能提供更复杂更详细的方法,这样能极大地加强软件的健壮性

   比如BLException:用一个异常的功能号来找到异常信息

   (2)代码更加清晰

   2.怎样自定义异常?

   方式1:继承 Exception

   方式2:继承 RuntimeExceptiom

九 在Override 构造器中处理异常需要注意的问题

   在方法override时如果父类方法声明的异常是运行时异常,则子类可以声明声明更多的异常.

   非受查异常:NullpointException

             ArithmeticException

             NumberFormatException

             NagtiveArrayException

             SecurityException