Java的面向对象编程基本概念学习笔记整理

个人理解，编程中所谓的 类¨ 与现实世界中对物体的分门别类中的类是同一个概念，只是在编程中将其借用进来。类代表有一系列共性和相同操作或动作的事物，在编程中即为抽象的数据类型。具体的每个个体（现实世界中）、实例变量(对于在编程中来说)就是对象。

　 类是现实世界某些对象的共同特征(属性和操作)的表示，对象是类的实例。

    类的属性:就是类的静态属性的简称，指类内包含的各项数据，如变量或其他类的对象；
   类的服务:  则被称为成员函数或方法。

¨　

java中类的定义形式如下：

[修饰符] class 类名 [extends 父类] [implements 接口名]
{
 类成员变量声明
 类方法声明

}

我们再来仔细说说这中间的每一个部分：

在class关键字前，也即类的修饰符有大体分三种类型——访问修饰符public公共类、final修饰符(最终类说明符)和abstract修饰符(抽象类说明符)

          而其中，权限修饰符只能为public或默认(即为空，什么都没有，表示定义为友好的)，public表示该类可被任何地方使用和访问（只要程序能找到该类位置)，无论是在同一包内，还是在不同包。注意，这与c＋＋中不同，c＋＋中没有还对类的访问权限用修饰符来限制的，而是对类之间的继承关系有访问权限的说明，除此之外，它们倒是都对类的属性和方法有访问权限有限制。          默认的访问权限（即定义为友好的），即是指只能被同一包内的类引用和访问，而不能被其它包中的类访问和引用，即使import进去。

后面还会提到：以类的属性和方法缺省修饰符时，也表示为只能被同一包中的类引用和访问。

java中不允许多重继承，这与c++中不同，也算是为了弥补这个不足，java中引进了接口的概念。

上述类的定义中，类体中主要是类的具体内容，包括类的属性和类的方法。类的属性可以是简单变量，也可以是某些类的实例，如果是类的实例，可以如下定义：

[修饰符]   类名 对象名＝new类名（参数列表）；

在声明对象和复杂变量时，可以不在声明时用创建，可以在以后的构造函数中创建。

类中定义的方法通常起到两种作用：一是围绕着类的属性进行各种操作；二是与其他的类或对象进行数据交流、消息传递等操作。

java中声明方法的语法如下：

 [修饰符] 返回值类型 方法名(参数列表)

throws 例外名1，例外名2，…

{ 方法体：

 局部变量声明；

 语句序列；

}

类的方法，又称为成员函数，用来规定类属性上的操作，实现类的内部功能的机制，同时也是类与外界进行交互的重要窗口。

java程序员把注意力放在创建称为类的用户自定义类型（user-definedtype）上，类也称为程序员定义的类型（programmer-definedtype），每个类都含有数据和一组操作数据的方法，类中的数据部分称为实例变量。用户定义类型（即类）的实例称为对象。

对象是类的一个实例，类是同种对象的抽象，是创建对象的模板。在程序中创建—个对象将在内存中开辟一块空间，其中包括该对象的属性和方法。创建对象使用关键字运算符new。

构造函数（可以对比c++中，与c++几乎相同）

创建自己的构造函数
•构造函数的名字和类的名字是相同的。当构造employee类的对象时，此构造函数被启动，实例字段赋初值，在java中，定义和初始化是统一的——两者缺一不可。
  例如，用下面的代码创建employee类的一个实例时，

newemployee (“james bond”,100000,1950,1,1);

构造函数的特点有：

（1）构造函数和类具有相同的名字。

（2）一个类可以有多个构造函数。

（3）构造函数可以有0个、1个或多个参数。

（4）构造函数没有返回值。

（5）构造函数总是和new运算符一起被调用。

构造函数的作用
 (1）对象初始化

（2）引入更多的灵活度（变量赋值或更复杂的操作）

（3）java中可以不定义构造函数

 java中可以不定义构造函数，此时系统会自动为该系统生成一个默认的构造函数。这个构造函数的名字与类名相同，它没有任何形式参数，也不完成任何操作。

 方法概述
java程序是由一个个类定义组成的，类有两个部分：属性和方法。属性描述类是什么，方法描述类做什么。任何对象都有独立的内存存储它的属性。类的所有的对象共享存贮在内存的方法。

    换言之：方法是类的主要组成部分。在一个类中，程序的作用体现在方法中。

  方法即是java创建一个有名字的子程序。一个主方法和若干个子方法构成。主方法调用其他方法，其他方法间也可互相调用，同一个方法可被一个或多个方法调用任意次。
在一个方法中定义另一个方法将产生语法错误。

（1）最好避免局部变量“屏蔽”实例变量，在一个类中不使用同名标识符就可以做到这一点；方法调用中参数用来传递数值、传递引用，同时方法还可以嵌套、递归调用。
（2）方法体中如果指定了非void的返回值类型，方法中就必须包含一条return语句保证任何情况下都有返回数值，return语句后面不能跟任何表达式；
java程序的基本结构如下：

引入java类库；
定义用户类1
{
 
 定义类1的若干变量或对象：
 定义类1的方法1；
 定义类1的方法2；
  …
 定义类1的方法m1；
}
定义用户类2
{
 定义类2的若干变量或对象：
 定义类2的方法1；
 定义类2的方法2；
  …
 定义类2的方法m2
}

java推出了“访问控制修饰符”的概念，允许库创建者声明哪些东西是客户程序员可以使用的，哪些是不可使用的。

这种访问控制的级别在“最大访问”和“最小访问”的范围之间，分别包括：public，“默认”（无关键字），protected以及private。下面的列表说明访问控制修饰符含义：

公共访问控制符public
用于类：  

java中类的访问控制符只有一个：public，即公共的。一个类被声明为公共类，表明它可以被所有的其他类所访问和引用，这里的访问和引用是指这个类作为整体是可见和可使用的，程序的其他部分可以创建这个类的对象、访问这个类内部可见的成员变量和调用它的可见的方法。
一个类作为整体对程序的其他部分可见，并不能代表类内的所有属性和方法也同时对程序的其他部分可见，前者只是后者的必要条件，类的属性和方法能否为所有其他类所访问，还要看这些属性和方法自己的访问控制符。

用于类内属性：    

用public修饰的类内属性称为公共属性，若这个类是公共类则它可以被所有的其他类访问。

缺省访问控制符
用于类  

   假如一个类没有访问控制符，说明它具有缺省的访问控制特性。这种缺省的访问控制权规定该类只能被同一个包中的类访问和引用，而不可以被其他包中的类使用，这种访问特性称为包访问性。通过声明类的访问控制符可以使整个程序结构清晰、严谨，减少可能产生类间干扰和错误。

用于类属性  

    类内的属性和方法如果没有访问控制符号来限定，也说明它们具有包访问性。

3 私有访问控制符private
用private修饰的属性或方法只能被该类自身所访问和修改，而不能被任何其他类，包括该类的子类，来获取和引用
1）. 私有数据
例如有三个实例字段，它们含有在employee类的实例内部被操作的数据。

private string name;

private double salary;

private date hireday;

       private(私有的）关键字用来确保可以访问这些实例字段的只能是employee类本身的方法。

2）.私有方法
在实现类时，我们使所有的数据字段都是私有的，因为公开的数据是危险的。对于方法又是什么情况呢 ？虽然大多数方法是公开的，但是私有方法也经常使用。这些方法只能被同一个分离的方法。

总起来说，在下面的情况下可以选择私有方法：

  （1）与类的使用者无关的那些方法。

（2）如果类的实现改变了，不容易维护的那些方法。

保护访问控制符protected
用protected修饰的成员变量可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类。使用protected修饰符的主要作用是允许其他包中的它的子类来访问父类的特定属性。
         protected关键字为我们引入了一种名为“继承”的概念，它以现有的类为基础，并在其中加入新的成员，同时不会对现有的类产生影响——我们将这种现有的类称为“基础类”或者“基本类”（base class）。亦可改变那个类现有成员的行为。对于从一个现有类的继承，我们说自己的新类“扩展”（extends）了那个现有的类

私有保护访问控制符private protected
private和protected按顺序连用构成一个完整的访问控制符：私有保护访问控制符。用privateprotected修饰的成员变量可以被两种类访问和引用，一种是该类本身，一种是该类的所有子类，不论这些子类是与该类在同一个包里，还是处于其他的包中。

相对于protected，privateprotected修饰符把同一包内的非子类排除在可访问的范围之外，使得成员变量更专有于具有明确继承关系的类，而不是松散地组合在一起的包。

静态修饰符
static称为静态修饰符，它可以修饰类中的属性和方法。

使用static（静态）关键字，可满足两方面的要求：

（1）一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象；被static修饰的属性称为静态属性，这类属性一个最本质的特点是：它们是类的属性，而不属于任何一个类的具体对象。换句话说，对于该类的任何一个具体对象而言，静态属性是一个公共的存储单元，任何一个类的对象访问它时，取到的都是相同的数值，同样任何一个类的对象去修改它时，也都是在对同一个内存单元做操作。
（2）另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能用类直接调用的方法。

 static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法。

静态常量
静态变量是很少见的。然而，静态常量却很普遍。例如，math类中定义了一个静态常量：
public class math

{

……

public static final double pi=3.1.4159265358979323846;

……

}

静态方法
      声明一个方法为static至少有三重含义：
（1）使用这个方法时，应该使用类名做前缀，而不是某一个具体的对象名；
（2）非static的方法是属于某个对象的方法，在这个对象创建时对象的方法在内存中拥有自己专用的代码段；而static的方法是属于整个类的，它在内存中的代码段将随着类的定义而分配和装载，不被任何一个对象专有；
（3）由于static方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量。

5  main方法
    main方法并不对任何对象施加操作。实际上，当程序开始执行时，还不存在任何对象。静态方法被执行，并构造程序所需的对象。

   提示  每个类都可以有一个main方法。这是对类进行单元测试的一个很方便技巧。

abstract是抽象修饰符，可以用来修饰类或方法。

抽象类
当一个类被声明为abstract时，这个类被称为是抽象类。所谓抽象类就是没有具体实例对象的类。
针对这个问题，java专门提供了一种机制，名为“抽象方法”。它属于一种不完整的方法，只含有一个声明，没有方法主体。下面是抽象方法声明时采用的语法：
abstract void x();

抽象方法
     作为类方法修饰符，abstract则声明了一种仅有方法头，而没有具体的方法体和操作实现的抽象方法。

     可见，abstract方法只有方法头的声明，而用一个分号来代替方法体的定义：至于方法体的具体实现，那是由当前类的不同子类在它们各自的类定义中完成的。
需要特别注意的是，所有的抽象方法，都必须存在于抽象类之

中。
    除了抽象方法，抽象类也可以有具体的数据和方法。
  在java编程语言中抽象方法是非常重要的概念。在接口里你会大量的用到它。
注意：这里要与接口进行对比、记忆，接口中的方法都属于抽象方法，当然，接口中也有属性，其具体性质将在后文详述。

最终类、最终属性、最终方法与终结器（c++中可没有final最终修饰符）

final是最终修饰符，它可以修饰类、属性和方法。另外终结器的关键字与final很相近，一并介绍

最终类

    如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为abstract的，又被声明为final的。

被定义成final的类，通常是一些有特殊作用的、用来完成标准功能的类，将一个类定义为final则可以将它的内容、属性和功能固定下来，与它的类名形成稳定的映射关系，从而保证引用这个类时所实现的功能是准确无误的

最终属性
许多程序设计语言都有自己的办法告诉编译器某个数据是“常数”。常数主要应用于下述两个方面：

（1）编译期常数，它永远不会改变；

（2）在运行期初始化的一个值，我们不希望它发生变化。

     可以把一个实例字段定义为final(不能改变的)。在对象被构造时，这种字段必须被初始化。即，必须保证在每一个构造函数结束之前其值已被设定。以后字段的值不能改变

最终方法
          之所以要使用final方法，可能是出于对两方面理由的考虑。
        第一个是为方法“上锁”，防止任何继承类改变它的本来含义。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。
     采用final方法的第二个理由是程序执行的效率

终结器
终结器的作用是回收对象时执行的方法。类似与构造函数是创建对象时执行的方法一样。
例

protected voidfinalize(){
   system.out.println(“ “);

  }

其它修饰符

volatile

  如果一个属性被volatile修饰，说明这个属性可以同时被几个线程所控制和修改。

synchronized

  主要用于线程同步

native

  表示该方法不是用java语言写成的（是用c,c++等语言写的）

网上查到的一点资料:——内部类

简单的说,内部类就是类中的类,举个例子:

class a {
private int i;
private void m() {

}
class b {
mm(int j) {
i = j;
m();
}
}
}

这里,b就是a的内部类
内部类的特点就是,可以方便的访问外部类里面的私有方法和属性,比如,这里b里面可以直接访问a里面的私有属性i,和私有方法m()

面向对象编程最重要的特征就是封装性(也可称作抽象性)、继承性和多态性，那么，作为面向对象编程语言，java在这方面更是有其出色之处：

“继承性是软件复用的一种形式，对降低软件复杂性行之有效。继承性同时是面向对象程序设计语言的特点，采用对象但没有继承性的语言是基于对象的语言，但不是面向对象的语言，这是两者的区别”

类之间的继承关系是现实世界中遗传关系的直接模拟，它表示类之间的内在联系以及对属性和操作的共享，即子类可以沿用父类（被继承类）的某些特征。当然，子类也可以具有自己独立的属性和操作

继承性是软件复用的一种形式。新类由已存在的类生成，通过保留它们的属性和行为，并且根据新类的要求对性能加以修改，添加新的属性和行为。如果子类只从一个父类继承，则称为单继承；如果子类从一个以上父类继承，则称为多继承。注意java不支持多重继承，但它支持“接口”概念。接口使java获得了多重继承的许多优点，摒弃了相应的缺点。注意：c++支持多继承

继承关系的定义：

[修饰符]class子类名
extends父类名,父类名2

父类名跟在extends

  关键字后面，用来说明当前类是哪个已经存在类的子类，存在继承关系。

定义 雇员类  employee的两个子类：

一般雇员类:commonemployee

主    管    类:manageremployee

子类从父类继承有两个主要的方面：

（1）属性的继承。例如，公司是一个父类，一个公司有名称、地址、经理、雇员等，这些都属于结构方面。

（2）方法的继承。一个父类定义了若干操作，如一个公司要有项目、利润、任命经理、录用职工等操作，子公司也将继承这些行为s;mp

classcommonemployeeextends
 employee／／子类1：

{
 intm_managerno ;／／定义类属性m _managerno，代表雇员上司的编号
}
classmanageremployeeextends employee ／／子类2：
{
 intm_secretaryno； ／／定义类属性m_secretaryno，代表秘书的编号
}

属性继承与隐藏
尽管employee类是一个父类，但是并不因为它是父类就意味着它有更多的功能。恰恰相反，子类比它们的父类具有更多的功能。因为子类是父类的扩展，增加了父类没有的属性和方法
（1）子类不能访问父类的private成员，但子类可以访问其父类的public，

（2）protected访问是public和private访问之间一个保护性的中间层次。

（3）由于被继承的父类成员没有在子类声明中列出，但是这些成员确实存在于子类中。
在这里，要区分一下继承、覆盖与重载这几个易混淆的概念：

只有方法这一概念层面，这三个概念才易混淆：

方法继承

对于子类对象，可以使用父类中的方法。即使这些方法没有明显地在子类中定义，它们也自动地从父类中继承过来了

方法覆盖

方法的覆盖是指：子类定义同名方法来覆盖父类的方法，是多态技术的一个实现。当父类方法在子类中被覆盖时，通常是子类版本调用父类版本，并做一些附加的工作。

有很多注意事项，这里，我主要提一下this与super，c++中有this（且与java中中概念差不多）,但是没有super。

this表示的是当前对象本身，this代表当前对象的一个引用。可以理解为对象的另一个名字。利用this可以调用当前对象的方法和属性。

如：this.getname（）和getname（）在类中是一样的。

super表示的是当前对象的直接父类对象，是当前对象的父类对象的引用
方法重载

重载的定义：可以用相同的方法名但不同的参数表来定义方法（参数表中参数的数量、类型或次序有差异），这称为方法重载。
•重载（overloading）：当多个方法具有相同的名字而含有不同的参数时，便发生重载。编译器必须挑选处调用哪个方法。它通过将在不同方法头部中的参数类型和在特定的方法调用中使用值的类型进行比较，从而挑选出正确的方法。

多态性允许以统一的风格处理已存在的变量及相关的类，使增加系统中新功能变得容易。这里，贴一下网上找的资料，能更清楚地将继承中需特别注意的多态、继承中的问题弄清:

 java的多态性
面向对象编程有三个特征，即封装、继承和多态。

    封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。

     继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？

     方法的重写、重载与动态连接构成多态性。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”。

     对于多态，可以总结它为：

（1）使用父类类型的引用指向子类的对象（实际对象）；

（2）该引用只能调用父类中定义的方法和变量；

（3）如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
（4）变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

多态是通过:
 （1） 接口 和 实现接口并覆盖接口中同一方法的几个不同的类体现的
 （2） 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.

1.基本概念

 多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
 通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

 ava 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

 （1）如果a是类a的一个引用，那么，a可以指向类a的一个实例,或者说指向类a的一个子类。
 （2）如果a是接口a的一个引用，那么,a必须指向实现了接口a的一个类的实例。

java多态性实现机制

 sun目前的jvm实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：
一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；
另一个指针指向一块从java堆中为分配出来内存空间。

总结

 （1）通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

derivedc c2=new derivedc(); 
baseclass a1= c2; //baseclass 基类，derivedc是继承自baseclass的子类 
a1.play(); //play()在baseclass，derivedc中均有定义，即子类覆写了该方法 

分析：
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型baseclass；
* a.play()将执行子类还是父类定义的方法？
子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。

 在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。

 （2）不能把父类对象引用赋给子类对象引用变量

baseclass a2=new baseclass(); 
derivedc c1=a2;//出错 

 在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(derivedc)a2; 进行强制转化,也就是向下转型.

 （3）记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
 例如，derivedc类在继承baseclass中定义的函数外，还增加了几个函数（例如 myfun()）

 分析：
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。

 （4）java与c++多态性的比较

 jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。

 java把类型信息和函数信息分开放。java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。

            java的所有函数，除了被声明为final的，都是用后期绑定。

1个行为,不同的对象,他们具体体现出来的方式不一样,
         比如:     方法重载 overloading 以及 方法重写(覆盖)override 

     class human{ 
     void run(){输出 人在跑} 
      } 
    class man extends human{ 
   void run(){输出 男人在跑} 
     } 
     这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子) 
    class test{ 
   void out(string str){输出 str} 
    void out(int i){输出 i} 
    } 

                这个例子是方法重载,方法名相同,参数表不同

               ok,明白了这些还不够,还用人在跑举例
              human ahuman=new man();
              这样我等于实例化了一个man的对象,并声明了一个human的引用,让它去指向man这个对象
               意思是说,把 man这个对象当 human看了.

               比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
               这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
               这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理.

              这种方式下要注意 new man();的确实例化了man对象,所以 ahuman.run()这个方法 输出的   是 "男人在跑 "

               如果在子类 man下你 写了一些它独有的方法 比如 eat(),而human没有这个方法,

 在调用eat方法时,一定要注意 强制类型转换 ((man)ahuman).eat(),这样才可以...

 对接口来说,情况是类似的...

 实例:

package domatic; 

//定义超类supera 
class supera { 
int i = 100; 

void fun(int j) { 
j = i; 
system.out.println("this is supera"); 
} 
} 

// 定义supera的子类subb 
class subb extends supera { 
int m = 1; 

void fun(int aa) { 
system.out.println("this is subb"); 
} 
} 

// 定义supera的子类subc 
class subc extends supera { 
int n = 1; 

void fun(int cc) { 
system.out.println("this is subc"); 
} 
} 

class test { 
public static void main(string[] args) { 
supera a = new supera(); 
subb b = new subb(); 
subc c = new subc(); 
a = b; 
a.fun(100); 
a = c; 
a.fun(200); 
} 
} 

/*
* 上述代码中subb和subc是超类supera的子类,我们在类test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
* "为什么(1)和(2)不输出：this is supera"。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subb的一个实例,因而(1)所调用的fun()实际上是子类subb的成员方法fun(),
* 它覆盖了超类supera的成员方法fun()；同样(2)调用的是子类subc的成员方法fun()。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/
 以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法

java里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：

//父类 
public class father{ 
 //父类有一个打孩子方法 
 public void hitchild(){ 
 } 
} 
//子类1 
public class son1 extends father{ 
 //重写父类打孩子方法 
 public void hitchild(){ 
  system.out.println("为什么打我？我做错什么了！"); 
 } 
} 
//子类2 
public class son2 extends father{ 
 //重写父类打孩子方法 
 public void hitchild(){ 
  system.out.println("我知道错了，别打了！"); 
 } 
} 
//子类3 
public class son3 extends father{ 
 //重写父类打孩子方法 
 public void hitchild(){ 
  system.out.println("我跑，你打不着！"); 
 } 
} 

//测试类 
public class test{ 
 public static void main(string args[]){ 
  father father; 

  father = new son1(); 
  father.hitchild(); 

  father = new son2(); 
  father.hitchild(); 

  father = new son3(); 
  father.hitchild(); 
 } 
} 

都调用了相同的方法，出现了不同的结果！这就是多态的表现！

import java.io.*;
class super{
  super(){
    system.out.println("this is super class!");
  }
  void method(){
    system.out.println("super's method");
  }
}
class sub extends super{
  sub(){
    super();
    system.out.println("\n\t:and here is the child");
  }
  void method(){
    system.out.println("child's method");
  }
}


public class super_sub{
  public static void main(string[] args){
    super sup=new sub();
    sup.method();


    sub child=(sub)new super();//这里，实际分配的内存是super的，但是却用child来指代它，这就是“向下转型”(父类冒充子类，因为子类在uml中画时是在下的嘛),必经强制类型转换
    child.method();
  }
}

对于数据来说，继承是否为正确的设计可以用一个简单的规则来判断。“is-a”规则表明子类的每一个对象都是一个超类的对象。例如，每一个经理是一个员工。然而，只有经理类是员工类的子类才是有意义的。很明显，反过来就不行了——并不是每个员工都是经理。

    还有一个明确叙述“is-a”规则的方法是替代原则。该原则规定无论何时，如果程序需要一个超类对象，都可以用一个子类对象来代替

动态绑定
理解调用一个对象方法的机制是非常重要的。下面具体介绍：x.f；

（1）编译器检查对象的声明类型和方法名。

（2）接着，编译器检查方法调用中的参数类型。如果在所有的叫做f的方法中有一个其参数类型同调用提供的参数类型最匹配，那么该方法就会被选择调用。这个过程称作超载选择。（静态）

（3）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。

……

如果类中没有写构造函数，那么系统会自动为该类提供一个默认构造函数，该构造函数将所有的实例字段初始化为默认值：

……

包用途:

java允许把多个类收集在一起成为一组，称作包（package）。包便于组织任务，以及使自己的任务和其他人提供的代码库相分离。
   标准java库被分类成许多的包，其中包括java.1ang、java.util和java.net等等。标准java包是分层次的。就像在硬盘上嵌套有各级子目录一样，可以通过层次嵌套组织包。所有的java包都在java和javax包层次内

 创建包

已经看到，已有的库，比如javaapi中的类和接口，可以导入到java程序中。

java api中的每一个类和接口属于一个特定的包。它包含一组相关联的类和接口，实际是对类和接口进行组织的目录结构。

例如，假定文件名是myclass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是myclass（包括大小写形式）：

packagemypackage;

publicclass myclass

{

……

}

创建可复用的类的步骤简要说明如下：
（1）定义一个public类。如果类不是public，它只能被同一包中的其他类使用。
（2）选择一个包名，并把package语句加到可复用的类的源代码文件中。
（3）编译这个类。这样，它就被放到适当的包目录结构中，以供编译器和解译器使用。
（4）把这个可复用的类导入到需要用它的程序中。现在就可以使用它了。
注意 在java语言中可以出现在类定义的括号外面的仅有两个语句，它们是package和import。

包引用---每个类名前加上完整的包名
例如，给出一个指向此包中的类的快捷方式。一旦使用import（导入）了以后，就不再需要给出完整的包名。

可以引入一个特定的类，也可以引入整个包。import语句要放在源文件的头部（但在所有package语句的下面）。例如，可以通过下面的语句引入在java.util包中的所有的类：

importjava.util.*;

然后，就可以使用

datetoday=new date();

而不需要在前面加上包名。也可以引入包中某个特定的类：

importjava.util.date;

要把类放人一个包中，必须把此包的名字放在源文件头部，并且放在对包中的类进行定义的代码之前。例如，在文件employee.java的开始部分如下：

packagecom.horstmann.corejava;

publicclass employee

{

……

}

把包中的文件放入与此完整的包名相匹配的子目录中。例如，在包com.horstmann.corejava中的所有的类文件都必须放在子目录com/horstmann/core.java（windows下的com\horstmann\corejava）下。这是最简单的一种方法

类被存储在文件系统的子目录中。类的路径必须与所在包名相匹配。

在前面的例子中，包目录com/horstmann/corejava是程序目录的一个子目录。然而这样安排很不灵活。一般，有多个程序需要访问包文件。为了使包可以在多个程序间共享，需要做以下事情：

1）把类放在一个或多个特定的目录中，比如/home/user/classdir。此目录是包树的基本目录。如果加入了类com.horstmann.corejava.employee，那么此类文件必须位于子目录/home/user/classdir/com/horstmann/corejava下。

2）设置类路径。类路径是其子目录包含类文件的所有基本目录的集合。classpath

已经接触过public和private访问指示符。

被标记为public的部件可以被任何类使用，而私有部件只能被定义它们的类使用。如果没有指定public或private，那么部件（即类、方法或变量）可以被同一个包中的所有方法访问。

java api包
为了简化面向对象的编程过程，java系统事先设计并实现了一些体现了常用功能的标准类，如用于输入／输出的类，用于数学运算的类，用于图形用户界面设计的类，用于网络处理的类等。这些系统标准类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。

  java的类库是系统提供的已实现的标准类的集合，是java编程的api，它可以帮助开发者方便、快捷地开发java程序

接口主要作用是可以帮助实现类似于类的多重继承的功能。在java中，出于简化程序结构的考虑，不再支持类间的多重继承而只支持单重继承，即一个类至多只能有一个直接父类。然而在解决实际问题的过程中，仅仅依靠单重继承在很多情况下都不能将问题的复杂性表述完整，需要其他的机制作为辅助。

接口声明
java中声明接口的语法如下：

[public] interface 接口名 [extends 父接口名列表]

{ //接口体;

//常量域声明

 [public] [static] [final] 域类型 域名=常量值;

 //抽象方法声明

 [public] [abstract] 返回值 方法名(参数列表) [throw异常列表];

}

从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类

（1）接口中的属性都是用final修饰的常量，
（2）接口中的方法都是用abstract修饰的抽象方法，在接口中只能给出这些抽象方法的方法名、返回值和参数列表，而不能定义方法体，即仅仅规定了一组信息交换、传输和处理的“接口”

 接口的实现

一个类要实现某个或某几个接口时，有如下的步骤和注意事项：

（1）在类的声明部分，用implements关键字声明该类将要实现哪些接口；

  如下：

 class类名implements接口{

 

}

（2）如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参数列表；

（3）如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。

（4）一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。

（5）接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法时，必须显式地使用public修饰符。

小结：

多重继承是指一个子类继承多个父类。java不支持多重继承，但java提供了接口。

子类不能访问父类的private成员，但子类可以访问其父类的public，protected和包访问成员；要访问父类的包访问成员，子类一定要在父类的包内。

子类构造函数总是先调用（显式的或隐式地）其父类的构造函数，以创建和初始化子类的父类成员。

子类的对象可以当作其父类的对象对待，反之则不行（即向上转型）

protected访问是public和private访问之间一个保护性的中间层次。父类方法、子类方法和在同一个包内类的方法都能访问父类的protected成员，但其他方法均不能访问

一个子类对象引用可以隐式地转换成一个父类对象引用。使用显式的类型转换，可以把父类引用转换成子类引用。如果目标不是子类对象，将产生classcastexception例外处理。