定义： 注解是一种注释机制，它可以注释包、类、方法、变量、参数，在编译器生成类文件时，标注可以被嵌入到字节码中。
Override :重写方法，引用时没有该方法时会编译错误
public class Animals {
public void run(){
System.out.println("动物跑");
}
}public class Cat extends Animals{
@Override
public void run1() {
super.run();
}
}
Deprecated :标记过时方法，会造成编译警告
public class Animals {
@Deprecated
public void run(){
System.out.println("动物跑");
}
}
SuppressWarnings :用于编译器去忽略注解中的声明报告
FunctionalInterface ：用于指示被修饰的接口是函数式接口
@Retention -标记这个注解存储在哪里
@Documented -标记这些注解是否包含在用户文档中
@Target -标记这些注解时java哪种成员
public enum ElementType {
/** Class, interface (including annotation type), or enum declaration */
//可以应用于类的任何元素
TYPE,
//可以用于字段或属性
/** Field declaration (includes enum constants) */
FIELD,
//可以用于方法级注释
/** Method declaration */
METHOD,
//可以用于方法的参数
/** Formal parameter declaration */
PARAMETER,
//可以应用于构造函数
/** Constructor declaration */
CONSTRUCTOR,
//可以用于局部变量
/** Local variable declaration */
LOCAL_VARIABLE,
/** Annotation type declaration */
ANNOTATION_TYPE,
//可以用于包声明
/** Package declaration */
PACKAGE,
/**
* Type parameter declaration
*
* @since 1.8
*/
TYPE_PARAMETER,
/**
* Use of a type
*
* @since 1.8
*/
TYPE_USE
}@Inherited -标记这个注解时继承于哪个类
@Repeatable -标识某注解可以在同一个声明上使用多次
public enum RetentionPolicy {
/**
* Annotations are to be discarded by the compiler.
*/
SOURCE,//在源文件中有效（源文件保存）
/**
* Annotations are to be recorded in the class file by the compiler
* but need not be retained by the VM at run time. This is the default
* behavior.
*/
CLASS,//在class文件中有效（class保存）
/**
* Annotations are to be recorded in the class file by the compiler and
* retained by the VM at run time, so they may be read reflectively.
*
* @see java.lang.reflect.AnnotatedElement
*/
RUNTIME//在运行时有效（运行时保留）
}注解类：
@Target(ElementType.FIELD)//作用在类的属性上
@Retention(RetentionPolicy.RUNTIME)//运行时生效
public @interface NotNull {
String message() default "";
int length() default 0;
String lengthmessage() default "";
}model类：
public class User {
private int num;
@NotNull(message="姓名不能为空",length=3,lengthmessage="长度不能小于3")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}测试代码：
public class Test {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, Exception {
User user=new User();
Field[] fields=user.getClass().getDeclaredFields();//将类中的字段存储在field数组中
//对数组中的字段进行强循环
for(Field filed:fields){
NotNull notNull=filed.getAnnotation(NotNull.class);//获取注释类型
if(notNull!=null){
Method method = user.getClass().getMethod("get" + getMethodName(filed.getName()));//获取方法对象
Object value = method.invoke(user);//调用类的实例对象
if(value==null){
System.err.println(filed.getName()+notNull.message());//打印输出相应的字段和注释信息
throw new NullPointerException(notNull.message());//抛出异常信息
}
else if(String.valueOf(value).length()< notNull.length()){//判断字符串长度
System.err.println(filed.getName()+notNull.lengthmessage());
}
}
}
}
/**
* 把一个字符串的第一个字母大写
*/
private static String getMethodName(String fildeName) throws Exception {
byte[] items = fildeName.getBytes();
items[0] = (byte) ((char) items[0] - 'a' + 'A');
return new String(items);
}
}原因：new出来的对象属性都是初始化的值，不能保存当前对象“状态”，clone解决了这个问题
//这种形式的代码复制的是引用，即对象在内存中的地址，car1和car2指向同一个对象 Car car1=new Car(); Car car2=car1;
克隆分为浅克隆和深克隆，下面就简单的介绍它们之前的区别：
model类：
public class Person implements Cloneable{
int num;
String name;
Address address;
public Person() {
}
public Person(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
protected Person clone() throws CloneNotSupportedException {
Person person = (Person)super.clone();
// person.address = (Address)address.clone(); //深度复制 联同person中关联的对象也一同克隆.
return person;
}
@Override
public String toString() {
return "Person{" +
"num=" + num +
", name='" + name + '\'' +
", address=" + address +
'}';
}
}引用类：
public class Address {
String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
@Override
protected Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
}测试类：
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address();
address.setAddress("汉中");
Person p1 = new Person(100,"jim");
p1.setAddress(address);
Person p2 =p1.clone();
p2.setName("tom");
address.setAddress("西安");//
System.out.println(p1);
}
}
浅克隆中引用对象进行的是引用地址传递，原引用对象和克隆对象指向同一个引用地址
强克隆（值类型克隆值，引用类型克隆一个带有原数据的新的地址）
引用类：
public class Address implements Cloneable{
String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
@Override
protected Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
}model类：
public class Person implements Cloneable{
int num;
String name;
Address address;
public Person() {
}
public Person(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
protected Person clone() throws CloneNotSupportedException {
Person person = (Person)super.clone();
person.address = (Address)address.clone(); //深度复制 联同person中关联的对象也一同克隆.
return person;
}
@Override
public String toString() {
return "Person{" +
"num=" + num +
", name='" + name + '\'' +
", address=" + address +
'}';
}
}测试：
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address();
address.setAddress("汉中");
Person p1 = new Person(100,"jim");
p1.setAddress(address);
Person p2 =p1.clone();
p2.setName("tom");
address.setAddress("西安");
System.out.println(p1);
System.out.println(p2);
}
}
强克隆中的引用类型新创建的地址赋给克隆对象引用类型
我们也可以通过序列化的方式对对象进行克隆，代码如下：
引用类：
public class Address implements Serializable {
String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}model类：
public class Person implements Serializable {
int num;
String name;
Address address;
public Person() {
}
public Person(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
/**
* 自定义克隆方法
* @return
*/
public Person myclone() {
Person person = null;
try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
// 将流序列化成对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
person = (Person) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return person;
}
@Override
public String toString() {
return "Person{" +
"num=" + num +
", name='" + name + '\'' +
", address=" + address +
'}';
}
}测试类：
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address();
address.setAddress("汉中");
Person p1 = new Person(100,"jim");
p1.setAddress(address);
Person p2 =p1.myclone();
p2.setName("tom");
address.setAddress("西安");
System.out.println(p1);
System.out.println(p2);
}
}
