一、在一個類中重寫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){}
常見數據結構：
棧、隊列、數組、鏈表和紅黑樹。