他们两个都有什么作用啊，什么时候用==，什么时候用equals呀？

==一般用来判断基本数据类型，equals一般用来判断对象，

==判断两个对象在内存中是否为同一个对象。

而每个类都可以通过重写equals方法实现它特有的比较方法

你想想，equals();是个方法，对象调用方法，所以比较对象是否相等，==是运算符，基本数据类型参加运算，所以比较基本类型数据是否相等
instanceof是用来判断一个对象是不是属于某一类比如:stu instanceof Student 这句就是判断一下对象stu是不是学生

==比较的是两个对象的引用（即内存地址）是否相等，
equals()比较的是两个对象的值（即内存地址里存放的值）是否相等.
instance of是判断一个object是不是属于某个类的

instance of，按我理解就是一个操作符号，他的作用是判断一个对象是不是那个类,结果为 boolean类型
格式： 对象名 instanceof 类名，当然继承，不算、
例子： p1 instanceof  people

equals 则是判断两个对象是否引用的是同一地址，其结果也为布尔型
格式： 对象1.equals(对象2)
例子：
    people p1 = new people();
    people p2 = new people();
    people p3 =  p1;
    p1.equals(p2);    //false
    p1.equals(p3);    //true
就算，people()中，有成员变量，p1和p3改变了值，还为true，要注意

当然匿名对象不算

equals比较他们两个的内容是否相等，不考虑是不是内存对象一样！！
instanceof是比较在内存里是不是一个对象！！！

JAVA 中的 "==" 和 "equals" ,"InstanceOf"

"==" 和 "equals" 是在java引用变量比较中用来比较两个引用变量是否都指向同一个对象的.但是如果用"equals" 做比较时, 如果引用变量的的引用类型和变量值如果都相同的话,那结果为真.
InstanceOf 用来判断一个引用类型所引用的对象是否为一个类的实例变量.

Object中的equals方法准则:
当参数obj引用的对象与当前类的对象为同一个对象时,就放回true,否则为false.
public boolean equals(Object obj){
    if(this==obj){
       return true;
    }else{
       return false;
    }
}

举例:
package p;

public class Eq {
public static void main(String[] args){
  //Eq eq = new Eq();
  String name = new String("Tom");
  if(name == "Tom"){
   System.out.println("Hello,Tom");
  }else{
   System.out.println("Sorry,I don't know you");
  }
  
  if(name.equals("Tom")){
   System.out.println("Hello,Tom");
  }else{
   System.out.println("Sorry,I don't know you");
  }
  
  Boolean b1 = new Boolean(true);
  Boolean b2 = new Boolean(true);
  if(b1 == b2){
   if(b1.equals(b2)){
    System.out.println("a");
   }else{
    System.out.println("b");
   }
  }else{
   if(b1.equals(b2)){
    System.out.println("c");
   }else{
    System.out.println("d");
   }
  }
  //结果为 c
  
  Boolean b3 = new Boolean(true);
  Object obj = (Object)b3;
  if(b3 == obj){
   if(b3.equals(obj)){
    System.out.println("aa");
   }else{
    System.out.println("bb");
   }
  }else{
   if(b3.equals(obj)){
    System.out.println("cc");
   }else{
    System.out.println("dd");
   }
  }
  //结果为 aa
  
  String a = "hello";
  String b = new String(a);
  
  char[] c ={'h','e','l','l','o'};
  System.out.println(a=="hello");
  System.out.println(a==b);
  System.out.println(a.equals(b));
  System.out.println(a.equals(c));
}
}



例子2:        (InstanceOf)

package p;

public class Animal extends Creature{
String name = "abc";
public Animal(){}
public Animal(String name){
  this.name = name;
}
public boolean equals(Object obj){
  if(this == obj){
   return true;
  }
  if(!(obj instanceof Animal)){
   return false;
  }
  final Animal ani = (Animal)obj;
  if(this.name.equals(ani.name)){
   return true;
  }else{
   return false;
  }
}

public static void main(String[] args){
  Dog dog = new Dog();
  Cat cat = new Cat();
  Creature creature = dog;
  Animal animal = new Cat();
  Animal animal1 = new Animal("abc");
  Animal animal2 = new Animal("abc");
  System.out.println(dog == creature);
  System.out.println(dog == animal);
  System.out.println(animal1.equals(animal2));
  //如果不覆盖 equals 方法 ,则 animal1.equals(animal2) 结果为false
  
}
}

==：如果是基本类型就是直接比较值，如果是变量比较地址。 一般在基本类型比较时用

equals()：比较的是两个对象的值（即内存地址里存放的值）是否相等.

在比较字符串类型时用equals。String类已经重写了equals，所以可以比较。

比较自己写的类的对象时，需要重写equals方法。

instanceOf是判断属于操作，equals是判断相等操作。两者之间有明显的区别。
instanceOf只能简单的判断数据，equals可以感觉具体具体情况复写equals方法，改变默认判断条件。