java学习笔记

Java多态

综合评价：★★

方法继承

利用extends关键字一个方法继承另一个方法，而且只能直接继承一个类。

当Sub类和Base类在同一个包时Sub类继承Base类中的public/protected/默认级别的变量个方法，在不同包时继承public/protected级别的变量和方法。

 

构造函数：用父类的构造函数。如果存在无参构造函数（或者不存在任何构造函数），子类中不显式调用父类的构造函数，则默认调用父类的无参数构造函数（使用super()修改调用父类

  当子类继承一个父类时，构造子类时需要调用父类的构造函数，在父类不存在无参构造函数的情况下，子类的构造函数中必须显式调的构造函数）。

方法重载

如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。 @Overload

1)       方法名相同

2)       方法的参数类型，个数顺序至少有一项不同

3)       方法的返回类型可以不相同

4)       方法的修饰符可以不相同

5)       main方法也可以被重载

方法重写

如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

1)       子类的方法名称返回类型及参数签名 必须与父类的一致

2)       子类方法不能缩小父类方法的访问权限，只能把方法的作用域放大（不能把public修改为private）。但是父类的私有方法不能被子类覆盖

3)       子类方法不能抛出比父类方法更多的异常

4)       方法覆盖只存在于子类和父类之间，同一个类中只能重载

5)       父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法

6)       子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法（满足覆盖约束），而且Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。

7)       父类的抽象方法可以被子类通过两种途径覆盖（即实现和覆盖），父类的非抽象方法可以被覆盖为抽象方法 @Override

成员覆盖

当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量

Super关键字：

super和this关键字都可以用来覆盖Java语言的默认作用域，使被屏蔽的方法或变量变为可见。

1)       父类的成员变量和方法为private使用super访问编译出错

2)       在子类的构造方法种，通过super语句调用这个类的父类的构造方法

3)       在子类种访问父类被屏蔽的方法和属性

4)       只能在构造方法或实例方法内使用super关键字，而在静态方法和静态代码块内不能使用super

继承的利弊和使用原则：

优点：

（1）定义了下层子类都用有的相同属性和方法，尽可能默认实现，从而提高重用性

（2）代表系统的接口，描述系统所能提供的服务

缺点：

继承关系最大的弱点：打破封装（封装 (encapsulation)

1．事物的内部实现细节隐藏起来

2．对外提供一致的公共的接口――间接访问隐藏数据

3．可维护性

被继承类的使用原则：

（1）对这些类必须提供良好的文档说明

（2）尽可能的封装父类的实现细节，把代表时间细节的属性和方法定义为private

（3）如果某些实现细节必须被子类访问，定义为protected类型

（4）把不允许子类覆盖的方法定义为final类型

（5）父类的构造方法不允许调用可被子类覆盖的方法

（6）如果某些类不是专门为了继承而设计，那么随意继承它是不安全的

 

请看列子：综合评价：★★★

class A {     public String show(D obj){            return ("A and D");     }     public String show(A obj){            return ("A and A");     } } class B extends A{     public String show(B obj){            return ("B and B");     }     public String show(A obj){            return ("B and A");     } } class C extends B{          public String show(B obj){                  return ("C and B");           }           public String show(A obj){                  return ("C and A");           } } class D extends B{          public String show(B obj){                  return ("D and B");           }           public String show(A obj){                  return ("D and A");           } }   public class Test {          public static void main(String[] args) {                    //test polymorphic                    A a1 = new A();                    A a2 = new B();         B b = new B();         C c = new C();         D d = new D();                  System.out.println(a1.show(b));            System.out.println(a1.show(c));            System.out.println(a1.show(d));                  //********************''         System.out.println(a2.show(b));            System.out.println(a2.show(c));            System.out.println(a2.show(d));            System.out.println(b.show(b));              System.out.println(b.show(c));              System.out.println(b.show(d));                             // test extends /*              SubClass sc1 = new SubClass();                    SubClass sc2 = new SubClass(400);*/           } }

问题：写出9个输出语句的结果，并且解释原因。

答案： 1)A and A\  2) A and A\  3) A and D\  4)B and A\  5)B and A\ 6) A and D\ 

7)B and B\  8)B and B\ 9)A and D

分析： 运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。

      实际上这里涉及方法调用的优先问题 ，优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。其中super查找会首先查找直接父级，如果直接父级存在则调用父级对象，否则再进行父父级查找。直到找到顶级父级对象。        

比如④，a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(Bobj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(Aobj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(Aobj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

          再比如⑧，b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

 

Java集合

综合评价：★★★

Java容器类类库的用途是“保存对象”，并将其划分为两个不同的概念：

1）Collection 一组对立的元素，通常这些元素都服从某种规则。如，List必须保持元素特定的顺序，而Set 不能有重复元素。

2）Map 一组 成对的“键值对”对象。

 

Collection和Map的区别在于容器中每个位置保存的元素个数。Collection 每个位置只能保存一个元素（对象）

1)       Collection –对象之间没有指定的顺序，允许重复元素。

2)       Set –  对象之间没有指定的顺序，不允许重复元素

3)       List–  对象之间有指定的顺序，允许重复元素,并引入位置下标。

4)       Map –  接口用于保存关键字（Key）和数值（Value）的集合，集合中的每个对象加入时都提供数值和关键字。Map 接口既不继承 Set 也不继承 Collection。

5)       List、Set、Map共同的实现基础是Object数组

 

集合框架分解图：

Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素。（Elements）。所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后 一个构造函数允许用户复制一个Collection。注意:集合必须只有对象，集合中的元素不能是基本数据类型。

Collection的实现基础是数组，所以有转换为Object数组的方法：

Object[] toArray() ; Object[]toArray(Object[] a)

 

迭代器

Collection不提供get()方法。如果要遍历Collectin中的元素，就必须用Iterator。迭代器（Iterator）本身就是一个对象，它的工作就是遍历并选择集合序列中的对象，而客户端的程序员不必知道或关心该序列底层的结构。Iterator选取容器中的元素，它将容器转换成一个序列。Collection 接口的 iterator() 方法返回一个 Iterator对象。

 

Collection的Iterator 用法：

1)使用方法　iterator() 要求容器返回一个Iterator.第一次调用Iterator 的next() 方法时，它返回集合序列的第一个元素。

2)使用next() 获得集合序列的中的下一个元素。

3)使用hasNext()检查序列中是否元素。

4)使用remove()将迭代器新返回的元素删除。

需要注意的是：方法删除由next方法返回的最后一个元素，在每次调用next时，remove方法只能被调用一次。

List

List的最大的特点就是能够自动的根据插入的数据量来动态改变容器的大小。集合框架”中有两种常规的 List 实现：ArrayList 和 LinkedList。与 Set 不同的是 List 允许重复。

	简述	实现	操作特性	成员要求
List	提供基于索引的对成员的随机访问	ArrayList	1、提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好 2、允许null元素。	成员可为任意Object子类的对象
		LinkedList	1、对列表中任何位置的成员的增加和删除支持较好，但对基于索引的成员访问支持性能较差 。 2、允许null元素。 3、可被用作堆栈（stack），队列（queue）或双向队列（deque）。	成员可为任意Object子类的对象

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

List 接口不但以位置友好的方式遍历整个列表，还能处理集合的子集：

1)       ListIterator listIterator() ：返回一个ListIterator 迭代器，默认开始位置为0

2)       ListIterator listIterator(intstartIndex) ：返回一个ListIterator 迭代器，开始位置为startIndex

3)       List subList(int fromIndex, inttoIndex) ：返回一个子列表List ,元素存放为从fromIndex 到toIndex之前的一个元素。

 

ListIterator接口

ListIterator 接口继承 Iterator 接口以支持添加或更改底层集合中的元素，还支持双向访问，逆向访问注意 ListIterator最初位于列表尾之后（list.size()）。

 

Vector类

　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

 

Stack类

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

 

Vector和ArrayList区别

1)       vector是线程同步的，也是线程安全的，而arraylist是线程异步的，是不安全的。

2)       如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。

3)       如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是0(1),这个时候使用vector和arraylist都可以。如果移动一个指定位置的数据可以考虑使用LinkedList

 

arraylist和linkedlist的区别

1)       ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2)       对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3)       对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

Set

Set 接口继承 Collection 接口，而且它不允许集合中存在重复项。Set的常用实现类的描述：

	简述	实现	操作特性	成员要求
Set	成员不能重复	HashSet	外部无序地遍历成员。	成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
		TreeSet	外部有序地遍历成员； 附加实现了SortedSet, 支持子集等要求顺序的操作	成员要求实现Comparable接口，或者使用Comparator构造TreeSet。成员一般为同一类型。
		LinkedHashSet	外部按成员的插入顺序遍历成员	成员与HashSet成员类似

 

Set的实现原理

HashSet的实现，建立一个“键值对”，“键”就是我们要存入的对象，“值”则是一个常量。

 

用“集合框架”设计软件时，记住该框架四个基本接口的下列层次结构关系会有用处：

1)     Collection 接口是一组允许重复的对象。

2)     Set 接口继承 Collection，但不允许重复。

3)     List 接口继承 Collection，允许重复，并引入位置下标。

4)     Map 接口既不继承 Set 也不继承 Collection,存取的是键值对

集合的实现类之间的区别：

Collection/Map	接口	成员重复性	元素存放顺序（Ordered/Sorted）	元素中被调用的方法	基于那中数据结构来实现的
HashSet	Set	Unique elements	No order	equals() hashCode()	Hash 表
LinkedHashSet	Set	Unique elements	Insertion order	equals() hashCode()	Hash 表和双向链表
TreeSet	SortedSet	Unique elements	Sorted	equals() compareTo()	平衡树（Balanced tree）
ArrayList	List	Allowed	Insertion order	equals()	数组
LinkedList	List	Allowed	Insertion order	equals()	链表
Vector	List	Allowed	Insertion order	equals()	数组
HashMap	Map	Unique keys	No order	equals() hashCode()	Hash 表
LinkedHashMap	Map	Unique keys	Key insertion order/Access order of entries	equals() hashCode()	Hash 表和双向链表
Hashtable	Map	Unique keys	No order	equals() hashCode()	Hash 表
TreeMap	SortedMap	Unique keys	Sorted in key order	equals() compareTo()	平衡树（Balanced tree）

 

Map

Map Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

public Set keySet() ：返回所有的键（key），并使用Set容器存放

1)       public Collection values() ：返回所有的值（Value），并使用Collection存放

2)       public Set entrySet() ：返回一个实现Map.Entry 接口的元素 Set

 

Map的常用实现类的比较：

	简述	实现	操作特性	成员要求
Map	保存键值对成员，基于键找值操作，使用compareTo或compare方法对键进行排序	HashMap	能满足用户对Map的通用需求	键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。
		TreeMap	支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap； 附加实现了SortedMap接口，支持子Map等要求顺序的操作	键成员要求实现Comparable接口，或者使用Comparator构造TreeMap键成员一般为同一类型。
		LinkedHashMap	保留键的插入顺序，用equals 方法检查键和值的相等性	成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

Map中的entrySet()方法，返回一个实现 Map.Entry 接口的对象集合。集合中每个对象都是底层 Map 中一个特定的键-值对。Map.Entry 接口是Map 接口中的一个内部接口，该内部接口的实现类存放的是键值对。

 

HashMap的存入顺序和输出顺序无关。而LinkedHashMap 则保留了键值对的存入顺序。TreeMap则是对Map中的元素进行排序。实际使用中：使用HashMap或者LinkedHashMap 来存放元素，如果需要排序的Map就再使用TreeMap来重构原来的Map对象，提高存储效率。注意：TreeMap中是根据键（Key）进行排序的，Key 中存放的对象必须实现Comparable 接口。

 

 

 

 

 

 

 

Comparable接口，Comparable 接口适用于一个类有自然顺序的时候。在1.2 中有十四个类实现 Comparable 接口，如：

类	排序
BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short	按数字大小排序
Character	按 Unicode 值的数字大小排序
CollationKey	按语言环境敏感的字符串排序
Date	按年代排序
File	按系统特定的路径名的全限定字符的 Unicode 值排序
ObjectStreamField	按名字中字符的 Unicode 值排序
String	按字符串中字符 Unicode 值排序

 

Map的实现原理

HashMap使用的Hash算法。Hash翻译“散列、哈希” 把任意长度的输入，通过散列算法，变换成固定长度的输出。HashCode最重要因素是，无论何时，对同一个对象调用hashCode()都应该生成同样的值。Object的hashCode（）方法，返回的是当前对象的内存地址。

 

Hashtable类

Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。并且通过initial capacity和load factor两个参数调整性能。

由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，一定要同时复写equals方法和hashCode方法。Hashtable是同步的。

 

HashMap类

HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。

 

WeakHashMap类

WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

 

HashMap与TreeMap区别

  1、HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。集合框架”提供两种常规的Map实现：HashMap和TreeMap (TreeMap实现SortedMap接口)。

2、在Map 中插入、删除和定位元素，HashMap 是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。

 

hashtable与hashmap区别

1)    历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现

2)    同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的

3)    值：只有HashMap可以让你将空值作为一个表的条目的key或value

Java 枚举

综合评价：★★

普通类实现枚举，定义一个Weekday的类来模拟枚举功能。

1)      私有的构造方法，避免被实例化

2)      每个元素分别用一个公有的静态成员变量表示

3)      可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。（充分利用匿名内部类）

public abstract class WeekDay1 { private WeekDay1(){} public final static WeekDay1 SUN = new WeekDay1(){            @Override            public WeekDay1 nextDay() {                     return MON;            } }; public final static WeekDay1 MON = new WeekDay1(){            @Override            public WeekDay1 nextDay() {                     return SUN;            } };      public abstract WeekDay1 nextDay(); /*      public WeekDay nextDay(){            if(this == SUN){                     return  MON;            }else{                     return SUN;            } } */ public String toString(){            return this==SUN?"SUN":"MON"; }}

枚举特点

1.      枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

2.      枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。

public enum WeekDay{                    SUN(1),MON(),TUE,WED,THI,FRI,SAT;                    private WeekDay(){System.out.println("first");}                    private WeekDay(int day){System.out.println("second");}          }          public enum TrafficLamp{                    RED(30){                             public  TrafficLamp nextLamp(){                                      return GREEN;                             }                    },                    GREEN(45){                             public  TrafficLamp nextLamp(){                                      return YELLOW;                             }                                             },                    YELLOW(5){                             public  TrafficLamp nextLamp(){                                      returnRED;                             }                                             };                    public abstract TrafficLamp nextLamp();                    private int time;                    private TrafficLamp(int time){this.time = time;}          }

枚举只有一个成员时，就可以作为一种单例的实现方式。

Java反射

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示。反射就是把Java类中的各种成分映射成相应的Java类。

1、通过以下方式得到各个字节码对应的实例对象（ Class类型）

1)      类名.class，例如，System.class

2)      对象.getClass()，例如，newDate().getClass()

3)      Class.forName("类名")，例如，Class.forName("java.util.Date");

2、 九个预定义Class实例对象：

a)       参看Class.isPrimitive方法的帮助

b)       Int.class == Integer.TYPE

c)        数组类型的Class实例对象，Class.isArray()

注意：

1） 字节码，一个类在虚拟机中通常只有一份字节码

2） 静态代码块不是在类加载时被调用的，而是第一个实例对象被创建时才执行的。

3） 一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象

Constructor类

1.    Constructor类代表某个类中的一个构造方法

2.    得到某个类所有的构造方法：

Constructor [] constructors=Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：//获得方法时要用到类型

Constructor constructor =Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

3.    实例对象：

通常方式：String str = new String(new StringBuffer("abc"));

反射方式：String str = (String)constructor.newInstance(newStringBuffer("abc"));

         //调用获得的方法时要用到上面相同类型的实例对象

4.    Class.newInstance()方法：

例子：String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

field类

1. Field类代表某个类中的一个成员变量
2. 字段fieldX 代表的是x的定义，而不是具体的x变量。
3. 示例代码：

         ReflectPointpoint = new ReflectPoint(1,7);

         Fieldy =Class.forName("cn.John.corejava.ReflectPoint").getField("y");

         System.out.println(y.get(point));

         //Fieldx =Class.forName("cn.John.corejava.ReflectPoint").getField("x");

         Fieldx = Class.forName("cn.John.corejava.ReflectPoint").getDeclaredField("x");

         x.setAccessible(true);

         System.out.println(x.get(point));

 

中断

method类

Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式： System.out.println(charAt.invoke(str, 1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)

Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

问题：

启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，Javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，Javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{newString[]{"xxx"}});

mainMethod.invoke(null,(Object)newString[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

数组反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。String[] 通过Arrays.asList()方法可以打印数组元素，int[]则不行。

Array工具类用于完成对数组的反射操作。

Object[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。

main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)

properties 在hashmap上扩展的功能，能够将内存中的文件写入文件。也能读取文件中的信息，放入键值对。

使用反射调用配置文件中的信息，并且实例化对象

//InputStream ips = newFileInputStream("config.properties");

//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/John/day1/config.properties");

//InputStream ips =ReflectTest2.class.getResourceAsStream("resources/config.properties");

                   InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/John/day1/resources/config.properties");

                   Properties props = new Properties();

                   props.load(ips);

                   ips.close();

                   String className =props.getProperty("className");

                   Collection collections =(Collection)Class.forName(className).newInstance();。

//开发环境使用绝对路径，getRealPath();//金山词霸/内部

一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的

配置文件的加载，通常使用类加载器。

 

HashCode作用

为了方便在一个集合中大量元素查找需要元素时，有人发明了一种哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的就可以确定该对象应该存储在哪个区域。

HashSet就是采用哈希算法存取对象的集合，他内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域。Object类中定义了一个HashCode()方法来返回每个Java对象的哈希码，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode()方法获得该对象的哈希码，然后根据哈希码找到相应的存储区域，最后去除该存储区域内的每个元素与该对象进行equals方法比较，这样不用便利集合中国的所有元素就可以得到结论。HashSet集合具有很多好的对象检索性能，但是HashSet集合存储对象的效率相对要低些，因为向HashSet集合中添加一个对象时，要先计算出对象的哈希码和根据这个哈希码确定对象在集合中存放的位置。

为了保证一类的实例对象能在HashSet正常存储，要求这个类的两个实例对象用equals()方法比较的结果相等时，他们的哈希码也必须相等。也就是说，如果obj1.equals(obj2)的结果为true，那么一下表达式的结果也要为true:

Obj1.hashCode()=obj2.hashCode()

只有类的实例对象要被采用哈希算法进行存储和检索时，这个类才需要按要求覆盖hashCode方法。即使程序可能暂时不会用到当前类的hashCode方法大，但是为他提供一个hashCode方法也不会有什么不好，没准以后什么时候有用到这个方法了，所以，通常要求hashCode方法和equals方法一并被覆盖。

提示：

·        通常来说，一个类的两个实例对象用equal()方法比较的结果相等时，他们的哈希码也必须相等，但反之则不成立，即equals方法比较结果不相等的对象可以有相同的哈希码，或者说哈希码相同的对象的equals方法比较的结果可以不等，例如，字符串”BB”和字符串”Aa”的equals方法比较结果肯定不相等，但他们的hashCode方法返回值却相等。

·        当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈市细致与最初村粗进HashSet集合中时的哈希值就不同了，在这种情况下，继续在contains方法是用该对象的当前作为参数去HashSet集合中检索对象，也将返回找不到对象的结婚过，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露

Method?

Date dt = new Date();

Class clazz = Date.class ;//字节码

Dt.getClass();

Class.forName(“java.lang.String”);

得到字节码

1、 虚拟机已经加载

2、 虚拟机未加载

8个基本类型，都有对应的class对象。字节码和类对象有关

Int.class ==Integer.type

Int[].class.isArray();

Void.class

Constructor代表某个类中的一个构造方法

得到某个类所有的构造方法

Construtor[] contructors = Class.forName(“java.lang.String”).getContructors();

得到某一个构造方法

Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

//获得方法时要用到类型

创建实例对象

通常，String str = newString(new StringBuffer(“abc”));

反射，String str =(String)constructor.newInstance(new StringBuffer(“abc”));

//调用获得方法时要用到上面相同类型的实例对象

Arrays.asList()方法处理int[]和String[]时的差异。

内省

1)       内省(Introspector)是Java 语言对Bean类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过getName/setName 来访问 name 属性，这就是默认的规则。

Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中。

2)       直接通过属性的描述器java.beans.PropertyDescriptor类，来访问属性的getter/setter 方法;

3)       通过类 Introspector来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方。

4)       我们又通常把Javabean的实例对象称之为值对象（Value Object）,因为这些bean中通常只有一些信息字段和存储方法，没有功能性方法。一个JavaBean类可以不当JavaBean用，而当成普通类用。JavaBean实际就是一种规范，当一个类满足这个规范，这个类就能被其它特定的类调用。一个类被当作JavaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到Java类内部的成员变量(Javabean的成员变量通常都是私有private的)。

5)       除了反射用到的类需要引入外，内省需要引入的类如下所示，它们都属于java.beans包中的类，自己写程序的时候也不能忘了引入相应的包或者类。

import java.beans.BeanInfo;

import java.beans.IntrospectionException;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

6)       下面讲解一些开源的工具类Beanutils,需要额外下载的，commons-beanutils.jar，要使用它还必须导入commons-logging.jar包，不然会出异常；

//获取Javabean对象的某个属性的值

PropertiesDescriptor pd2 = new PropertiesDescriptor(propertiesName,pt1.getClass());

Method methodGetX= pd2.getReadMethod();

需要了解beanutil等包的学习，属性连功能。

Java 注解

什么是Java注解 

    注解，顾名思义，注解,就是对某一事物进行添加注释说明，会存放一些信息，这些信息可能对以后某个时段来说是很有用处的。 
Java注解又叫Java标注，Java提供了一套机制，使得我们可以对方法、类、参数、包、域以及变量等添加标准(即附上某些信息)。且在以后某个时段通过反射将标注的信息提取出来以供使用。 

自定义注解 

Java从1.5版本以后默认内置三个标注：

1) @Override:只能用在方法之上的，用来告诉别人这一个方法是改写父类的。 
2) @Deprecated:建议别人不要使用旧的API的时候用的,编译的时候会用产生警告信息,可以设定在程序里的所有的元素上. 
3) @SuppressWarnings:这一个类型可以来暂时把一些警告信息消息关闭. 

1.        如何自定义注解 

自定义步骤大致分为两步：

1) 通过@interface关键字(注意，不是interface，是@interface)声明注解名称，以及注解的成员属性或者叫做注解的参数。 
2)使用Java内置的四个元注解对这个自定义标注的功能和范围进行一些限制 

2.        什么是元注解 
    元注解，就是定义注解的注解，也就是说这些元注解是的作用就是专门用来约束其它注解的注解。请区别上面那三个注解，他们也是通过元注解定义而来的。 
元注解有哪些呢，主要有四个@Target,@Retention,@Documented,@Inherited

数组类型的属性

int [] arrayAttr() default{1,2,3};

@MyAnnotation(arrayAttr={2,3,4})

如果数组属性中只有一个元素，这时候属性值部分可以省略大括

枚举类型的属性

EnumTest.TrafficLamplamp() ;

@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

注解类型的属性

MetaAnnotationannotationAttr() default @MetaAnnotation("xxxx");

@MyAnnotation(annotationAttr=@MetaAnnotation(“yyy”))

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调用代码如下：MetaAnnotation ma = myAnnotation.annotationAttr();

         System.out.println(ma.value));

注解的详细语法可以通(过看Java语言规范了解，即看Java language specification。

注解与反射

if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class)){

   MyAnnotation myAnnotation = AnnotationTest.class.getAnnotation(MyAnnotation.class);

}

创建自定义注解

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD,ElementType.TYPE})

public @interface JohnAnnotation {

         Stringcolor() default "blue";

         Stringvalue();

         int[] arrayAttr() default{3,4,4};

         EnumTest.TrafficLamplamp() default EnumTest.TrafficLamp.RED;

         MetaAnnotation annotationAttr() default @MetaAnnotation("lhm");

}

 

通过Eclipse自动创建注解，类似于创建接口一样。Eclipse包含注解创建选项

注解的注解叫元注解

@Retention元注解的讲解，其三种取值：RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME;分别对应：Java源文件-->class文件-->内存中的字节码。Class文件里面不是字节码，只有加载到内存中才是字节码。

@Override、@SuppressWarnings和@Deprecated这三个注解的属性值分别是RetetionPolicy.SOURCE、RetetionPolicy.SOURCE、RetetionPolicy. RUNTIME

@Target描述我们的注解用在什么元素上。注解生命周期默认值可在class文件

添加属性和设置属性

l  注解的属性：@MyAnnotation(color="red")

l  定义基本类型的属性和应用属性：

在注解类中增加 String color();@MyAnnotation(color="red")

l  用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

MyAnnotation a =(MyAnnotation)AnnotationTest.class

.getAnnotation(MyAnnotation.class);

System.out.println(a.color());

//可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象

l  为属性指定缺省值：String color() default "yellow";

l  value属性：String value()default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。

l  数组类型的属性:int [] arrayAttr() default {1,2,3};int[]和String[]区别

@MyAnnotation(arrayAttr={2,3,4})//如果数组属性中只有一个元素，这时候属性值部分可以省略大括

l  枚举类型的属性：

EnumTest.TrafficLamplamp() ;

@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

l  注解类型的属性：MetaAnnotation annotationAttr() default@MetaAnnotation("xxxx");

@MyAnnotation(annotationAttr=@MetaAnnotation(“yyy”) )

注意：可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调用代码如下：

         MetaAnnotationma =  myAnnotation.annotationAttr();

         System.out.println(ma.value());

注解的详细语法可以通过看Java语言规范了解，即看Java language specification。

注解与枚举、注解与注解、注解与反射

Java 泛型

Java 泛型基本知识

泛型（generic）是提供给Javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

在JDK 1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告，泛型是表现给编译器的。

l  ArrayList类定义和ArrayList类引用中涉及如下术语：

1.      整个称为ArrayList泛型类型

2.      ArrayList中的E称为类型变量或类型参数

3.      整个ArrayList称为参数化的类型

4.      ArrayList中的Integer称为类型参数的实例或实际类型参数

5.      ArrayList中的<>念着typeof

6.      ArrayList称为原始类型

l  参数化类型与原始类型的兼容性：

1.      参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection c = new Vector();

2.      原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector();

l  参数化类型不考虑类型参数的继承关系：

1.      Vector v = newVector