Android-Java基础.doc

第一章 Java基础

1.1 java语言的简述
自从Java问世以来，其成长在计算机世界的每个角落。Java是对传统计算机程序设计模式的挑战，它对计算机软件开发和软件产业都产生了深远的影响。Java经过多年的发展，现在已经真正成为严格、主流的开发语言。Java给我们带来的一些新概念,诸如垃圾收集、虚拟机等，已经为C#等新语言所吸纳。虽然Java不如C++灵活和全面，但更为简洁。由于跨平台与网络功能是未来软件的发展趋势，Java在此方面具有得天独厚的优势，所以未来Java依然会占据主流软件开发语言的位置。
1.2 java语言的特点
java语言是简单的。Java语言与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。另一方面，Java语言不使用指针，并提供了自动的废料收集，使得程序元不必为内存管理而担忧。
java语言是面向对象的。java语言提供类、接口和继承等，其只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
Java语言是分布式的。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。
Java语言是健壮的。Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
Java语言是安全的。Java提供了一个安全机制以防恶意代码的攻击。Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。
Java语言是可移植的。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，java的运行环境是用ANSI C实现的。
Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在连接阶段被载入到运行环境中。
Java是高性能的。与那些解释型的高级脚本语言相比，Java的确是高性能的。
Java语言是多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread（Runnable）的构造子类将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出类并重写run方法，使用该子类创建的对象即为线程。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为Synchronized）。
Java语言是动态的。Java语言的设计目标之一是适应动态变化的环境。Java程序需要的类能够动态地被载入到运行环境中，也可以通过网络来载入所需要的类。
1.3 Java中的流程控制语句
1.分支语句 :if-else, break, switch, return.
2.循环语句 :while, do-while, for, continue.
3.例外处理语句 :try-catch-finally, throw
switch语句中的default子句是任选的，当表达式的值与任一case中的值都不匹配时，程序执行default后的语句。如果表达式的值与任一case中的值都不匹配且没有default，则直接跳出switch语句
break语句用于在执行一个case语句后，使程序跳出switch语句。break语句起到一个标号的作用，用来查找匹配的入口并从此处开始执行，对后面的case语句不再匹配，case语句中有多个执行语句时，可以不使用大括号
switch语句的功能优于if－else
breake语句可以跳出它所指定的块并从紧跟该块的第一条语句处执行，例如：
a:{……
b: {……
c: {……
break b;
…… //will not be executed
}
…… //will not be executed
}
…… //execute from here
}
return语句:
从当前方法中退出，返回到调用该方法的语句处，并从紧跟该语句的下句继续程序的执行。
continue语句:
用于结束本次循环，跳出循环体中下面尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环
1.4 面向对象编程

1) 类的定义格式如下：
[修饰符] class 类名 [extends 父类名] [implements 接口名1，接口名2，…]{
类属性声明；
类方法声明；
}

其中以[ ]括起的内容表示定义时可以没有。以大括号括起的内容称类体，之前部分称类头，[修饰符] class 类名 [extends 父类名] [implements 接口名]部分就是类头。

2） 类头说明
类头中关键词class表示类定义的开始，后面紧跟的是类名。
修饰符用来说明类的特殊性质，如前面程序中的public等。
-private(私有)： 修饰的类只能被同一包名中的类访问，这是Java默认方式；
-public(公共)： 修饰的类能被所有的类访问；
-abstract(抽象)： 修饰的类不能被实例化，它包含有未实现的方法。
-final(最终)： 修饰的类不能被继承，即不能有子类。
关键词extends表示该类是个子类，它的父类名紧跟在extends后。
关键词implements表示该类实现了哪些接口，后面就是接口名。

3) 类体说明
类体中定义了该类所有的成员变量和该类所支持的方法，其形式说明如下：
类体
{
[成员变量说明]
[构造方法说明]
[静态初始化说明]
[方法说明]
}
类体由成员变量说明、构造方法说明、静态初始化说明和方法说明构成，它们都是可选的
• 成员变量：
[修饰符] 变量的数据类型 变量名[= 初始值] ; //类属性为简单变量时
[修饰符] 类名 对象名[= new 类名([参数列表])]; //类属性为对象时

4) 成员变量说明
Java中成员变量说明形式如下：
[修饰符] 成员变量类型 成员变量名列表;
成员变量的修饰符有以下几种：缺省访问修饰符、public、protected、private、final、static
transient和volatile。
(1) 缺省访问修饰符
缺省访问修饰符的成员变量可以被同一包（package）中的任何类访问。
(2) public(公共)
public修饰的成员变量可以被项目文件中的任何方法所访问。由于public成员变量不受限制, 这易使类的对象引起不希望的修改，建议成员变量尽量不要使用public修饰符。
(3) protected (受保护)
protected修饰的成员变量可以被有继承关系的类自由访问，即子类可以访问它。
(4) private (私有)
private修饰的成员变量只能在同一个类中使用。这种方式通常是最为安全的。
(5) static(静态)：（类变量）
static修饰的成员变量又称为类变量。不加static修饰的成员变量又叫对象变量。对象变量依附于具体的对象实例，它的值因具体对象实例的不同而不同，而类变量为该类的所有对象共享，它的值不因类的对象不同而不同。
(6) final(最终)：（常量）
final修饰的成员变量叫最终成员变量。一开始创建该变量时将其设定了一个值，在以后程序的运行过程当中，变量的值将一直保持这个值不变。最终变量又称为常量。

5） 类的属性
Public void setName(String na)
{
name=na;
}
Public void getName(String na)
{
return na;
}
上面代码所对应的属性为name，setName是name属性的写操作器。
getName是name属性的读操作器。
读写操作器和属性之间的关系：
属性的首字母大写，在前面加上get或者set前缀。
Eclipse中提供了非常方便的get/set功能。

1.4.1 封装
面向对象使用类封装（即包装）数据（属性）和方法（行为）。封装使对象能够向其他对象隐藏它们的实现------该原则称为信息隐藏。尽管对象可以通过良好定义的接口互相通信，但是对象不知道其他对象是如何实现的。通常，实现细节隐藏在对象内部。在面向过程的编程语言（如C语言）中，编程一般面向操作。然而，Java编程是面向对象的。在面向过程的编程语言中，编程单位是函数（在Java中函数称为方法）。而在Java中，编程单位是类。最终实例化（即创建）这些类而得到对象，属性和行为作为字段和方法封装在类的“边界”内。
Java类使抽象数据类型（ADT）的创建者更加容易，同时向客户（或类的用户）隐藏了它们的实现。在过程化编程语言中存在这样一个问题，客户代码常常依赖于代码所用数据的实现细节。如果数据实现改变了，则这种依赖性可能会迫使程序员重写客户代码。ADT通过为客户提供独立于实现的接口（由类提供的方法集），消除了这个问题。类的创建者能够改变类的内部实现，而不会影响类的客户。
先来个例子看看：
　　public class Employer
　　{
　　//对属性的封装，一个人的姓名，年龄，雇员都是这个对象（人）的私有属性
　　private String name;
　　private int age;
　　private Employee employee;
　　//对改人对外界提供方法的封装，可以设定雇员，姓名，年龄也可以获得雇主的姓名和年龄
　　public void setEmployee(Employee employee)
　　{
　　this. employee = employee;
　　}
　　public String getName()
　　{
　　return name;
　　}
　　public void setName(String name)
　　{
　　this.name = name;
　　}
　　public int getAge()
　　{
　　return age;
　　}
　　public void setAge(int age)
　　{
　　this.age = age;
　　}
　　}
　　public class Employee
　　{
　　//属性封装
　　private String name;
　　private int age;
　　private Employer employer;
　　//方法封装
　　public String getName()
　　{
　　return name;
　　}
　　public void setName(String name)
　　{
　　this.name = name;
　　}
　　public int getAge()
　　{
　　return age;
　　}
　　public void setAge(int age)
　　{
　　this.age = age;
　　}
　　public Employer getEmployer ()
　　{
　　return employer
　　}
　　public void setEmployer (Employer employer)
　　{
　　this. employer = employer;
　　}
　　}
　　/**
　　* 仔细看就会发现，Employer类没有提供getEmployee的方法，这是以为雇主不想让自己的雇员被外界访问，
　　*
　　* 直接下来呢，就是封装可以吧一个对象的属性私有，而提供一些可以被外界访问的属性的方法，
　　*
　　* 比如说，name属性，Employer和Employee类都有相应的get和set方法，外界都可以通过这些方法访问和修改
　　*
　　* 同时对一些改对象不想让外界访问的属性，就不提供其方法，比如说Employer的Employee属性，就没有get方法
　　*
　　* 外界是不能带到Employer类的employee属性的
　　*
　　*/
　　上面那例子可能没有突出封装的好处，下面来个超简单的表达下：
　　public class Show
　　{
　　public static void show(String str)
　　{
　　System.out.println(str);
　　}
　　}
　　上面就是对 System.out.println();的封装。
　　调用的时候 ：
　　public class Use
　　{
　　public static void main(String[] args)
　　{
　　Show.show("封装")；
　　}
　　}
　　这样用的时候就不用使：System.out.println("封装")；
　　如果还有地方用到， 就省去了好多 System.out.println();
　　简而言之，有一段代码，如果3个程序要用它，你不封装，那你就得在这3个程序里都要写，浪费代码，浪费时间。
1.4.2 构造函数
构造函数初始化类的实例变量。在创建一个类对象时，new运算符调用该类的构造函数以执行初始化工作。构造函数名必须与类名相同（包括相同的大小写字母）。构造函数不能指定返回类型及返回值。一个类可以包含多个重载的构造函数，使该类的对象能够以不同的方法进行初始化。
在程序实例化类的一个对象时，可以在类名右边的括号中提供初始化值（initializer）(参数)，它们将作为参数传递给类的构造函数。创建类实例的表达格式如下：
new ClassName( arg1, arg2, … , argN)
这里的new表示正在创建一个新的对象，ClassName表示新对象的类型，arg指定类的构造函数用于初始化对象的值，整个表达式返回新对象的一个引用。
要求每个类都至少有一个构造函数。因此，如果没有为类声明构造函数，则编译器会创建一个没有参数的默认构造函数。类的默认构造函数将调用其超类（该类所扩展的类）的无参构造函数，然后将实例变量初始化为它们声明中所指定的初始值，或初始化为它们的默认值（基本数值类型为0，boolean型为false，引用类型为null）。如果超类没有无参构造函数，则编译器发出一个错误消息。
构造方法分为缺省的构造方法（不带参数）和带参数的构造方法
（1）缺省的构造方法
如果类的定义没有编制构造方法，Java语言会自动为用户提供。这个由Java自动提供的构造方法就是所谓的缺省构造方法。缺省的构造方法确保每个Java类都至少有一个构造方法，该方法应符合类的定义。
（2）带参数的构造方法
带有参数的构造方法能够实现这样的功能：当构造一个新对象时，类构造方法可以按需要将一些指定的参数传递给构造方法。
public Point(int x,int y) {
this.x=x;
this.y=y;
}

1.4.3 垃圾收集
在创建对象时，构造函数能够初始化该对象的实例变量。构造函数获取诸如内存等各种系统资源。当不再需要这些资源时，我们需要一种符合规则的方法将它们归还给系统，从而避免“资源泄露”。Java自动地执行垃圾收集工作，以帮助将对象所占用的且不再使用的内存返还给系统。当不再引用一个对象时，将标记该对象以用于垃圾收集。在垃圾收集程序执行时，将收回这个对象的内存。因此，尽管在其他诸如C和C++（因为这些语言不是自动地收回内存）等语言中常常会出现内存泄露，但Java却很少出现这种问题。
每个Java类都有一个终结（finalizer）方法，该方法将资源返还给系统。在垃圾收集程序收回一个对象的内存之前，将调用终结方法，对该对象执行终止内务处理（termination housekeeping）。类的终结方法总是finalize，它没有任何参数，并且返回类型为void型。该方法不能重载。finalize方法声明在Object类中，它只是一个什么也不做的空方法。

1.4.4 Static类
在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
静态方法不能以任何方式引用this和super关键字。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。

每个对象都拥有自己的类所有实例变量的副本。在某些情况下，一个类的所有对象应该只共享某个特定变量的惟一副本。静态域（称为类变量）就用于这些情况中。类变量代表类范围的信息----该类的所有对象共享同一块数据。静态成员的声明以关键字static开始。
尽管类变量似乎类似于全局变量，但类变量具有类作用域。可以通过引用一个类的任何对象，或者通过类名及点运算符（.）限定成员名来访问该类的public静态成员。private静态类成员只能通过该类的方法进行访问。实际上，即使不存在任何类对象，静态类成员也可以存在----只要类在执行时加载到内存中，就可以使用它们。当不存在任何类对象时，要访问一个public静态成员，则在该成员的前面添加类名及点运算符（.）作为前缀。要在不存在任何类对象时访问一个private静态成员，则必须提供一个public静态方法，并且在调用该方法时，必须添加类名和点运算符以进行限制。
例子1：
/*01*/public class static_demo
/*02*/{
/*03*/ public static int i=0;
/*04*/ public int j=0;
/*05*/ public void show()
/*06*/ {
/*07*/ System.out.println(i);
/*08*/ System.out.println(j);
/*09*/ }
/*10*/}
/*11*/
/*12*/class test
/*13*/{
/*14*/ public static void main(String args[])
/*15*/ {
/*16*/ static_demo obj1=new static_demo();
/*17*/ obj1.i=100;
/*18*/ obj1.j=200;
/*19*/ obj1.show();
/*20*/ static_demo obj2=new static_demo();
/*21*/ obj2.show();
/*22*/ }
/*23*/}

1.4.5 继承
继承是软件重用的一种形式，在这种形式中，通过吸收现有类的数据（属性）和方法（行为），并增加新功能或修改已有功能来创建新类。软件的重用性不仅节省了程序的开发时间，它还促进了经过验证和调试的高质量软件的重用，这增加了有效实现系统的几率。
在创建一个类，而不是声明全新的成员（变量和方法）时，程序员可以指定这个新类应继承某个现有类的成员。这个现有类称为超类，而这个新类称为子类（诸如C++等其他编程语言将超类称为基类，而将子类称为派生类）。一旦创建了子类，则它们以后也可以成为其他子类的超类。子类通常添加自己的变量和方法。因此，子类比它的超类更为特殊，并且代表一组更为专业化的对象。典型地，子类不仅展示其超类的行为，而且还展示特定于自身的行为。直接超类是子类显示继承的超类。间接超类是类层次结构中有两个或多个继承超类，而类层次结构定义了各类之间的关系。Java的类层次结构起始于Object类（在java.lang包中），所有的Java类均直接或间接地派生于该类。单重继承是指一个类只派生于一个超类。与C++不同，Java不支持多重继承（即一个类派生于多个直接超类）。
要能够用“is-a”关系和“has-a”关系。“is-a”代表继承。在“is-a”关系中，子类的一个对象还可以视为其超类的对象。“has-a”关系代表组合。在“has-a”关系中，一个对象包含一个或多个其他对象的引用成员。
新类可以从大量的类库中继承已有的类。团队不仅可以开发他们自己的类库，而且还可以利用世界上其他人员开发的类库。将来某一天，绝大多数新软件将都可能由标准化的可重用组建构成，正如现在大多数硬件的构成情况一样。这将有助于开发出更为强大、更多的软件。
例子1：
// BasicCalculator.java
/*01*/public class BasicCalculator{
/*02*/ public int add(int a, int b)
/*03*/ {
/*04*/ return a+b;
/*05*/ }
/*06*/ public int minus(int a,int b)
/*07*/ {
/*08*/ return a-b;
/*09*/ }
/*10*/}

// AdvancedCalculator.java
/*01*/public class AdvancedCalculator extends BasicCalculator{
/*02*/ public int multify(int a, int b)
/*03*/ {
/*04*/ return a*b;
/*05*/ }
/*06*/ public int devided(int a,int b)
/*07*/ {
/*08*/ return a/b;
/*09*/ }
/*10*/}

// Test.java
/*01*/public class Test
/*02*/{
/*03*/ public static void main(String args[])
/*04*/ {
/*05*/ AdvancedCalculator st1=new AdvancedCalculator();
/*06*/ int iResult=st1.add(3,2);
/*07*/ System.out.println("3+2="+iResult);
/*08*/ iResult=st1.minus(3,2);
/*09*/ System.out.println("3-2="+iResult);
/*10*/ iResult=st1.multify(3,2);
/*11*/ System.out.println("3*2="+iResult);
/*12*/ iResult=st1.devided(3,2);
/*13*/ System.out.println("3/2="+iResult);
/*14*/ }
/*15*/}

1.4.6 多态性
多态性使开发人员能够设计和实现易于扩展的系统。只要新类作为程序通常所处理的继承层次结构的组成部分，则这些类经过较少修改或不需要修改就可以添加到程序的通用部分中。为适应新类，程序惟一必须修改的部分是那些需要直接知道程序员添加到层次结构中的新类的部分。利用多态性，具有同样方法名和方法特征的方法根据调用方法的对象的类型，可以产生不同的动作。这极大地增强了程序员的表达能力。多态性使程序员能够处理程序的一般性问题，而让执行时环境处理特定问题。程序员可以命令对象以适合于该对象的方式进行工作，而无需知道对象的类型（只要这些对象属于同一继承层次结构）。
方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。
要理解多态性，首先要知道什么是“向上转型”。
我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过
　　Cat c = new Cat();
　　实例化一个Cat的对象，这个不难理解。但当我这样定义时：
　　Animal a = new Cat();
这代表什么意思呢？
很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，
定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。
所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；
同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
看下面这段程序：
　　class Father{
　　public void func1(){
　　func2();
　　}
　　//这是父类中的func2()方法，因为下面的子类中重写了该方法
　　//所以在父类类型的引用中调用时，这个方法将不再有效
　　//取而代之的是将调用子类中重写的func2()方法
　　public void func2(){
　　System.out.println("AAA");
　　}
　　}
　　class Child extends Father{
　　//func1(int i)是对func1()方法的一个重载
　　//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用
　　//所以在下面的main方法中child.func1(68)是不对的
　　public void func1(int i){
　　System.out.println("BBB");
　　}
　　//func2()重写了父类Father中的func2()方法
　　//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法
　　public void func2(){
　　System.out.println("CCC");
　　}
　　}
　　public class PolymorphismTest {
　　public static void main(String[] args) {
　　Father child = new Child();
　　child.func1();//打印结果将会是什么？
　　}
　　}
上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。
那么该程序将会打印出什么样的结果呢？
很显然，应该是“CCC”。
对于多态，可以总结它为：
一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
多态性促进了可扩展性：调用多态行为的软件与接收消息的对象类型无关。对于可以响应现有方法调用的新对象类型，无需修改基本系统，就可以将这个新对象类型集成到系统中。但必须修改实例化新对象的客户代码，使其适应新的类型。
接口描述一组能够由对象调用的方法。程序员可以声明用于实现一个或多个接口的类。实现接口的类必须声明该接口的所有方法。一旦一个类实现了某个接口，该类的所有对象与该接口类型就存在“is-a”关系，并且确保该类的所有对象都能够提供该接口所描述的功能。

1.4.7 抽象类和抽象方法
在思考某个类的类型时，我们假设程序将创建这种类型的对象。然而，在某些情况下，声明程序员从未实例化该类对象的类也是有用的。这种类称为抽象类。因为抽象类只能作为继承层次结构中的超类，所以这些类也称为抽象超类。不能实例化这些类的对象，抽象类是不完整的，子类必须声明缺少的部分。
抽象类的目的是提供一个合适的超类，以派生其他类。用于实例化对象的类称为具体类。这种类实现它们声明的所有方法。继承层次结构并不需要包含抽象类。然而，却经常在类层次结构顶部添加抽象类以减少客户代码对特定子类类型的依赖。抽象类有时构成若干级别的层次结构。
使用关键字abstract声明抽象类。抽象类通常包含一个或多个抽象方法（静态方法不能为抽象方法）。使用关键字abstract声明抽象方法，形如
public abstract void methodName(); // abstract method
抽象方法并不提供实现。包含抽象方法的类必须声明为抽象类。抽象超类的所有具体子类都必须为超类的抽象方法提供具体实现。
抽象类声明类层次结构中各个类的共同属性和行为。典型的抽象类包含一个或多个抽象方法，子类必须重载这些方法。抽象类的实例变量和具体方法必须遵循通常的继承规则。子类若没有实现超类的抽象方法，则会产生编译错误，除非子类也声明为abstract。
尽管不能实例化抽象超类的对象，但可以使用抽象超类来声明变量，用以保存抽象类所派生的任何具体类的对象的引用。程序通常使用这种变量来多态地操作子类对象。还可以使用抽象超类名来调用这些抽象类中声明的静态方法。
对于抽象类与抽象方法的限制如下：
1 凡是用abstract修饰符修饰的类被称为抽象类，凡是用abstract修饰符修饰的成员方法被称为抽象方法；
2 抽象类中可以有零个或多个抽象方法，也可以包含非抽象的方法；
3 抽象类中可以没有抽象方法，但是有抽象方法 的类必须是抽象类；
4 对于抽象方法来说，在抽象类中只定义其方法名和类型，而不书写其实现代码；
5 抽象类可以派生子类、在抽象类派生的子类中必须实现抽象类中定义的所有的抽象方法；
6 抽象类不能使用new运算符创建对象，但是仍可在抽象类中定义构造方法，可由派生类的构造方法调用；
7 abstract和final不能同时修饰一个类；
8 abstract不能与private、Static、final或native同时修饰一个方法；
9 abstract类中不能有private的数据成员或者成员方法；
10 父类不是抽象类（即具体类），则其子类仍可是抽象类；
11 虽然不能创建抽象类的对象，但抽象类可以当作数据类型使用，如作为方法形参类型、返回值类型、数组元素类型等。

1.4.8 使用this引用当前对象的成员
每个对象都可以使用关键字this（有时称为this引用）访问其自身的引用。在一个方法中，this引用可以隐式地或显示地引用调用该方法的对象的实例变量和其他方法。
如果一个方法包含一个与该类的某个域同名的局部变量，则该方法将引用该局部变量，而不是引用该域。在这种情况下，局部变量在该方法作用域中屏蔽了同名的域。然而，该方法可以使用this来显示地引用屏蔽的域。在一个方法中，this引用可以隐式地或显示地引用调用该方法的对象的实例变量和其他方法。
例子1：
// Using the this reference to refer to field and method (用this引用相关的域和方法)
import javax.swing.*;
import java.text.DecimalFormat;

public class ThisTest {

public static void main( String args[] )
{
SimpleTime time = new SimpleTime( 12, 30, 19 );

JOptionPane.showMessageDialog(null, time.buildString(), "Demonstrating the \"this\"Reference", JOptionPane.INFORMATION_MESSAGE);

System.exit(0);
}

} // end class ThisTest

class SimpleTime {
private int hour;
private int minute;
private int second;

// constructor uses parameter(参数) names identical(相同的) to instance variable names; //(构造函数参数名与实例变量相同)
// "this" reference required to distinguish between names
public SimpleTime( int hour, int minute, int second )
{
this.hour = hour; // set "this" object's hour (用this显示地引用屏蔽的SimpleTime类的实例变量)
this.minute = minute; // set "this" object's minute
this.second = second; // set "this" object's second
}

// use ecplicit(显示地) and implicit