从现实生活的角度出发，在生活中，如果有"两个人"，名字和身份证号都相同 那么这"两个人"肯定是同一个人，所以我们应该让这两个人比较为true ==属于运算符 我们无法改变比较规则 但是 equals可以 所以我们就重写equals
package com.edu.test1;
public class Person {
private String name;
private String idCard;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public Person(String name, String idCard) {
this.name = name;
this.idCard = idCard;
}
public Person() {
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
Person p =(Person)obj; // 强制类型转换
if(this.getName().equals(p.getName()) && this.getIdCard().equals(p.getIdCard())) {
return true;
}
return false;
}
public static void main(String[] args) {
Person p1 = new Person("赵四", "56121578432132656323231");
Person p2 = new Person("赵四", "5612157843213265632323");
// 从现实生活的角度出发，在生活中，如果有"两个人"，名字和身份证号都相同
// 那么这"两个人"肯定是同一个人，所以我们应该让这两个人比较为true
// ==属于运算符 我们无法改变比较规则 但是 equals可以 所以我们就重写equals
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));
Person p3 = new Person("广坤", "5623789756345987231");
Person p4 = new Person("广坤", "5623789756345987231");
System.out.println(p3.equals(p4));
}
}
2. 重写hashCode方法
hashCode 是根据对象的地址等信息使用hash算法所计算出来的一个十进制的数值
杂凑算法的特点：正向是快速的 不可逆的
实际开发中，我们重写了equals，通常都要重写hashCode方法
回顾，本身equals方法的作用是比较什么的呢？本身比较地址
地址相同的"两个对象",hash值肯定是相同，但是目前我们重写了equals方法
导致目前 equals方法按照内容(名字和身份证号)来比较，内容相同则比较为true
但是hashCode却不相同，我们应该继续保持这种规则：
equals比较为true，hash值必须相同
在一些散列数据结构中，是以两个对象equals比较为true，并且hashCode相同来认为是重复的对象
不允许重复添加
package com.edu.test2;
public class Person {
private String name;
private String idCard;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public Person(String name, String idCard) {
this.name = name;
this.idCard = idCard;
}
public Person() {
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
Person p =(Person)obj; // 强制类型转换
if(this.getName().equals(p.getName()) && this.getIdCard().equals(p.getIdCard())) {
return true;
}
return false;
}
public int hashCode() {
int prime = 31; // 权重 (决定性因素)
int result = 1;
result = prime * result + (this.getName() == null ? 0 : this.getName().hashCode());
result = prime * result + (this.getIdCard() == null ? 0 : this.getIdCard().hashCode());
return result;
}
public static void main(String[] args) {
Person p1 = new Person("赵四","2356457845129");
Person p2 = new Person("赵四","235645784512");
System.out.println(p1.equals(p2));
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
}
}
3. 为什么使用31计算hash值(了解)
为什么使用31作为计算权重 ？
不是必须使用31的 使用31的原因如下：
31是一个特殊的质数 任何数乘以31 等于这个数 左移5位 减去这个数本身
总结：使用31计算hash值效率比较高
左移几位表示乘以2的几次方 右移几位表示除以2的几次方
n * 31 = (n << 5) - n
package com.edu.test2;
public class TestPrime {
public static void main(String[] args) {
int num =3;
System.out.println(num * 31);
System.out.println((3 << 5) -3);
}
}
4. 使用getClass方法
getClass方法用于返回当前对象的类型 返回值为Class类型
使用这个方法可以获取当前对象的信息
package com.edu.test3;
public class Test1 {
public static void main(String[] args) {
Test1 test1 = new Test1();
System.out.println(test1.getClass().getName());
}
}
5. 多态
多态：多种形态
生活中的多态：指同一个事物/动作，因为环境的不同，产生不同的效果
程序中的多态：指同一段代码，因为实际参数或者返回值的不同，产生完全不同的效果
多态的两种表现形式：
1.父类作为形参，子类作为实参。
父类引用指向子类对象( Pet pet = new Dog(); double a = 20;)属于自动向上转型,此时可以调用的是子类重写父
类的方法和继承自父类的方法 ,不能访问子类独有的方法
2.父类作为返回值，实际返回值为子类类型
package com.edu.test5;
public class Pet {
private String name;
private int health;
private int love;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
public void print() {
System.out.println("宠物的名字是：" + name + "，健康值是：" + health + "，爱心值是：" + love );
}
public void cure() {
System.out.println("给宠物看病");
}
public Pet() {
}
public Pet(String name, int health, int love) {
this.name = name;
this.health = health;
this.love = love;
}
}
package com.edu.test5;
public class Cat extends Pet{
private String furColor;
public String getFurColor() {
return furColor;
}
public void setFurColor(String furColor) {
this.furColor = furColor;
}
public Cat() {
}
public Cat(String name, int health, int love,String furColor) {
super(name, health, love);
this.furColor = furColor;
}
public void cure() {
System.out.println("猫咪看病，打针，吃小鱼");
this.setHealth(100);
}
}
package com.edu.test5;
public class Dog extends Pet{
private String strain;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public Dog() {
}
public Dog(String strain,String name,int health,int love) {
super(name, health, love);
this.strain = strain;
}
public void cure() {
super.cure();
System.out.println("狗狗看病，吃药打针，吃骨头，健康值恢复");
this.setHealth(100);
this.setLove(100);
}
}
package com.edu.test5;
public class Penguin extends Pet{
private String sex;
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Penguin() {}
public Penguin(String sex,String name,int health,int love) {
super(name, health, love);
this.sex = sex;
}
public void cure() {
System.out.println("企鹅看病，疗养，输液，吃小鱼，健康值恢复");
this.setHealth(100);
this.setLove(100);
}
}
package com.edu.test5;
public class TestPet {
public static void main(String[] args) {
Master zhaosi = new Master();
zhaosi.setName("赵四");
Dog dog = new Dog("金毛", "大黄", 65, 65);
Penguin penguin = new Penguin("雄", "小黑", 70, 65);
Cat cat = new Cat("小绿", 20, 20, "红色");
zhaosi.toHospital(dog); // 向上转型 子类类型自动提升父类类型
zhaosi.toHospital(penguin);
zhaosi.toHospital(cat);
System.out.println(dog.getHealth());
System.out.println(penguin.getHealth());
}
}
6.案例
package com.edu.test6;
public class Computer {
public void study() {
System.out.println("敲代码学习");
}
}
class BookComputer extends Computer{
@Override
public void study() {
super.study();
System.out.println("笔记本敲代码很方便");
}
}
class PadComputer extends Computer{
@Override
public void study() {
super.study();
System.out.println("平板电脑敲代码不舒服");
}
}
class DesktopComputer extends Computer{
@Override
public void study() {
super.study();
System.out.println("台式机显示器很大，敲代码很刺激");
}
}
class Student{
public void gotoQianFeng(Computer computer) {
computer.study();
}
}
package com.qfedu.test6;
public class Test {
public static void main(String[] args) {
Student zhaosi = new Student();
BookComputer huawei =new BookComputer();
DesktopComputer hp = new DesktopComputer();
PadComputer lenovo =new PadComputer();
zhaosi.gotoQianFeng(huawei);
}
}
