注解，通过反射机制 去获取注解中设置的值，lambda表达式，断言

1.自己写的第一个注解
设置注解的域 , RetentionPolicy.RUNTIME 运行时期也可以使用
默认是 RetentionPolicy.RUNTIME 是编译时期可以用,运行时期不可用
RetentionPolicy.SOURCE 编译器时期就丢弃
在使用注解是,要求给注解的属性付初始值
赋值的格式: (属性名=属性值,属性名=属性值…)
注解: 给程序看的.告知程序如何执行
比如 Override 重写的标记
自定义注解:
public @interface 注解的名字{
属性
String name() default “aaa”;
int age();
Class cls() ;
枚举 gender();
int[] arr();
Annotation an();
}
注解可以作用在类中的类上面, 属性 , 方法上面, 如果注解中设置了@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})
就要按照target设置的类型来使用
注解中的内容只能通过反射来获取
cls.getAnnotation(注解.class);
元注解:
@Documented
// 存在继承性
@Inherited
// 指定注解可以作用于类的那些成员
@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})
@Retention(value=RetentionPolicy.RUNTIME)

public @interface MyAnnotation {
	// 在这里叫属性
	// 运行的时候 public abstract String name();
	String name();
	int age();
}
@MyAnnotation(name="zhangsan",age=4)
		String gender;		
		@MyAnnotation(name="lisi",age=14)
		public void show(){			
		}

当注解中只有一个属性,并且属性的名字叫value的时候, 可以在使用的时候省略属性名

public @interface MyAnnotation2 {
	String value();
}
@MyAnnotation2("aaa")
		public void show2(){			
		}

注解中属性的数据类型有要求:

• String 基本数据类型 数组 枚举 注解 Class

public @interface MyAnnotation3 {
	String name() default "zhangsan";
	int age() default 4;
	int[] arr() default {1,2,3,4,5};
	Gender gender() default Gender.男;
	Class cls() default Person.class;
	MyAnnotation annotation() default @MyAnnotation(age = 5, name = "zhangsan");
}

@Documented
//存在继承性
@Inherited
//指定注解可以作用于类的那些成员
@Target(value={ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@SuppressWarnings("serial")
public class Person implements Serializable{
	// 注解 提前告诉编译器说 此方法是重写
		@Override   //重写
		public String toString() {
			// TODO Auto-generated method stub
			return super.toString();
		}		
		@Deprecated
		public static void show(){			
		}			
		// 抑制警告
		@SuppressWarnings("all")
		public static void main(String[] args) {
			Date date = new Date();
			date.getDay();			
			show();			
			@SuppressWarnings("unused")
			List  list = new ArrayList();			
		}
}

2.通过反射机制 去获取注解中设置的值

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		// 1. 第一步得到Class对象
		Class cls = Class.forName("demo.Student");
		MyAnnotation myAnnotation = (MyAnnotation) cls.getAnnotation(MyAnnotation.class);
		String name = myAnnotation.name();// myAnnotation null
		int age = myAnnotation.age();
		System.out.println("类上面的" + name + " ---> " + age);
		// 创建Student类的对象
		Object obj = cls.newInstance();
		Method method = cls.getMethod("show", String.class, int.class);
		// 获取show方法上面注解的信息
		MyAnnotation mAnnotation2 = method.getAnnotation(MyAnnotation.class);
		String name2 = mAnnotation2.name();
		int age2 = mAnnotation2.age();
		// 调用show方法
		method.invoke(obj, name2, age2);
	}
}

自定义注解

@MyAnnotation4(age=5)
public class Teacher {
	@MyAnnotation4
	int age;
	@MyAnnotation4
	public void show(){		
	}
}
public class LittleTeacher extends Teacher{
}
public class Test2 {
	public static void main(String[] args) {
		// LittleTeacher 继承到Teacher类中注解
				Class cls = LittleTeacher.class;
				MyAnnotation4 myAnnotaion4 = (MyAnnotation4)cls.getAnnotation(MyAnnotation4.class);
				int age = myAnnotaion4.age();
				System.out.println(age);
	}
}

3.函数式接口
在jdk1.8以后,新增了带有方法体的 静态方法和默认方法 以提高代码的复用性
1.8新增行

• 1. 接口中新增了 默认方法和静态方法 带有方法体的方法,提高了复用性
• 2. 哈希表
     由 数组+链表 变成了 数组+链表+红黑树 的结构
• 3. 函数式接口: 一个接口中只能存在一个抽象方法, 默认和静态方法不限
• 接口中的静态方法只能用接口名字调用,

@FunctionalInterface
public interface AAA {
public void a();	
	//public void b();	
	public static void b(){		
	}	
	public default void c(){		
	}
}
public class TV implements MyInterface{
	/*
	 * @Override public void tongdian() { System.out.println("通电"); }
	 */
	@Override
	public void tongdian2() {
	}
}
public interface MyInterface {
	public void tongdian2();
	// 在jdk1.8以后,新增了带有方法体的 静态方法和默认方法 以提高代码的复用性
	public static void tongdian() {
		System.out.println("通电");
	}
	public default void a() {
		System.out.println("aaaa");
	}
}
public class Test {
	public static void main(String[] args) {
		TV tv = new TV();
		tv.a();		
		// 接口中的静态方法只能用接口名字调用, 
		MyInterface.tongdian();
	}
}

3.lambda表达式
会对 匿名内部类进行格式上的简化, 让代码更加的简洁紧凑
lambda表达式不会产生 字节码文件

@FunctionalInterface
public interface MyInterface {
	public void show();
}
import java.util.Comparator;
import java.util.TreeSet;
public class Test {
	public static void main(String[] args) {
		// 匿名的内部类
				/*Runnable run = new Runnable() {					
					@Override
					public void run() {
						// TODO Auto-generated method stub						
					}
				};*/				
				// 原来的匿名内部类的写法
				MyInterface  interface1 = new MyInterface() {					
					@Override
					public void show() {
						System.out.println("展示");
					}
				};
				interface1.show();
				MyInterface interface2 =()-> System.out.println("展示");											
				Runnable runnable = new Runnable() {				
					@Override
					public void run() {
						System.out.println("这是一个任务");
					}
				};			
				Runnable runnable2 = ()->System.out.println("这是一个任务");							
				Comparator<Integer> comparator = new Comparator<Integer>() {
					@Override
					public int compare(Integer o1, Integer o2) {
						// TODO Auto-generated method stub
						return o1-o2;
					}
				};				
				// 当大括号中只有一条语句的时候可以将 大括号省略
				// 如果方法体中带有return,则要讲return也一起省略
				//Comparator<Integer> comparator2 = (o1,o2)->o1-o2;			
				TreeSet<Integer> set = new TreeSet<>((o1,o2)->o2-o1);
				set.add(3);
				set.add(13);
				set.add(30);
				set.add(2);
				System.out.println(set);						
				Comparable<Integer> comparable = new Comparable<Integer>() {
						@Override
					public int compareTo(Integer o) {
						// TODO Auto-generated method stub
						return 1;
					}
				};	
				// 当小括号中参数为1个的时候 小括号可以省略
				Comparable<Integer> comparable2 = o->1;
	}
}
import demo2.MyInterface;;
public class Test2 {
	public static void main(String[] args) {
		MyInterface interface1 = new MyInterface() {
			@Override
			public void tongdian2() {
				System.out.println("aaaa");
			}
		};
		int a = 0;
		interface1.tongdian2();
		MyInterface interface2 = new MyInterface() {
			@Override
			public void tongdian2() {
				// 内部类中 如果使用外部类的局部变量, 则要求添加final, 在jdk1.7以后会自动帮助添加
				System.out.println(a);
				System.out.println("aaaa");
			}
		};
		MyInterface myInterface = () -> System.out.println("bbb" + a);
		myInterface.tongdian2();
	}
}

4.断言
Predicate 断言型的

import java.util.ArrayList;
public class Test {
	public static void main(String[] args) {
		ArrayList<String> list= new ArrayList<>();
		list.add("aaa");
		list.add("bbbb");
		list.add("cc");
		list.add("aadda");				
		/*Consumer<String> consumer = new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		};*/
		//Consumer 利用消费型接口实现了遍历集合
		list.forEach(t->System.out.println(t));		
		/*Predicate<String> predicate = new Predicate<String>() {
			@Override
			public boolean test(String t) {
				// TODO Auto-generated method stub
				return t.length()>3;
			}
		};*/
		//Predicate 断言型的
		list.removeIf(t->t.length()>3);
	}
}