First, overriding the ToString method in a class
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.) {this.age = age;} @Overridepublic String toString () {//{name=name, age= Age}return "{" + "name=" + getName () + "age=" + getage () + "}";} Override Equals @Overridepublic Boolean equals (Object obj) {//To determine if the memory address is the same if (this = = obj) { return true;} Determines whether the object passed in obj is null if the type of obj is the same as the current type if (obj = = NULL | | This.getclass ()! = Obj.getclass ()) { return false;} Strong-turn type person p = (person) obj//determines whether the value of the passed Obj object is empty and the value is the same, return this.age = = P.age && Objects. Equa LS (this.name,p.name)//judgment value is the same}
Ii. definition and use of generics
The flexibility to apply data types to different classes, methods, and interfaces to pass data types as parameters
1. Defining and using classes that contain generics
define the format:
modifier class class name < variable >{} that represents the generic type
Example:
//generics use defined positions in the class after the class name
Public class Person <e>{
//generics as parameters in parentheses
Public Boolean Add (E e) {
}
// with generic method in alternate method type
Public E Get (int index) {
}
}
2. Distance definition generic class
Public class Mygenericclass<mvp> {
//There is no MVP type, here represents an unknown type of data to pass what is what type in the future
Private MVP MVP;
Public void SETMVP (MVP MVP) {
THIS.MVP = MVP;
}
Public MVP GETMVP () {
return MVP;
}
}
3. the format of a method definition that contains a generic type
format:
modifier < variable representing generic type > Return value type method name (parameter) {}
Public class MyGenericMethod {
Public <MVP> void Show (MVP MVP) {
System.out.println (Mvp.getclass ());
}
Public <MVP> MVP Show2 (MVP MVP) {
return MVP;
}
}
4. Interface with generic type
define the format:
modifier Interface Interface name < variable >{} that represents a generic type
public interface mygenericinterface<e>{
public abstract void Add (e e);
}
For example:
public class MyImp1 implements mygenericinterface<string> {
@Override
public void Add (String e) {
Omitted...
}
?
@Override
Public String Gete () {
return null;
}
}
2. The type of the generic is always indeterminate until the type of the generic is determined when the object is created
Public class Myimp2<e> implements mygenericinterface<e> {
@Override
Public void Add (E e) {
Omitted...
}
@Override
Public E Gete () {
return null;
}
}
/**
Determining generics
*/
Public class Genericinterface {
Public static void Main (string[] args) {
myimp2<string> my = new myimp2<string> ();
my.add ("AA");
}
}
The wildcard character of a generic type
when a generic class or interface is used, the type of the generic is not deterministic and can be represented by a wildcard character <?>. But once a generic wildcard is used,
Only the generic method of the object class can be used, and its own methods cannot be used in the collection.
1. Wildcard characters Basic use
Generic wildcard: Do not know when to use what type to accept, at this time can be used? Indicates an unknown wildcard character
Example:
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) {}
//? Delegates can receive any type
notes:tips: generic no inheritance relationship collection<object> list = NE W arraylist<string> (); this is wrong; 2. Wildcard advanced when you set generics before using----restricted generics, you can actually set them arbitrarily, as long as the class is set. In Java generics, however, you can develop a generic upper bound for the on-line and lower-bound generics: Format: type name <? Extends class > object name meaning: You can only receive the lower bound of the type and its subclass generics: Format: Name of type <? Super Class > object name meaning: You can only receive the type and its parent class type
Example: public static void Main (string[] args) {Collection<i Ntger> 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);//Error GetElement (LIST3); GetElement (LIST4);//Error GetElement2 (LIST1);//Error GetElement2 (LIST2);//Error GetElement2 (LIST3); GetElement2 (LIST4); }//The upper limit of generics: generic at this time, must be a number type or a subclass of number type public static V OID GetElement1 (collection<? extendsNumber> coll) {}//The lower limit of generics: generic at this time, must be the number type or the parent of number type public static void G EtElement2 (collection<? Super Number> Coll) {}
Common Data Structures:
Stacks, queues, arrays, linked lists, and red-black trees.
Java overrides the use of ToString and generics