ConcurrentHashMap实现原理和特点

注解的使用方式（注解的原理没有细看）
代理模式（静态）
动态代理

Author: uodut

src/AnnotationDemo/AnnotationClass.java

@@ -0,0 +1,31 @@
+package AnnotationDemo;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+/**
+ * 元注解包括：
+ * 　		  1.@Target,
+　　　　2.@Retention,
+　　　　3.@Documented,
+　　　　4.@Inherited
+ * Target取值(ElementType)有：
+ * 　		  1.CONSTRUCTOR:用于描述构造器
+　　　　2.FIELD:用于描述域
+　　　　3.LOCAL_VARIABLE:用于描述局部变量
+　　　　4.METHOD:用于描述方法
+　　　　5.PACKAGE:用于描述包
+　　　　6.PARAMETER:用于描述参数
+　　　　7.TYPE:用于描述类、接口(包括注解类型) 或Enum声明
+	Retention取值（RetentionPolicy）有：
+　　　　1.SOURCE:在源文件中有效（即源文件保留）
+　　　　2.CLASS:在class文件中有效（即class保留）
+　　　　3.RUNTIME:在运行时有效（即运行时保留）
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)//如果不加这句的话，在使用反射的时候找不到此注解
+public @interface AnnotationClass {
+	public String className() default "className";
+}
+

src/AnnotationDemo/AnnotationConstructor.java

@@ -0,0 +1,13 @@
+package AnnotationDemo;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.CONSTRUCTOR,ElementType.METHOD})//¿ÉÒÔÓжà¸ö
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AnnotationConstructor {
+	String name() default("");
+	int age() default(0);
+}

src/AnnotationDemo/AnnotationTest.java

@@ -0,0 +1,62 @@
+package AnnotationDemo;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import BasicDao.PersonAnnotation;
+
+/**
+ * 2016年3月1日
+ * @author <a href = "[email protected]">王高亮</a>
+ * 得到注解内容
+ */
+public class AnnotationTest {
+	public static void main(String[] args){
+		parseTypeAnnotation();
+		parseMethodAnnotation();
+		parseConstructorAnnotation();
+	}
+	//类，接口，枚举注解
+	static void parseTypeAnnotation(){
+		Class<?> clazz;
+		try {
+			clazz = Class.forName("BasicDao.PersonAnnotation");
+			Annotation[] annotations = clazz.getAnnotations();
+			for(Annotation annotaion:annotations){
+				AnnotationClass ac = (AnnotationClass)annotaion;
+				System.out.println(ac.className());
+			}
+		} catch (ClassNotFoundException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	//成员方法注解
+	static void parseMethodAnnotation(){
+		Method[] methods = PersonAnnotation.class.getDeclaredMethods();
+		System.out.println(methods.length);
+		for(Method method:methods){
+			boolean hasAnnotation = method.isAnnotationPresent(AnnotationConstructor.class);
+			if(hasAnnotation){
+				AnnotationConstructor ac = method.getAnnotation(AnnotationConstructor.class);
+				System.out.println("method  = " +method.getName() + '\t'
+						+ "name = " + ac.name() + '\t' + "age = " + ac.age());
+			}
+		}
+	}
+	//构造函数注解
+	static void parseConstructorAnnotation(){
+		Class<?> clazz = new PersonAnnotation().getClass();
+		Constructor<?>[] constructors = clazz.getConstructors();
+		for(Constructor<?> constructor:constructors){
+			boolean hasAnnotation = constructor.isAnnotationPresent(AnnotationConstructor.class);
+			if(hasAnnotation){
+				AnnotationConstructor ac = constructor.getAnnotation(AnnotationConstructor.class);
+				System.out.println("Constuctor = " + constructor.getName()
+						+ '\t' + "name = " + ac.name() + '\t' + "age = "
+						+ ac.age());
+			}
+		}
+	}
+}

src/BasicDao/ArgsDemo.java

@@ -1,4 +1,7 @@
 package BasicDao;
+
+import java.util.concurrent.ConcurrentHashMap;
+
 /**
  * 可变参数
  * 必须为参数的最后一个，且在一个方法中只能有一个可变参数。可以把可变参数当做数组处理。

src/BasicDao/PersonAnnotation.java

@@ -0,0 +1,37 @@
+package BasicDao;
+
+import AnnotationDemo.AnnotationClass;
+import AnnotationDemo.AnnotationConstructor;
+
+@AnnotationClass(className = "PersonAnnotation，类注解")
+public class PersonAnnotation {
+	@AnnotationConstructor(name="构造器注解",age=23)
+	public PersonAnnotation(){
+	}
+	
+	private String name;
+	private int age;
+	private String otherInfo;
+	public String getName() {
+		return name;
+	}
+	@AnnotationConstructor(name="成员方法注解")
+	public void setName(String name) {
+		this.name = name;
+	}
+	public int getAge() {
+		return age;
+	}
+	@AnnotationConstructor(age = 13)
+	public void setAge(int age) {
+		this.age = age;
+	}
+	public String getOtherInfo() {
+		return otherInfo;
+	}
+	public void setOtherInfo(String otherInfo) {
+		this.otherInfo = otherInfo;
+	}
+	
+	
+}

src/ClassDemo/常规内部类.java src/ClassDemo/PlainInnerClass.javasrc/ClassDemo/常规内部类.java renamed to src/ClassDemo/PlainInnerClass.java

@@ -4,7 +4,7 @@
  * 内部类和外部类的成员变量和访问规则
  *
  */
-public class 常规内部类 {
+public class PlainInnerClass {
 	private int age = 11;
 
 	public class In{
@@ -13,7 +13,7 @@ public void print(){
 			int age = 13;
 			System.out.println("内部类的变量" + age);//默认访问外部类变量，但内部类有同名变量时覆盖外部类变量
 			System.out.println("内部成员变量"+this.age);//访问内部成员变量
-			System.out.println(常规内部类.this.age);//访问外部类的成员变量
+			System.out.println(PlainInnerClass.this.age);//访问外部类的成员变量
 		}
 		private void print2(){
 			System.out.println("外部类的私有变量" + age);
@@ -32,7 +32,7 @@ public static void main(String[] args) {
 
 　　2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量
 		 */
-		常规内部类.In in = new 常规内部类().new In();//内部类的实例化方式
+		PlainInnerClass.In in = new PlainInnerClass().new In();//内部类的实例化方式
 		in.print();
 		in.print2();//调用内部类的私有成员方法print2()
 

src/ClassDemo/私有内部类.java src/ClassDemo/PrivateInnerClass.javasrc/ClassDemo/私有内部类.java renamed to src/ClassDemo/PrivateInnerClass.java

@@ -1,6 +1,6 @@
 package ClassDemo;
 
-public class 私有内部类 {
+public class PrivateInnerClass {
 	private int age = 11;
 	private class In{
 		public void print(){
@@ -12,7 +12,7 @@ public In getInstance(){
 	}
 	public static void main(String[] args) {
 		//私有内部类.In in = new 私有内部类.new  In();
-		私有内部类 s = new 私有内部类();//不能支持操作内部类，需要在外部类中提供得到内部类对象的方法。
+		PrivateInnerClass s = new PrivateInnerClass();//不能支持操作内部类，需要在外部类中提供得到内部类对象的方法。
 		s.getInstance().print();
 	}
 }

src/ClassDemo/静态内部类.java src/ClassDemo/StaticInnerClass.javasrc/ClassDemo/静态内部类.java renamed to src/ClassDemo/StaticInnerClass.java

@@ -1,6 +1,6 @@
 package ClassDemo;
 
-public class 静态内部类 {
+public class StaticInnerClass {
 	private int age = 10;
 	private static String name = "tudou";
 	static class In{
@@ -10,7 +10,7 @@ void print(){
 		}
 	}
 	public static void main(String[] args) {
-		静态内部类.In in = new 静态内部类. In();//In被当做是“静态内部类”的一个静态成员，所以可以直接调用，不用实例化
+		StaticInnerClass.In in = new StaticInnerClass. In();//In被当做是“静态内部类”的一个静态成员，所以可以直接调用，不用实例化
 		in.print();
 	}
 }

src/ClassDemo/匿名内部类.java src/ClassDemo/UnnameInnerClass.javasrc/ClassDemo/匿名内部类.java renamed to src/ClassDemo/UnnameInnerClass.java

@@ -1,6 +1,6 @@
 package ClassDemo;
 
-public class 匿名内部类 {
+public class UnnameInnerClass {
 	public static void main(String[] args) {
 		InterfaceDemo id = new InterfaceDemo(){
 			public void func(){

src/DesignMode/DynamicProxy/Bird.java

@@ -0,0 +1,17 @@
+package DesignMode.DynamicProxy;
+
+public class Bird implements Sound, Flyable {
+
+	@Override
+	public void fly() {
+		// TODO Auto-generated method stub
+		System.out.println("Bird can fly");
+	}
+
+	@Override
+	public void sound() {
+		// TODO Auto-generated method stub
+		System.out.println("Bird can speak");
+	}
+
+}