java/C#多态漫谈
最近面试深受打击，我感到自己的内功不足。于是翻看了一下《java编程思想》，对多态有了更深的认识。
以前只知道多态有什么用，怎么用，但是不知道多态的原理是什么，现在大概是知道了，我也不想私藏，现与大家分享，老鸟就不用看了。
多态实现的原理就是“ 方法调用后期绑定 ”。
什么叫后期绑定？
讲一个方法调用同一个方法主体关联起来被称作绑定。若在程序执行前进行绑定（例如编译的时候）的话，叫做前期绑定（c语言都是前期绑定）。相应的，在运行时候根据对象的类型进行绑定叫后期绑定，也叫动态绑定。也就是说，如果一个语言想实现后期绑定，就必须具有某种机制，以便能够在运行时能判断对象的类型，从而调用恰当的方法。 也就是说，编译器一直不知道对象的类型，但是运行时方法调用机制能够找到正确的方法体，并加以调用。不管怎样，都必须在对象中安置某种类型信息。
在java中，除了static方法和final方法(private方法属于final方法)之外，其他的都默认进行后期绑定（就是可以多态）。 如果将一个方法声明为final或者static或者private，就告诉编译器不需要对该方法动态绑定。这样，编译器就可以可以为final方法调用生成更有效的代码（）。
总结一下：
1. java普通方法默认都是动态绑定的。
2. 父类static 和final方法（private除外），子类不可以重写，编译器会报错。其中构造器默认是static的。
3. 父类private(也默认final的)方法，子类可以声明同名方法（这个方法和父类同名方法只是名字相同，没有什么关系），但是不会多态，也不可能多态，因为父类方法为private的。
4. 子类需要多态的方法的可视范围（protected , public等）不能比父类的那个方法小（可以大），否则的话，父类可能没法找到子类的那个方法，会编译时报错。
5. java的各种属性不能多态。多态仅适用于方法。
下面看一个例子
1 class Base{
2
3 public int a=2 ;
4 public void fmethod(){
5 System.out.println("base:fmethod" );
6 }
7 int getA(){
8 return a;
9 }
10 }
11
12 class Sub extends Base{
13 public int a=3 ;
14 public void fmethod(){ // final表示不尽兴多态
15 System.out.println("sub:fmethod" );
16 }
17 // 子类方法可视范围可以扩大
18 public int getA(){
19 return a;
20 }
21 }
22 public class Test {
23
24 public static void main (String args []) {
25 Base b= new Sub();
26 // 方法多态，输出sub:fmethod
27 b.fmethod();
28 // 属性不能多态，输出为2.
29 System.out.println(b.a);
30 // 但是可以通过方法来实现属性的多态，输出3
31 System.out.println(b.getA());
32 }
33
34 }
C#和java的多态机制大部分是一样的，只是有一点，有着翻天覆地的不同。
不同： java普通方法默认是后期绑定的，而C#方法默认是前期绑定的 ，所以C#里面如果需要后期绑定（即多态），那么必须使用virtual + override+overide关键词对。另一方面，好像重写（这篇文章 所谓重写 ，表示需要多态的用override修饰的）的方法访问限制必须一致，不一致就报错，不清楚这个说法对不对。
闲话少数，上代码
1 class Base{
2
3 public int a= 2 ;
4 public void fmethod(){
5 Console.WriteLine( " base:fmethod " );
6 }
7 // virtual关键词，可以提示编译器这个方法可以被后面的子类重写（子类方法需有override），
8 public virtual void gmethod()
9 {
10 Console.WriteLine( " base:gmethod " );
11 }
12
13 public virtual void hmethod()
14 {
15 Console.WriteLine( " base:hmethod " );
16 }
17 protected virtual int getA()
18 {
19 return a;
20 }
21 }
22
23 class Sub: Base
24 {
25 public int a= 3 ;
26 // 普通方法默认修饰符为new, public void fmethod = public new void fmethod
27 public void fmethod(){
28 Console.WriteLine( " sub:fmethod " );
29 }
30 // 有override，与父类virtual 配对，多态
31 public override void gmethod()
32 {
33 Console.WriteLine( " sub:gmethod " );
34 }
35 // 即使父类方法有virual，子类方法没有override，不会多态，
36 public void hmethod()
37 {
38 Console.WriteLine( " sub:hmethod " );
39 }
40
41
42 // 子类重写的方法访问限制必须一致,对不对？
43 protected override int getA(){
44 return a;
45 }
46 }
47
48 class Subsub : Sub
49 {
50 // 有override，与父类virtual 配对，多态
51 public override void gmethod()
52 {
53 Console.WriteLine( " subsub:gmethod " );
54 }
55 public static void Main(String[] args)
56 {
57 Base b = new Sub();
58 // 输出base:fmethod
59 b.fmethod();
60 // 输出sub:gmethod
61 b.gmethod();
62 // 输出base:hmethod
63 b.hmethod();
64 // 属性不能多态，输出为2.
65 Console.WriteLine(b.a);
66 Sub s = new Subsub();
67 // 输出subsub:gmethod
68 s.gmethod();
69 }
70
71 }
转载请注明出处：博客园 stonehat http://www.cnblogs.com/stonehat/archive/2012/04/30/2476798.html
标签: 多态 , 原理 , java , C#
Java集合框架总结（5）——Map接口的使用
Map用于保存具有映射关系的数据（key-vlaue）。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false
Map中包含了一个keySet()方法，用于返回Map所以key组成的Set集合。
Map集合与Set集合元素的存储形式很像，如Set接口下有HashSet、LinkedHashSet、SortedSet（接口）、TreeSet、EnumSet等实现类和子接口，而Map接口下则有HashMap、LinkedHashMap、SortedMap（接口）、TreeMap、EnumMap等实现类和子接口。
如果把Map的value非常类似List： 元素与元素之间可以重复，每个元素可以根据索引（key）来查找。
Map有时也称为字典，或关联数组。
Map接口中定义如下方法：
void clear(); 删除Map对象中所有key-value对。 boolean containsKey(Object key) :查询Map中是否包含指定key，如果包含则返回true。 boolean containsValue(Object value) :查询Map中是否包含一个或多个value，如果包含则返回true。 Set entrySet():返回Map中所有包含的key-value对组成的Set集合，每个集合元素都是Map.Entry(Entry是Map的内部类）对象。 Object get(Obejct key):返回指定key所对应的value；如果此Map中不包含key，则返回null。 boolean isEmpty():查询该Map是否为空（即不包含任何key-value对），如果为空则返回true。 Set keySet():返回该Map中所有key所组成的set集合。 Object put(Object key, Object value):添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。 Object remove(Object key):删除指定key对应的key-value对，返回被删除key所关联的value，如果该key不存在，返回null。 int size():返回该Map里的key-value对的个数。 Collection values():返回该Map里所有value组成的Collection。Map接口提供了大量的实现类，如HashMap和Hashtable等，以及HashMap的子类LinkedHashMap,还有SortedMap子接口及该接口的实现类TreeMap。下面将进行详细介绍。
Map中包括一个内部类：Entry。该类封装了一个key-value对，Entry包含三个方法：
Object getkey():返回该Entry里包含的key值。 Object getValue():返回该Entry里包含的value值。 Object setValue():设置该Entry里包含的value值，并返回新设置的value值。可以把Map理解成一个特殊的Set，只是该Set里包含的集合元素是Entry对象，而不是普通对象。
1、HashMap和Hashtable实现类
HashMap和Hashtable都是Map接口的实现类，Hashtable是一个古老的Map实现类，它从JDK1.0起就有，它包含两个烦琐的方法：elements()(类似于Map接口定义的values()方法）和keys()（类似于Map接口定义的keySet()方法)，现在很少使用这两种方法。
两点区别：
Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高些；但如果多线程访问同一个Map对象，使用Hashtable实现类更好。 Hashtable不允许使用null作为key和value，如果为null，则引发NullPointerException异常；但HashMap可以使用null作为key或value。由于HashMap里的可以不能重复，所以HashMap里最多只有一对key-value值为null，但可以有无数多项key-value对的value为null。
HashMap重写了toString()方法方法总是返回如下格式的字符串：{key1 = value1，key2 = value2..}
HashMap、Hashtable判断两个key相等的标准是：两个key通过equasl方法比较返回ture,两个key的hashCode值相等。
LinkedHashMap类HashMap有一个子类：LinkedHashMap, 它也是双向链表来维护key-value对的次序， 该链表定义了迭代顺序，该迭代顺序与key-value对的插入顺序保持一致。
LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可）。同时又可避免使用TreeMap所增加的成本。
LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能，但在迭代访问Map里的全部元素时将有很好的性能，因为它以链表来维护内部顺序。
Properties类Properties类是Hashtable类的子类，用于处理属性文件（例如Windows操作平台上的ini文件）。 Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件，也可以把属性文件中的属性名=属性值加载到Map对象中。由于属性文件里的属性名、属性值只能是字符串类型，所以Properties里的key、value都是字符串类型， 该类提供了如下三个方法来修改Properties里的key、value值。
String getProperty(String key):获取Properties中指定属性名对应的属性值，类似于Map的get(Object key)方法。 String getProperty(String key, String defaultValue):该方法与前一个方法基本类似。该方法多一个功能，如果Properties中不存在指定key时，该方法返回默认值。 Object geProperty(String key、String value):设置属性值，类似Hashtable的put方法。提供两个读、写属性文件的方法：
void load(InputStream inStream):从属性文件（以输入流表示）中加载属性名=属性值，把加载到的属性名=属性值对追加到Properties里（由于Properties是Hashtable)的子类，它不保证key-value对之间的次序）。 void Store(OutputStream out, String comment):将Properties中的key-valu对写入指定属性文件（以输出流表示）。示例程序：
public class TestProperties
{
public static void main(String[] args) throws Exception
{
Properties props = new Properties();
// 向Properties中增加属性
props.setProperty("username" , "yeeku" );
props.setProperty( "password" , "123456" );
// 将Properties中的属性保存到a.ini文件中
props.store( new FileOutputStream("a.ini") , "comment line" );
// 新建一个Properties对象
Properties props2 = new Properties();
// 向Properties中增加属性
props2.setProperty("gender" , "male" );
// 将a.ini文件中的属性名-属性值追加到props2中
props2.load( new FileInputStream("a.ini" ) );
System.out.println(props2);
}
}
运行结果：
{password=123456, gender=male, username=yeeku}
2、SortedMap接口和TreeMap实现类
Map接口派生了一个SortedMap子接口，TreeMap为其实现类。 类似TreeSet排序，TreeMap也是基于红黑树对TreeMap中所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap两种排序方法：
自然排序：TreeMap的所有key必须实现Comparable接口，而且所有key应该是同一个类的对象，否则将会抛出ClassCastExcepiton异常。 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeＭap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。TreeMap中判断两个key相等的标准也是 两个key通过equals比较返回true， 而通过compareTo方法返回0，TreeMap即认为这两个key是相等的。
如果使用自定义的类作为TreeMap的key，应重新该类的equals方法和compareTo方法时应有一致的返回结果：即两个key通过equals方法比较返回true时，它们通过compareTo方法比较应该返回0。如果equals方法与compareTo方法的返回结果不一致，要么该TreeMap与Map接口的规则有出入（当equals比较返回true,但CompareTo比较不返回0时），要么TreeMap处理起来性能有所下降（当compareTo比较返回0，当equals比较不返回true时）。
TreeMap中提供了系列根据key顺序来访问Map中key-value对方法：
Map.Entry firstEntry():返回该Map中最小key所对应的key-value对，如果该Map为空，则返回null。 Object firstKey():返回该Map中的 最小key值 ，如果该Map为空，则返回null。 Map.Entry lastEntry():返回该Map中 最大key所对应的key-value对 ，如果该Map为空，或不存在这样的key-value都返回null。 Object lastKey():返回该 Map中的最大key值 ，如果该Map为空，或不存在这样的key都返回null。 Map.Entry higherEntry(Object key):返回该 Map中位于key后一位的key-value对（即大于指定key的最小key所对应的key-value对）。 如果该Map为空，则返回null。 Object higherKey():返回该 Map中位于key后一位的key值（即大于指定key的最小key值）。 如果该Map为空，或不存在这样的key都返回null。 Map.Entry lowerEntry(Object key):返回该 Map中位于key前一位的key-value对（即小于指定key的最大key所对应的key-value对）。 如果该Map为空，或不存在这样的key-value则返回null。 Object lowerKey():返回该 Map中位于key前一位的key值（即小于指定key的最大key值）。 如果该Map为空，或不存在这样的key都返回null。 NavigableMap subMap(Object fromKey, boolean fromInclusive, Object tokey, boolean tolnclusive):返回该 Map的子Map，其key的范围从fromKey(是否包括取决于第二个参数）到tokey（是否包括取决于第四个参数）。 SorterMap subMap（Object fromKey， Object toKey)：返回该 Map的子Map，其key的范围从fromKey（包括）到toKey（不包括）。 SortedMap tailMap（Object fromKey，boolean inclusive）:返回该 Map的子Map，其key的范围是大于fromkey（是否包括取决于第二个参数）的所有key。 NavigableMap headMap(Object toKey, boolean lnclusive):返回该 Map的子Map，其key的范围是小于fromKey（是否包括取决于第二个参数）的所有key。程序示例：
// R类，重写了equals方法，如果count属性相等返回true
// 重写了compareTo(Object obj)方法，如果count属性相等返回0;
class R implements Comparable
{
int count;
public R( int count)
{
this .count = count;
}
public String toString()
{
return "R(count属性:" + count + ")" ;
}
public boolean equals(Object obj)
{
if ( this == obj)
{
return true ;
}
if (obj != null
&& obj.getClass() == R. class )
{
R r = (R)obj;
if (r.count == this .count)
{
return true ;
}
}
return false ;
}
public int compareTo(Object obj)
{
R r = (R)obj;
if ( this .count > r.count)
{
return 1 ;
}
else if ( this .count == r.count)
{
return 0 ;
}
else
{
return -1 ;
}
}
}
public class TestTreeMap
{
public static void main(String[] args)
{
TreeMap tm = new TreeMap();
tm.put( new R(3) , "轻量级J2EE企业应用实战" );
tm.put( new R(-5) , "Struts2权威指南" );
tm.put( new R(9) , "ROR敏捷开发最佳实践" );
System.out.println(tm);
// 返回该TreeMap的第一个Entry对象
System.out.println(tm.firstEntry());
// 返回该TreeMap的最后一个key值
System.out.println(tm.lastKey());
// 返回该TreeMap的比new R(2)大的最小key值。
System.out.println(tm.higherKey( new R(2 )));
// 返回该TreeMap的比new R(2)小的最大的key－value对。
System.out.println(tm.lowerEntry( new R(2 )));
// 返回该TreeMap的子TreeMap
System.out.println(tm.subMap( new R(-1) , new R(4 )));
}
}
运行结果：
{R(count属性:-5)=Struts2权威指南, R(count属性:3)=轻量级J2EE企业应用实战, R(count属性:9)=ROR敏捷开发最佳实践}
R(count属性:-5)=Struts2权威指南
R(count属性:9)
R(count属性:3)
R(count属性:-5)=Struts2权威指南
{R(count属性:3)=轻量级J2EE企业应用实战}
分类: Java
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息