Practice| 面向对象
实参与形参的传递机制
* 实参给形参赋值：
* 1、基本数据类型：
* 实参给形参的数据值，形参的修改和实参无关
* 2、引用数据类型
* 实参给形参的地址值，如果这个地址值修改“属性”会影响实参，但是你如果修改是地址值，和实参无关了
*/
class MianShiTi{ String str = new String("good idear"); //创建字符串对象； char[] ch = {'a','b','c','d'}; //创建数组； public static void main(String[] args){ MianShiTi m = new MianShiTi(); //创建一个对象； exchange(m.str, m.ch); //m.str没有变，m.ch的[1]变了 System.out.println(m.str); //good idear ,它们是两个无关的str System.out.println(m.ch); //a*cd String s = "bbbb"; StringBuffer b = new StringBuffer("bbbb"); change(s,b); //s不可变，s仍然"bbbb" //b的内容就从"bbbb" ---> "aaaa" System.out.println(s+b); //bbbbaaaa } public static void exchange(String str, char[] ch){ //两个都是引用数据类型String和char[]数组, str = "Hello World"; //字符串对象是不可变的，一旦修改str=xxx，就是产生新的对象，和原来的"实参"无关 System.out.println(str); //Hello World ch[1] = '*'; //数组元素是可变的，ch形参和上面的m.ch实参指向的是同一个数组,所以ch[1]修改，就是修改m.ch[1] System.out.println(ch); //a*cd } private static void change(String s, StringBuffer b){ //两个形参为String类型和 类 都是引用数据类型 s = "aaa"; b.setLength(0);//b的长度设置为0，相当于清空原来b中内容 b.append("aaaa");//append表示追加，又追加了aaaa } }
public class MainTest{ public static void test(String str){ str = "hello"; } public static void main(String[] args){ String str = "beijing"; test(str); System.out.println(str); //beijing } }
public class TestMethod { //i,str,j是形参 public static void change(int i, String str, Integer j, MyData my){ i++;//这里i无论怎么改，和实参无关 str += "尚硅谷";//字符串对象是不可变的，一旦改变，会产生新对象,str中的地址值变了 j++;//Integer对象是不可变的，一旦改变，会产生新对象,j中的地址值变了 //my.num = 20; my = new MyData(); my.num = 100; } public static void main(String[] args){ int a = 10; String s = "hello"; Integer b = 20; MyData m = new MyData(); change(a,s,b,m);//a,s,b,m是实参 System.out.println("a = " + a); //a=10 System.out.println("s = " + s); //s=hello System.out.println("b = " + b); //b=20 System.out.println("m.num = " + m.num); //n.num=100 } } class MyData{ int num = 10; }
class TEXT{ public int num; public String str; public TEXT(int num, String str){ this.num = num; this.str = str; } } public class Class4 { public static void f1(TEXT tIn, int intIn, Integer integerIn, String strIn){ tIn.num =200; tIn.str = "bcd"; intIn = 200; integerIn = 200; strIn = "bcd"; } public static void main(String[] args) { TEXT tIn = new TEXT(100, "abc"); //tIn引用数据类型,对象 int intIn = 100; Integer integerIn = 100; String strIn = "abc"; f1(tIn,intIn,integerIn,strIn); //引用数据类型 + 引用数据类型+int+Integer +String System.out.println(tIn.num + tIn.str + intIn + integerIn + strIn); } //200 bcd + 100 + 100 + abc } ===>>>200bcd100100abc
用数组来管理属性、对象等
/* (1)声明一个日期类型MyDate：有属性：年year,月month，日day （2）创建2个日期对象，分别赋值为：你的出生日期，你对象的出生日期，放到数组中 （3）遍历显示 */
public class TestMydate { public static void main(String[] args) { MyDate[] arr = new MyDate[2]; //创建长度为2的数组 arr[0] = new MyDate(); //引用数据类型需要给它赋值一个对象； arr[0].year = 1994; arr[0].month = 7; arr[0].day = 7; arr[1] = new MyDate(); arr[1].year = 1996; arr[1].month = 7 ; arr[1].day = 7; for(MyDate num : arr){ System.out.println(num.year + "-" + num.month + "-" + num.day); }
class TestTeacher{ public static void main(String[] args){ //用数组来管理属性，创建的对象,排序等 Teacher[] arr = new Teacher[5]; //声明一个一维数组，来存储5个Teacher的对象； arr[0] = new Teacher(); //arr[0]代表一个元素,是Teacher类型(引用数据类型),需要赋值为一个Teacher对象； arr[0].name = "kris"; arr[0].age = 18; arr[0].gender = '男'; arr[0].course = "java"; Teacher t2 = new Teacher(); t2.name = "alex"; t2.age = 11; t2.gender = '女'; t2.course = "Mysql"; arr[1] = t2; for(int i = 0;i < arr.length;i++){ //arr[i]是一个Teacher的对象 //Exception in thread "main" java.lang.NullPointerException空指针异常 //一旦报NullPointerException，说明对象是null //arr[i]是否是null？ //if(arr[i] != null){ System.out.println(arr[i].name + "\t" + arr[i].age + "\t" + arr[i].gender + "\t" +arr[i].course); //} } } } class Teacher{ String name; int age; char gender; String course; }
练习2 声明一个圆类Circle，有属性半径radius 声明一个测试类TestCircleArray， 在main方法中，创建一个Circle数组，长度为3，并创建三个Circle对象放到数组中， 遍历显示数组，显示每一个圆的半径、面积。 然后在对Circle数组进行排序，按照半径从小到大，再次遍历显示数组，显示每一个圆的半径、面积 */ class TestCircle2{ public static void main(String[] args){ Circle[] arr = new Circle[3]; //创建一个Circle数组，长度为3,默认值都为null //创建3个Circle对象放到数组中, 动态输入创建 java.util.Scanner input = new java.util.Scanner(System.in); for(int i = 0; i < arr.length;i++){ arr[i] = new Circle(); //先创建圆Circle的对象 System.out.print("请输入圆的半径:"); arr[i].radius = input.nextDouble(); System.out.println("半径" + arr[i].radius + "\t" + "面积" + Math.PI * arr[i].radius * arr[i].radius); } /* //静态输入 arr[0] = new Circle(); arr[1] = new Circle(); arr[2] = new Circle(); arr[0].radius = 2.0; arr[1].radius = 3.0; arr[2].radius = 1.0; */ //冒泡排序按从小到大顺序排,需要排arr.length-1次，大的就往后 //第一轮:i=1,j=0,1两次 //第二轮:i=2,j=1一次 for(int i = 1; i < arr.length;i++){ for(int j = 0;j < arr.length-i;j++){ //如果前面的圆的半径比较后面的圆的半径大，就交换两个圆 if(arr[j].radius > arr[j+1].radius){ //比较的是圆的半径,对象需要.半径属性 Circle temp = arr[j];//temp的类型和arr[j]和arr[j+1]一样，它俩是Circle arr[j] = arr[j+1]; arr[j+1] = temp; } } } for(int i = 0; i < arr.length;i++){ System.out.println(arr[i].radius); } } } class Circle{ double radius; }
练习3 （1）声明一个丈夫类型Husband，有属性：姓名，年龄，妻子，其中妻子是Wife类型 （2）声明一个妻子类型Wife，有属性：姓名，年龄，丈夫，其中丈夫是Husband类型 （3）创建一个丈夫对象，创建一个妻子对象，并显示他们的信息 */ class Test3{ public static void main(String[] args){ Husband hus = new Husband(); //hus丈夫对象； hus.name = "kris"; hus.age = 20; Wife wif = new Wife(); //wif妻子对象； wif.name = "xka"; wif.age = 19; hus.qi = wif; //qi为引用数据类型，必须给它赋值一个对象； wif.fu = hus; System.out.println("丈夫的信息:"+hus.name + "\t" + hus.age + "\t" + "妻子的信息:" + hus.qi.name + hus.qi.age); System.out.println("妻子的信息:" + wif.name + "\t" + wif.age + "\t" +"丈夫的信息:"+ wif.fu.name); } } class Husband{ String name; int age; Wife qi; } class Wife{ String name; int age; Husband fu; }
/* 2、练习2 （1）声明一个日期类型MyDate，包含年、月、日 （2）声明一个员工类，包含属性：姓名、薪资、生日，其中生日是MyDate类型 （3）声明一个测试类，在main方法中，声明一个数组，创建三个员工对象，并为属性赋值 （4）遍历显示员工信息，并且按照生日排序 （5）遍历显示员工信息，按照薪资排序 */ class Test2{ public static void main(String[] args){ Staff[] arr = new Staff[3]; //声明一个数组，创建员工对象，并为他们赋值； java.util.Scanner input = new java.util.Scanner(System.in); for(int i = 0; i < arr.length; i++){ arr[i] = new Staff(); System.out.print("请输入员工姓名:"); arr[i].name = input.next(); System.out.print("员工薪资:"); arr[i].salary = input.nextInt(); System.out.println("请输入员工生日"); arr[i].birthday = new MyDate(); //birthday为引用数据类型，必须给它赋值一个对象； System.out.print("年:"); arr[i].birthday.year = input.nextInt(); System.out.print("月:"); arr[i].birthday.month = input.nextInt(); System.out.print("日:"); arr[i].birthday.day = input.nextInt(); } System.out.println("姓名\t" + "薪资\t" + "生\t日"); //遍历显示员工信息;foreach循环 //for(元素的数据类型 元素名 : 数组名){} for(Staff num : arr){ //System.out.println(arr[i].name + "\t" + arr[i].salary + "\t" + arr[i].birthday.year + "-" + arr[i].birthday.month + "-" + arr[i].birthday.day); System.out.println(num.name + "\t" + num.salary + "\t" + num.birthday.year + "-" + num.birthday.month + "-" + num.birthday.day); } //冒泡排序；按员工生日排序;从小到大 for (int j = 1;j < arr.length;j++){ for(int i = 0;i < arr.length-i; i++){ if(arr[i].birthday.year > arr[i+1].birthday.year){ //先比较年year,大的年龄小 Staff temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; }else if(arr[i].birthday.year == arr[i+1].birthday.year){ if(arr[i].birthday.month > arr[i+1].birthday.month){ Staff temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; }else if(arr[i].birthday.month == arr[i+1].birthday.month){ if(arr[i].birthday.day > arr[i+1].birthday.day){ Staff temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } } } } //遍历排序之后的 System.out.println("排序之后的:"); System.out.println("姓名\t" + "薪资\t" + "生\t日"); for(int i = 0;i < arr.length; i++){ System.out.println(arr[i].name + "\t" + arr[i].salary + "\t" + arr[i].birthday.year + "-" + arr[i].birthday.month + "-" + arr[i].birthday.day); } } } class MyDate{ int year; int month; int day; } class Staff{ String name; double salary; MyDate birthday; }
类的继承，super 1、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号id，余额balance，年利率annualInterestRate；
包含的方法：访问器方法（getter和setter方法），返回月利率的方法getMonthlyInterest()，取款方法withdraw()，存款方法deposit()。 写一个测试类TestAccount：在用户程序中，创建一个账号为11223344、余额为20000、年利率4.5%的Account对象。使用withdraw方法提款30000元，并打印余额。 再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。 2、创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额，。在CheckAccount类中重写withdraw方法。 写一个用户程序测试CheckAccount类。在用户程序中，创建一个账号为11223344、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。 提示： （1）子类CheckAccount的构造方法需要将从父类继承的3个属性和子类自己的属性全部初始化。 （2）父类Account的属性balance被设置为private，但在子类CheckAccount的withdraw方法中需要修改它的值 最后思考：如果将父类Account的属性balance设置为protected，会怎么样？
package com.atguigu.variable; import com.atguigu.inherited.Account; public class CheckAccount extends Account { private double overdraft; public CheckAccount() { super(); } public CheckAccount(String id, double balance, double annualInterestRate, double overdraft) { super(id, balance, annualInterestRate); this.overdraft = overdraft; } public double getOverdraft() { return overdraft; } public void setOverdraft(double overdraft) { this.overdraft = overdraft; } /* public void withdraw(double money){ if(money < 0){ System.out.println("输入有误"); }if(money < getBalance()){ super.withdraw(money); //正常取,可以使用父类里边的方法withdraw }else{ //可以透支 if(money > getBalance() + overdraft){ System.out.println("超过可透支额度"); }else{ System.out.println("剩余可透支额度为:" + (overdraft -= money - getBalance())); //取后剩余的透支额度； //超过的额度(money - balance); setBalance(0); System.out.println("哎呀取完了，账户余额为:" + getBalance()); } } }*/ // 如果将父类Account的属性balance设置为protected,表在其他包的子类里边也可以使用 public void withdraw(double money){ if(money < 0){ System.out.println("您的输入有误"); }if(money < balance){ super.withdraw(money); }else{ if(money > balance + overdraft){ System.out.println("超过卡的取款额度"); }else{ System.out.println("可透支额度剩余:" + (overdraft -= money -balance)); setBalance(0); } } } }
package com.atguigu.variable; import com.atguigu.inherited.Account; public class TestAccount { public static void main(String[] args) { // TODO Auto-generated method stub Account a = new Account("11223344", 20000, 0.045); CheckAccount c = new CheckAccount("11223344", 20000, 0.056, 5000); c.withdraw(28000);//传参调用withdraw方法,它是没有返回值的。 //System.out.println(a.getBalance()); System.out.println(a.deposit(2000)); } }
多态转型
// A(show(D obj) show(A obj)) --> B(show(B obj) show(A obj) ) --> C // --> D //父类的变量可以存储子类的对象;但子类的变量不能存储父类的对象; D13Exam public class Exam1 { public static void main(String[] args) { A a1 = new A(); A a2 = new B(); //向上转型 a2对象可以调用B中重写父类的方法show(A obj)（重写的形参看是否符合 父类的引用变量接收子类的对象。） 和 父类中的方法。 B b = new B(); //本态引用，b可以调用它自己即子类B中的方法和继承父类的方法，只要参数符合就可以。 C c = new C(); D d = new D(); System.out.println("(1)" + a1.show(b));//调用A类中的哪个show方法，实参是子类B的对象b，b可以传给它的父类引用变量 A obj 多态参数 System.out.println("(2)" + a2.show(b));//B类的对象有几个show方法? D继承了B,B继承了A；
//（(1)show(D obj)（2）show(A obj)（3）show(B obj)），这里传的实参类型D类型d对象，选择show(D obj)执行
System.out.println("(3)" + b.show(c));//b类的对象有几个方法? b可以调用B和A中所有的方法，形参c 可以传给它的父类；多态参数。 // 这里传的实参类型是C类型的c对象，如果有形参C类型的，肯定首选，这里没有，看哪个合适，选择B类型 System.out.println("(4)" + b.show(d)); // 这里传的实参类型是D类型的d对象，有合适的， } } class A{ public String show(D obj){ return ("A and D"); } public String show(A obj){ //a1对象可以调用哪个传入B类型的show方法呢?B继承了A return "A and A"; } } class B extends A{ public String show(B obj){ return "B and B"; } @Override public String show(A obj){ //重写了父类show(A obj)的方法 return "B and A"; } } class C extends B{ } class D extends B{ ---》》 (1)A and A (2)B and A (3)B and B (4)A and D
多态针对方法的，属性没有多态，注意权限修饰符
public class Exam2 { public static void main(String[] args) { Base b = new Sub();//多态引用 System.out.println(b.x);//属性没有多态，按照编译时,b对象有1个x,是Base类中 //1 } } class Base{ int x = 1; } class Sub extends Base{ int x = 2; }
public class Child extends Father{ public String grade; public static void main(String[] args){ Father f = new Child(); //向上转型; System.out.println(f.name);//因为name是private的,所以编译错误; } } class Father{ private String name = "atguigu"; //private 只能在本类中使用。 int age = 0; }
this、继承时构造器的调用
public class Teacher extends Person{ private String name = "tom"; public Teacher(){ System.out.println("this is a teacher."); // super(); //编译错误，必须在子类构造器的首行 } public static void main(String[] args){ Teacher tea = new Teacher(); // System.out.println(this.name);//编译错误，this不能在static方法中使用的 } } class Person{ public Person(){ System.out.println("this is a Person."); } }
继承、构造器、super、方法的重写、多态引用
public class Test { public static void main(String[] args) { Base b1 = new Base();//本态引用，只看Base类，执行了Base类的无参构造，在无参构造中，调用了Base类的method(100) Base b2 = new Sub(); //执行的是子类重写的方法。 //多态引用，创建的是子类的对象，执行子类Sub的无参构造； //在子类的构造器中，一定会调用父类的构造器，默认调用的是父类的无参构造，会导致父类的无参构造被执行，因为父类的无参构造中调用method(100)， //它省略了“this.”，这个this是当前对象，当前正在创建的是子类Sub的对象，执行的是子类Sub重写的method(100) //接着在子类的构造器中，有super.method(70)，这个执行的是父类的method(70)，所以会打印 Base：70 } } class Base{ Base(){ method(100); //省略了this.method(100),this指当前对象 } public void method(int i){ System.out.println("base : " + i); // 1.base: 100; 3. base: 70 } } class Sub extends Base{ Sub(){ //省略了super(); super.method(70); //super.方法。子类重写了method方法，但是它又想调用父类的method方法了。 } public void method(int j){ //子类重写了method方法。 System.out.println("sub : " + j); //2. sub: 100 ; } } --->> base : 100 sub : 100 base : 70
类初始化和实例初始化
如果没有实例化（例如main方法中执行了某个函数），没有创建对象，只执行类的实例化，不进行实例的初始化。
public class Test { { System.out.println("b"); } static{ System.out.println("a"); } Test(){ System.out.println("c"); } public static String getOut(){ try { return "1"; } catch (Exception e) { return "2"; }finally{ return "3"; } } public static void main(String[] args) { System.out.println(getOut()); } } ===》》 a 3
* 类初始化和实例初始化 * （1）先类初始化 * A：如果父类没有初始化，会先初始化父类 * B：类的初始化执行的是<clinit>方法，它由两部分组成： * (a)静态变量的显式赋值语句 (b)静态代码块的语句,(a)(b)谁在上谁先执行 * * （2）实例初始化 * A：创建子类对象时，也会导致父类的实例初始化方法执行 * B：每一个构造器都会有对应的实例初始化方法 * C：每一个实例初始化有三部分组成： * (a)非静态变量的显示初始化代码(b)非静态代码块的语句(c)构造器； (a)(b)谁在上谁先执行，构造器后执行
子类继承父类，子类和父类都有无参构造和有参构造；子类在进行创建对象时，不管子类创建对象时候它有没有传参，
子类都是默认调用父类的无参构造，如果传参了，那么参数传给的是子类的有参构造。
练习：
/* * 实例初始化的过程： * 1、父类的实例初始化<init>() * 因为子类默认调用父类的无参构造，那么选择父类的<init>()，而不是<init>(String name) * System.out.print("1"); * 2、子类的实例初始化 * System.out.print("3"); * father = new People(name +" F"); //创建了父类的对象 * 这句代码会导致，父类的有参构造，即父类的<init>(String name)会执行 * System.out.print("2"); * */ public class TestChild { public static void main(String[] args) { new Child("mike");// } } class People{ private String name; public People(){ System.out.print("1"); } public People(String name){ System.out.print("2"); this.name = name; System.out.println(name); } } class Child extends People{ People father; //子类的构造器中，默认会调用父类的无参构造 public Child(String name){ System.out.print("3"); father = new People(name +" F"); } public Child(){ System.out.print("4"); } } 打印：--->> 132mike F
父类初始化< clinit >---->>>子类初始化< clinit >--->> 父类的实例初始化< init > --->>子类的实例初始化< init >；一开始都是静态的先初始化。
（1.先父类初始化；2.子类初始化； 3.父类实例初始化； 4.子类实例初始化。）
练习：
* 1、实例初始化，为属性赋值的过程 * （1）父类的实例初始化方法<init>() * x = 10;//父类中的x * this.print();//要考虑方法的重写，因为在创建子类Son的对象，所以这个this是子类的对象 * System.out.println("Son.x = " + x);// Son.x = 0 ，这个是子类中的x * x = 20;//父类中的x * （2）子类的实例初始化方法<init>() * x = 30;//子类的x * this.print(); * System.out.println("Son.x = " + x);//子类中的x，就近原则 Son.x = 30 x = 40;//子类的x * * 2、属性没有多态 * System.out.println(f.x);//按照编译时类型，父类的x */ public class Exam3 { public static void main(String[] args) { Father f = new Son(); System.out.println(f.x);//先初始化最后执行这个,按照编译时类型，父类的x;属性没有多态。 } } class Father{ int x = 10; //父类的实例初始化; 显式赋值; public Father(){ //构造器; this.print();//this指的是当前对象,即Son对象,它重写了print方法,所以调用的是子类的print方法 x = 20; } public void print(){ System.out.println("Father.x = " + x); } } class Son extends Father{ int x = 30; public Son(){ this.print(); x = 40; } public void print(){ //执行这个方法的时候x还没赋值,它的默认值为0 System.out.println("Son.x = " + x);//子类中的x，就近原则 } }
----->>> 打印：
Son.x = 0
Son.x = 30
20
* 实例初始化的问题： * 1、创建父类对象时 * 执行父类的实例初始化方法<init> * System.out.println("father create"); * 2、创建子类对象时 * 执行父类的实例初始化方法<init> * System.out.println("father create"); * 执行子类的实例初始化方法<init> * System.out.println("child create"); */ public class Child extends Father{ public Child(){ System.out.println("child create"); } public static void main(String[] args) { Father f = new Father(); //先执行这一句，父类 f 的实例初始化 Child c = new Child(); //再执行子类的实例初始化 --> 它会导致父类的先初始化再初始化子类 } } public class Father { public Father(){ System.out.println("father create"); } } 打印： father create father create child create
* 1、创建对象 * 实例初始化 * （1）父类的实例初始化<init> * name = "father"; //这个name是父类的name * （2）子类的实例初始化<init> * name = "test"; //这个name是子类的name * * 2、对象调用方法 * 调用的是子类从父类继承的getName() * * 子类的对象有两个name, this.name，如果在子类中，this.name就是子类的，如果在父类中，this.name就是父类的 */ public class Test extends Father{ private String name = "test"; public static void main(String[] args) { Test test = new Test(); System.out.println(test.getName()); } } public class Father { private String name = "father"; public String getName() { return name;//这里就近原则，找的是父类的name } }
* 1、创建对象 * Other o = new Other(); o.i = 0; * 2、调用了addOne(o) * o.i++; o.i = 1; * 3、final修饰的变量不可变问题 * 是修饰什么变量，局部变量还是成员变量？ */ public class Something { public static void main(String[] args) { Other o = new Other(); new Something().addOne(o); //对象.方法 System.out.println(o.i); } //final修饰的变量不可变； 这里是o变量不可变 public void addOne(final Other o){ // o = new Other();//o的变量值不可变 o.i++; } } class Other{ public int i; }
* 1、static * 本类中，静态的方法，代码块可以访问静态的属性 * 2、类初始化 * main方法所在的类必须先初始化，然后才能执行main方法 * * Myclass2类的初始化<clinit>() * static{ int x = 5; x--;//这里的x是局部变量的x，不是类变量的x x = 4 } static{ x--;//这里的x是类变量的x x = -1 } * 在执行main * System.out.println("x = " + x);//类变量的x x=-1 z--;//类变量的z z= -1 myMethod(); y = z++ + ++z;//都是类变量 (1)先把z=-1的值load到操作数栈(2)z++,z=0(3)++z,z=1(4)再把z=1的值load到操作数栈(5)计算-1+1(6)赋值给y=0 System.out.println("result: " + (z + y + ++z)); (1)先把z=1的值load到操作数栈（2）再把y=0的值load到操作数栈 （3）++z,z=2(4)先把z=2的值load到操作数栈（5）执行1+0+2（6）打印3 * 2、局部变量与成员变量（类变量、实例变量） * 3、自增问题 * */ public class Myclass2 { static int x,y,z; static{ int x = 5; //局部变量 x--; } static{ x--; //这里的x是类变量 } public static void main(String[] args) { System.out.println("x = " + x);//类变量的x x=-1 z--;//类变量的z z= -1 myMethod(); System.out.println("result: " + (z + y + ++z)); } public static void myMethod(){ y = z++ + ++z; } } x = -1 result: 3
==和equals()的区别 ==：如果是基本数据类型，比较的是数据值 如果是引用数据类型，比较的是对象的地址值 equals()：必须是对象才能调用，它是Object类中声明的，如果子类没有重写，那么它的效果和==是一样的，也是比较对象的地址。如果子类重写了，
那么就按照重写的规则进行比较，例如String类型重写了equals，比较的是字符串的字符内容。
重写一个类的equals方法需要主意什么？
（1）必须和hashCode()方法一起重写，凡是参与equals比较的属性，一定要参与hashCode值的计算。 （2）equals的重写要求遵循几个原则： equals 方法在非空对象引用上实现相等关系： • 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。 • 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。 • 传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。 • 一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。 • 对于任何非空引用值 x，x.equals(null) 都应返回 false。
