一、在一个类中重写toString方法
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// {name=name , age= age}
return "{" + "name=" + getName() +
"age=" + getAge() +
"}";
}
// 重写 equals
@Override
public boolean equals(Object obj) {
// 判断内存地址是否相同
if( this == obj ){
return true;
}
// 判断 传入的obj的对象是否为空 obj的类型与当前类型是否相同
if ( obj == null || this.getClass() != obj.getClass() ){
return false;
}
// 强转 类型
Person p = (Person) obj
// 判断传入的obj对象 的 值是否为空，判断值是否相同，
return this.age == p.age && Objects. equals( this.name,p.name )
// 判断 值是否相同
}
二、泛型的定义和使用
可以 灵活地 将数据类型应用到不同的 类、方法、接口中 将数据类型做为参数进行传递
1。定义和使用含有泛型的类 ，方法，参数
定义格式：
修饰符 class 类名 <代表泛型的变量>{ }
例子：
// 泛型在类中使用 定义的 位置 位于 类名 后
public class Person <E>{
// 泛型作为参数 在 括号里
public boolean add (E e){
}
// 带有 泛型 方法 位于 替换 方法类型
public E get(int index){
}
}
2.距离定义 泛型类
public class MyGenericClass<MVP> {
//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
3. 含有泛型的 方法 定义的格式
格式:
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
}
4.含有泛型的接口
定义格式:
修饰符 interface 接口名 <代表泛型的变量>{ }
public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}
在定义类的时候 确定泛型 的类型
例如:
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
/**
确定泛型
*/
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
一、泛型的通配符
当使用 泛型类 或者接口时，传递的数据中，泛型的类型不确定，可以通过通配符<?>表示。但是一旦使用泛型通配符后，
只能使用Object类的共性方法，集合中自身方法无法使用。
1.通配符基本使用
泛型的通配符的：不知道什么时候用什么类型 来 接受的时候， 此时 可以使用 ？ 表示未知通配符
例子：
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型
Notes：
tips:泛型不存在继承关系 Collection<Object> list = new ArrayList<String>();这种是错误的；
2.通配符高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类 就可以设置。但是在Java的泛型中可以制定一个泛型的上线和下限
泛型的上限：
格式： 类型名称<? extends 类> 对象名称
意义：只能接收该 类型及其子类
泛型的下限：
格式 ： 类型的名称<? super 类> 对象名称
意义： 只能 接收该类型 及其父类类型
例子：
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
常见数据结构：
栈、队列、数组、链表和红黑树。