Java学习笔记——Object类、多态、final

Object类、多态

1. Object 类
2. 多态
3. 向上转型
4. 向下转型
5. final关键字

第一节： Object类

类Object是类层次结构的根类。每个类都使用Object作为超类。

1.1 equals()方法

指示其他某个对象是否与此对象“相等”。

/**
 * 学生类
 * @author wgy
 *
 */
public class Student extends Object{
    String stuNo;
    String stuName;
    int age;

    public void show() {
        System.out.println("学号:"+stuNo+" 姓名:"+stuName+" 年龄:"+age);
    }
}


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);

    }
}





    String s1 = new String("abc");
    String s2 = new String("abc");
    System.out.println(s1==s2);//new表示在堆中开辟新的空间存储数据，双等号比较的是new出来的两块对内存
    System.out.println(s1.equals(s2));//String类中重写了equals方法，比较的是两个字符串内容是否相等

==操作符与equals方法的区别：

1 == 比较基本类型比较的是数据，引用类型比较对象的引用（地址）

2 默认情况 Object中equals方法和==一样。

3 String类型重写了Object中的equals，所以String比较使用equals方法。

1.2 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());

1.3 getClass()方法

返回此Object的运行时类。通过某个对象通过反射获取类。

    Object obj = new Object();
    Class cls = obj.getClass();//通过反射获取到了Object类

1.4 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=张三
    }
}

第二节：多态

2.1 什么是多态

在生活中，一个事物有多种表现形态，对象的多种形态，方法的多样性，比如：某个音乐家有三个儿子，大儿子会唱美声，二儿子会唱流行，三儿子会摇滚。

程序中多态：同一个引用类型，使用不同的实例而执行不同操作，一句话理解：父类引用，子类对象。

2.2 案例引入:

需求：

1 编写一个宠物类 Pet 属性：id,name,health,love ;方法有print(),打印信息，要封装成员变量

2 两个子类狗狗和猫类，狗狗有品种(strain),猫类有爱好(hobby),重写父类print()方法

3 宠物饿了，需要主人给宠物喂食，狗狗吃狗粮、猫咪吃小鱼，吃完之后健康值狗狗增加3，猫咪增加5。

/*
宠物类
*/
package com.qf.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.qf.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.qf.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.qf.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.qf.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喂食,怎么办?

这样频繁修改代码，代码可扩展性、可维护性差。使用多态优化。

2.3 多态实现步骤：

1 编写父类、子类，子类重写父类方法

2 运行时，使用父类变量，子类的对象

/*
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();//调用子类重写的方法
}

2.4 多态使用形式:

1 使用父类作为方法形参实现多态
2 使用父类作为方法返回值实现多态

上机练习1：使用多态实现领养宠物，使用父类作为方法返回值

//主人类中添加领养方法
//领养
    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.qf.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("领养失败");
        }

    }
}

2.5 向上转型，向下转型

向上转型：将子类的对象赋值给父类变量，自动转换

Pet pet = new Dog();

String str = "abc";
Object obj = str;

注意：
1 <父类型> <引用变量名> = new <子类型>();
2 此时通过父类引用变量调用的方法是子类覆盖或父类的方法  ,编译时看父类，运行时看子类
3 此时通过父类引用变量无法调用子类特有的属性和方法

向下转型：将父类的变量赋值给子类变量，强制转换

上机练习1:实现主人与宠物玩耍功能

//猫咪捉迷藏  猫类中
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();
        }

    }



Object obj = new String("abc");
String str = (String)obj;
Pet pet=new Dog();  // Pet pet=new Cat();
Dog d=(Dog)pet;

注意：
1 <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
2 在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

2.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：最终的

在Java中声明类、属性和方法时，可以使用关键字final来修饰。

3.1 final修饰变量(成员变量或局部变量),则成为（符号）常量，只能赋值一次。重点

修饰成员变量时，定义时同时给出初始值，或在构造方法中赋值
修饰局部变量时，只能赋值一次

3.2 final修饰方法，则该方法不能被子类重写，能被继承

  final returnType methodName(paramList){

    …

  }

3.3 final修饰类，则类不能被继承

 final class finalClassName{

     …

 }

总结

1 Object 类，是所有的父类，默认继承Object

equals()方法：判断两个对象是否相等     this==obj;

    ==  ： 基本类型比较的数据，引用类型比较的地址。

    equals()  默认 和== 一样，

hashCode()方法：返回对象的地址

getClass()方法：返回类对象

toString()方法：返回对象的字符串形式， com.qf.day10.Person@123142;  重写

2 多态：同一个引用类型，使用不同的实例，执行不同的操作，父类引用，子类对象

实现多态的要素或条件：

1 子类继承父类，子类必须重写父类的方法

2 使用父类变量，子类对象 

多态表现形式:

1 使用父类作为方法的参数

2 使用父类作为方法的返回值

    向上转型和向下转型

向上转型：子类转成父类

向下转型：父类转成子类

instanceof： 判断变量是否是某种类型。

if(pet instanceof Dog){     

    Dog dog=(Dog)pet;

}

3 final 终止的

3.1 final 修饰变量   常量：只能赋值一次。

    修饰成员变量

    修饰局部变量

3.2 final 修饰方法  终止方法不能被重写，能被继承

3.3 final修饰类，终止类，不能被继承。

面试题

class A{  
    public String show(D obj){  
           return ("A and D");  
    }   
    public String show(A obj){  
           return ("A and A");  
    }   
}     
class B extends A{  
    public String show(B obj){  
           return ("B and B");  
    }  
    public String show(A obj){  
           return ("B and A");  
    }   
}    
class C extends B{}   
class D extends B{}

问题：以下输出结果是什么？

A a1 = new A();

A a2 = new B();

B b = new B();

C c = new C();

D d = new D();

System.out.println(a1.show(b)); A and A

System.out.println(a1.show(c)); A and A

System.out.println(a1.show(d)); A and D

System.out.println(a2.show(b)); B and A

System.out.println(a2.show(c)); B and A

System.out.println(a2.show(d)); A and D

System.out.println(b.show(b)); B and B

System.out.println(b.show(c)); B and B

System.out.println(b.show(d)); A and D

Java学习笔记——Object类、多态、final

Object类、多态

猜你喜欢