一、在一个类中重写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类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
private MVP mvp;

public void setMVP(MVP mvp) {
          this.mvp = mvp;
      }

      public MVP getMVP() {
          return mvp;
      }
  }
  1. 含有泛型的 方法 定义的格式
    格式:
    修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
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){}

常见数据结构:

栈、队列、数组、链表和红黑树。