Java重写toString和泛型的使用

一、在一个类中重写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){}

常见数据结构：

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

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有