15_Java筑基之Object类、多态 一. Object类 Object类是类层次结构的根类,每个类都使用Object作为超类(父类). 1. equals()方法 指示其他某个对象是否与此对象“相等”. 示例代码; /** * 学生类 */
15_Java筑基之Object类、多态
一. Object类
Object类是类层次结构的根类,每个类都使用Object作为超类(父类).
1. equals()方法
指示其他某个对象是否与此对象“相等”.
示例代码;
/**
* 学生类
*/
public class Student extends Object{
String stuNo;
String stuName;
int age;
public void show() {
System.out.println("学号:"+stuNo+" 姓名:"+stuName+" 年龄:"+age);
}
@Override
public boolean equals(Object obj) {
if(obj==null) {
return false;
}
//强制类型转换
//注意:可能的NullPointerException
Student stu=(Student)obj;
//比较学号和姓名
if(this.stuNo.equals(stu.stuNo)&&this.name.equals(stu.name)){
return true;
}
return false;
}
}
public class Test {
public static void main(String[] args) {
Student zhangsan=new Student();
zhangsan.stuNo="bj1805";
zhangsan.stuName="xxx";
zhangsan.age=20;
Student lisi=new Student();
lisi.stuNo="bj1805";
lisi.stuName="xxx";
lisi.age=20;
boolean b=zhangsan.equals(lisi);
boolean b2=zhangsan==lisi;
System.out.println(b);
System.out.println(b2);
}
}
2. ==操作符与equals方法的区别:
1. ==: 如果是基本类型进行比较,则比较的是数值;
如果是引用类型进行比较,则比较的是对象的引用(地址);
2. 默认情况下,Object中的 equals和 == 一样;
3. String类型中重写了Object中的equals方法,所以String中的比较使用equals()方法.
3. hashCode()方法
返回该对象的哈希码值(理解为对象的地址),每一个对象的哈希码值唯一.
示例:
Object obj1 = new Object();
Object obj2 = new Object();
Object obj3 = obj2;
//obj2与obj3两个对象的哈希码值一样
System.out.println(obj1.hashCode()); System.out.println(obj2.hashCode()); System.out.println(obj3.hashCode());
3. getClass()方法
返回此Object的运行时类,获取某个类的类对象.
示例:
Object obj = new Object();
Class cls = obj.getClass();//通过反射获取到了Object类
5. toString()方法
返回该对象的字符串,可以在自定义类中重写toString方法,以实现是对象转成指定格式的字符串.
示例
public class Person{
String name;
public Person(String name){
this.name = name;
}
//重写toString方法
public String toString(){
return "name="+name;
}
}
public class DemoPerson{
public static void main(String[]args){
Person p = new Person("张三");
System.out.println(p);//输出结果为:name=张三
}
}二. 多态
1. 什么是多态
在生活中,一类事物有多种表现形态,对象的多种形态.
比如: 某个音乐家有三个儿子: 大儿子
会唱美声,二儿子会唱流行,三儿子唱摇滚.
程序中举例, 动物是父类: Dog会旺旺,Cat会喵喵,Pig会哼哼.
程序中的 多态: 同一个父类引用类型,使用不同的子类实例可以执行不同的操作.
2. 案例
需求:
- 编写一个宠物类 Pet, 属性: id,name,health,love;方法有print(),打印信息,要封装成员变量.
- 两个子类狗狗和猫类,狗狗有品种(strain),猫类有爱好(hobby),重写父类print()方法;
- 宠物饿了,需要主人给宠物喂食,狗狗吃狗粮、猫咪吃小鱼,吃完之后健康值狗狗增加3斤,猫咪增加5斤.
示例:
/*
宠物类
*/
package com.syc.day08;
public class Pet{
private int id; //id 宠物编号
private String name;// 宠物昵称
private int health;// 健康值
private int love;// 亲密度
public void setId(int id){
this.id=id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setHealth(int health){
this.health=health;
}
public int getHealth(){
return health;
}
public void setLove(int love){
this.love=love;
}
public int getLove(){
return love;
}
//方法
public void print(){
System.out.println("宠物id:"+this.id+",宠物昵称:"+this.name+",健康值:"+health+", 亲密度:"+love);
}
}
/*
dog类继承Pet类
*/
package com.syc.day08;
public class Dog extends Pet{
private String strain;
public void setStrain(String strain){
this.strain=strain;
}
public String getStrain(){
return strain;
}
public void print(){
int id=getId();
String name=getName();
int health=getHealth();
int love=getLove();
System.out.println("狗狗id:"+id+" 昵称:"+name+" 健康值:"+health+" 亲密度:"+love+"
品种:"+strain);
}
public void eat(){
String name=getName();
System.out.println(name+"大口吃狗粮...."); //增加健康值
int health=getHealth(); setHealth(health+3);
}
}
/*
猫类
*/
package com.syc.day08;
public class Cat extends Pet{
private String hobby;
public void setHobby(String hobby){
this.hobby=hobby;
}
public String getHobby(){
return hobby;
}
public void print(){
int id=getId();
String name=getName();
int health=getHealth();
int love=getLove();
System.out.println("猫咪id:"+id+" 昵称:"+name+" 健康值:"+health+" 亲密度:"+love+"
爱好:"+hobby);
}
public void eat(){
String name=getName(); System.out.println(name+"大口吃小鱼...."); //增加健康值
int health=getHealth(); setHealth(health+5);
}
}
/*
主人
*/
package com.syc.day08;
public class Master{
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
//喂食
public void feed(Dog d){
System.out.println(name+"要给狗狗喂食物...");
d.eat();
d.print();
}
public void feed(Cat c){
System.out.println(name+"要给猫咪喂食物...");
c.eat();
c.print();
}
}
package com.syc.day08;
public class TestPet{
public static void main(String[] args){
Dog afu=new Dog();
afu.setId(120);
afu.setName("阿福");
afu.setHealth(85);
afu.setLove(90);
afu.setStrain("拉布拉多");
afu.print();
Cat amao=new Cat();
amao.setId(119);
amao.setName("阿猫");
amao.setHealth(90);
amao.setLove(70);
amao.setHobby("爬树");
amao.print();
Master yuhuan=new Master();
yuhuan.setName("小美");
yuhuan.feed(afu);
yuhuan.feed(amao);
}
}
思考:
如果再领养XXX宠物,就需要给XXX喂食,怎么办?
这样频繁修改代码,代码可扩展性、可维护性差,考虑使用多态来优化代码.
3. 多态实现步骤
- 编写父类、子类,子类重写父类方法;
- 运行时使用父类变量,子类的对象(编译时看父类,运行时看子类).
示例:
/*
public void feed(Dog d){
System.out.println(name+"要给狗狗喂食物...");
d.eat();
d.print();
}
public void feed(Cat c){
System.out.println(name+"要给猫咪喂食物...");
c.eat();
c.print();
}*/
public void feed(Pet p){
String n=p.getName(); System.out.println(name+"要给"+n+"喂食物..."); p.eat();//调用子类重写的方法
p.print();//调用子类重写的方法
}
4. 多态使用形式
- 使用父类作为方法形参实现多态;
- 使用父类作为方法返回值实现多态.
上机练习:
使用多态实现领养宠物,使用父类作为方法返回值.
//主人类中添加领养方法
//领养
public Pet adopt(int type){
if(type==1){
Pet d=new Dog();
d.setHealth(80);
d.setLove(50);
return d;
}else if(type==2){
Pet c=new Cat();
c.setHealth(80);
c.setLove(50);
return c;
}else{
return null;
}
}
/*
领养宠物
*/
package com.syc.day08;
import java.util.Scanner;
public class TestPet2{
public static void main(String[] args){
System.out.println("欢迎来到xxx宠物商店.....");
System.out.println("请选择您要领养的宠物类型. 1 狗狗; 2 猫咪");
Scanner input=new Scanner(System.in);
int choice=input.nextInt();
Master yuhuan=new Master();
Pet p=yuhuan.adopt(choice);
if(p!=null){
System.out.println("领养成功");
p.print();
}else{
System.out.println("领养失败");
}
}
}
5. 向上转型、向下转型
向上转型:
将子类的对象赋值给父类变量,自动转换.
Pet pet1 = new Dog();
Pet pet2 = new Cat();
String str = "abc";
Object obj = str;
注意:
- <父类型> <引用变量名> = new <子类型>();
- 此时通过父类引用变量调用的方法是子类重写或父类的方法, 编译时看父类,运行时看子类;
- 此时通过父类引用变量无法调用子类特有的属性和方法.
向下转型:
将父类的变量赋值给子类变量,强制转换.
Object obj = new String("abc");
String str = (String)obj;
Pet pet=new Dog();
// Pet pet=new Cat();
Dog d=(Dog)pet; //向下转型注意:
- <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
- 在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换异常ClassCastException.
上机练习: 实现主人与宠物玩耍功能
//猫咪捉迷藏: 猫类中
public void hideAndSeek(){
String name=getName(); System.out.println(name+"玩捉迷藏...");
int health=getHealth();
setHealth(health-5);
}
//接球: 狗狗类
public void catchBall(){
String name=getName();
System.out.print(name+"玩接球游戏....");
int health=getHealth();
setHealth(health-3);
}
//和宠物玩耍
public void play(Pet pet){
if(pet instanceof Dog){
Dog d=(Dog)pet;
d.catchBall();
}else if(pet instanceof Cat){
Cat c=(Cat)pet;
c.hideAndSeek();
}
}
6. instanceof
对象向下转型时,存在一个问题:
若一个父类A的引用a,指向一个子类B的实例,将a赋值给另一个子类C引用时,会抛出java.lang.ClassCastException异常.
抛出异常后,程序将不能继续向下执行.为了避免这个异常的抛出,我们可以通过instanceof关键字,来判断引用指向的实例是否可以进行强制转换成某个子类对象.
示例:
已知Pet类有两个子类Dog和Cat:
public class Demo{
public static void main(String[]args){
Pet a = new Dog();
check(a);
}
//设计一个方法,判断一个动物是猫还是狗
public static void check(Pet a){
if(a instanceof Dog){
System.out.println("狗");
}else if(a instanceof Cat){
System.out.println("猫");
}
}
}三. final关键字
final: 最终的.
可以使用final关键字来修饰Java的类、属性和方法.
1. final修饰变量
final修饰成员变量或局部变量,则成为(符号)常量,只能赋值一次,用大写字母表示.
- 修饰成员变量时,定义时同时给出初始值,或在构造方法中赋值;
- 修饰局部变量时,只能赋值一次.
2. final修饰方法
则该方法不能被子类重写,但能被继承.
final returnType methodName(paramList){
...
}3. final修饰类,则类不能被继承.
final class finalClassName{
...
}四. 总结
1. Object类: 所有类的父类,默认继承Object.
2. equals()方法: 判断两个对象是否相等, this==obj;
==: 基本类型比较数据,引用类型比较地址/
equals() 默认 和 == 一样;
hashCode()方法: 返回对象的地址;
getClass()方法: 返回类对象;
toString()方法: 返回对象的字符串形式.
3. 多态: 同一个父类引用类型,使用不同的子类实例,执行不同的操作.
父类引用子类对象实现多态的要素或条件:
①. 子类继承父类,子类必须重写父类的方法;
②. 使用父类变量,子类对象.
多态表现形式:
①. 使用父类作为方法的参数;
②. 使用父类作为方法的返回值.
4. 向上转型和向下转型
向上转型: 子类转成父类;
向下转型: 父类转成子类,先向上转型,才能向下转型.
5. instanceof: 判断对象是否是某种类型.
if(pet instanceof Dog){
Dog dog=(Dog)pet;
}
6. final 终止的.
①. final修饰变量,常量:只能赋值一次;
②. 修饰成员变量;
③. 修饰局部变量.
④. final修饰方法,该方法属于终止方法,不能被重写,
但能被继承.
⑤. final修饰类,终止类,不能被继承.