4、Java中的Object类@Override注解、Lambda表达式

Object类

重写Object类的方法，直接输出。

如果一个类没有extends，那将自动继承Object类。Object类支持引用类型，不支持基本类型

toString方法控制对象的字符串输出

public class Person {
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName() {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge() {
		this.age = age;
	}
	public Person() {
		
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";//输出标准格式。数字18自动转为字符串
	}
	
	public static void main(String[] args) {
		Person person1 = new Person("Rxl",18);
		System.out.println(person1);
	}
}	

public String toString() {
    return 信息;
}
Man5.fly();
不需要调用toString方法，便可以直接println方法进行输出，可以输出对象。（输出return的返回值）

给定两个对象
Student stu1 = new Student("name",1007);
Student stu2 = new Student("name",1007);
Student stu3 = "hello";         // 字面量是常量，放在常量池里面
Student stu4 = "h"+"e"+"llo";   // 常量拼接还是常量
 
//比较地址，地址本就不同，将输出false。等号判断引用类型，是依据对象的地址来判断
System.out.println( stu1 == stu2)    ->    false
System.out.println( stu3 == stu4)    ->    true   
//常量池内的常量，被定义之后就只有一个，不同于new出来的对象在堆区，故而返回值为true
 
//由于引用类型不能用等号，而是需要重写Object的equals方法来判断
//重写Object的方法
pubulic boolean equals(Object obj) {
    if(obj == null) {                           //判断依据需要自己重写
    	Return false;
    }
    if(this == obj){
    	Return ture;
    }
    
    基本类型不能用于 instanceof 判断
    instanceof 关键字一般用于强制转换，在强转之前用它来判断是否可以强制转换
    if(obj instanceof Student) {  //如果是同一个类型，就比较他们的关键参数。大转小需要类型
    	Student other = (Student)obj;   //类型强制转换
    if(this.idCard == other.idCard && this.name.equals(other.name)) {//引用类型用equals，基本类型用"=="
    	return ture;
    } else {
    	return false;
    }
} 
return false;
}

特殊的接口——注解（Annotation），标注（接口），继承自超接口

给JVM用的（方便jvm去读取注解），和源代码一样，通过编译，可以继续使用

1、@Override——检查该方法是否是重写方法，如果发现父类或者引用接口中没有该方法时，就会报编译错误

@Override, 重写父类，实现接口，都需要写上@Override，避免程序出错，保证了安全性

2、@FunctionalInterface——函数式接口，有且只有一个抽象方法的接口

为了避免类的膨胀（写很多的类），以及一个类只想使用一次

解决方法：匿名内部(类的内部，方法内部)类（实现接口）（因为被匿名了，所以没有名字，自然不能二次引用）

加不加@FunctionalInterface对于接口是不是函数式接口是没有影响的。该注解只是提醒编译器去检查该接口是否包含一个抽象方法

函数式接口里允许定义静态方法

函数式接口里允许定义Object中的public方法

@FunctionalInterface
interface GreetingService{
     void sayMessage(String message);
}

这样的接口就可以使用Lambda表达式来表示该接口的一个实现
GreetingService greetingService = message → System.our.println("Hello" + message);

3、Lambda 表达式的作用是去实现函数式接口中的抽象方法

CanFly man5 = (String tools) -> {       //一个参数的时候，可以省掉参数，括号，类型
    System.out.println();
};

CanFly man5 = tools -> System.out.println("");引用类型

编写步骤

1、确认Lambda表达式的类型

2、找到要实现的方法，函数式接口

3、实现这个方法

接口里面，抽象方法只能有一个，因为Lambda只能实现一个抽象方法

4、方法引用

当方法体中只有一个方法调用时，可以简化

a -> a.getid()  //就是对Student对象上getid()方法的调用，还可以继续简化成Student::getid
Text text = () -> ArrayList<>();
Text text = ArrayList::new;