Java面向对象详解（5）继承的作用和特点，instanceof操作符，方法的重写，final关键字，组合，Object类和toString的重写，equals ,super关键字

最新推荐文章于 2024-05-03 15:25:14 发布

古倪啷虚宇

最新推荐文章于 2024-05-03 15:25:14 发布

阅读量338

点赞数

本文链接：https://blog.csdn.net/m0_58783923/article/details/119871808

版权

2：Object类和重写toString方法

2.1.当其他的类没有调用extends是那么该类的父类就是java.lang.Object

1：继承

1.1继承的两个作用

1.代码复用，便于类的扩展

2.便于建模

1.2 继承的实现和继承的特点

1.通过extends关键字来继承

2.子类继承父类的属性和方法（但不见得可以直接访问，如父类的私有属性和方法），但是不继承构造方法

3.父类也成为基类，超类，子类也成为派生类

4.如果调用一个类的时候，没有使用extends，呢么该类的父类是:java.lang.Object

5.java中只有单继承，没有多继承，接口有多继承

1.3：instanceof操作符

instanceof 是二元操作符，左边是对象，右边是类，当左边的对象是右边的类或者子类所创建的对象时返回true,反之返回false

package com.gnlxy.test;

public class TestExtends {
    int id;
    String name;
    void rest(){
        System.out.println("休息一会");
    }

    public static void main(String[] args) {
        Test t=new Test(110,"古倪啷虚宇","卢鑫宇");
        //instanceof 操作符
        System.out.println(t instanceof Test);
        System.out.println(t instanceof TestExtends);
        System.out.println(t instanceof Object);

    }
}
//Test是TestExtends的子类
class Test extends TestExtends{
    String friend;
    void play(){
        System.out.println("打游戏"+this.name);
    }
    Test(int id,String name,String friend){
        this.id=id;
        this.name=name;
        this.friend=friend;
    }
}

1.4方法的重写

子类通过重写父类的方法，可以用自身的行为来替换父类的行为，方法的重写是实现多态的必要条件

方法的重写需要符合下面三个条件：

1.“==” 方法名，形参列表必须相同

2.“<=” 返回类型和声明异常类型，必须小于等于父类的类型

3.“>=” 访问权限，子类大于等于父类

package com.gnlxy.test;

public class Vehicle {
    public void run(){
        System.out.println("刺溜，刺溜~~~~");
    }
    public void stop(){
        System.out.println("呲呲呲呲呲呲~~~~");
    }

    public static void main(String[] args) {
        Vehicle v=new Vehicle();
        Train t=new Train();
        Cycle c=new Cycle();
        v.run();
        v.stop();
        t.run();
        t.stop();
        c.run();
        c.stop();

    }
}
class Train extends Vehicle {
    //方法的重写override
    public void run(){
        System.out.println("呜呜呜五~~~");
    }
    public void stop(){
        System.out.println("裤子擦，裤子擦~~~");
    }
    public Train test(){
        return new Train();
    }
}
class Cycle extends  Train {
    //这里返回值比父类大，所以不可以
//    public Vehicle test(){
//        return new Vehicle();
//
//    }
    //这里返回值正好等于父类Train,可以
//    public Train test(){
//        return new Train();
//    }
    //这里返回值小于父类Train,可以
    public Cycle test() {
        return new Cycle();

    }
}

1.5：final关键字

被final所修饰的东西都是最终形态，修饰变量，变量不能被修改，修饰方法，方法不能被重写，修饰类，类不能被继承

package com.gnlxy.test;

public class TestFinal {
    String name;
    public final void shout(){
        System.out.println("name:"+name);
    }

    public static void main(String[] args) {
        int id=20;
        id=30;
        //被final修饰无法被改变
//        final int idd=20;
//        idd=30;
    }
}
final class Test2 extends TestFinal{
    //shout()被final修饰无法被重写
    public void shout(){
        System.out.println("name"+name);

    }

}
class Test3 extends Test2{//Test2被final修饰无法被继承
    
}

1.6：组合

组合的核心就是将父类的对象作为子类的属性，子类通过调用该属性来获得父类的方法和属性

看下面的代码

package com.gnlxy.test;

public class TestZuhe {
    int id;
    String name;
    public void test(){
        System.out.println("啊哈哈哈");
    }

    public static void main(String[] args) {
        Dog d1=new Dog(101,"小黑",88);
        d1.test2();
    }
}
class Dog{
    int heavy;
    //将要继承的类的对象作为属性即可获得其所有的属性和方法
    TestZuhe zuhe=new TestZuhe();
    public void test2(){
        System.out.println("汪汪汪");
    }
    //构造器，初始化对象
    public Dog(int id,String name,int heavy){
        this.zuhe.id=id;
        this.zuhe.name=name;
        this.heavy=heavy;
        System.out.println("id="+id+" name: "+name+" heavy;"+heavy);
    }
}

2：Object类和重写toString方法

2.1.当其他的类没有调用extends是那么该类的父类就是java.lang.Object

2.2.toString方法

Object类中定义了public String toString()方法，其返回值是String类型源码为

根据如上源码得知，默认会返回“类名+@+16 进制的 hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的 toString()方法，也就是说下面两行代码意义相同

2.3重写toString方法

package com.gnlxy.test;

import java.sql.SQLOutput;

public class TestToString {
    int id;
    String name;
    int heavy;
    //重写的toString方法
    public String toString(){
       return "name:"+name+" id:"+id+" heavy:"+heavy;
    }

    public TestToString(int id,String name,int heavy) {
        this.id = id;
        this.name=name;
        this.heavy=heavy;
    }

    public static void main(String[] args) {
        TestToString t1=new TestToString(101,"古倪啷虚宇",44);
        System.out.println(t1);
    }
}

3：equals和super关键字

3.1：equals和”==“的区别

==比较的是两个对象的地址，equals可以自己设置比较什么，看下面的代码

package com.gnlxy.test;

import java.util.Objects;

public class TestEquals {
    int id;
    String name;
    String friend;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TestEquals that = (TestEquals) o;
        return id == that.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    public static void main(String[] args) {
        TestEquals t1=new TestEquals();
        TestEquals t2=new TestEquals();
        System.out.println(t1.toString());
        System.out.println(t2);//即使不写toString 也会自动调用
        System.out.println(t1==t2);//两个对象，地址不同
        System.out.println(t1.equals(t2));//上面重写equals的时候只比较id的值
        //因为没有赋值，所以都是默认值0，相等就是true
    }

3.2： super关键字：

1.所有的构造方法中第一句总是super(...)/this()你不加编译器帮你加,他会调用父类的无参构造器，也就是说先建好的是父类的对象

package com.gnlxy.test;

public class TestSuper {
    public TestSuper(){
        System.out.println("创建TestSuper");
    }

    public static void main(String[] args) {
        System.out.println("创建Child2对象");
        Child2 c1=new Child2();
    }
}
class Child2 extends TestSuper{
    public Child2(){
        System.out.println("创建Child");
    }

}

2.在子类中，super是对父类对象的直接引用

package com.gnlxy.test;

import java.util.Objects;

public class TestEquals {
    int id;
    String name;
    String friend;
public void test(){
    id=100;
    System.out.println("id="+id);
}
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TestEquals that = (TestEquals) o;
        return id == that.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    public static void main(String[] args) {
//        TestEquals t1=new TestEquals();
//        TestEquals t2=new TestEquals();
//        System.out.println(t1.toString());
//        System.out.println(t2);//即使不写toString 也会自动调用
//        System.out.println(t1==t2);//两个对象，地址不同
//        System.out.println(t1.equals(t2));//上面重写equals的时候只比较id的值
//        //因为没有赋值，所以都是默认值0，相等就是true
        Child c1=new Child();
        c1.test();

    }
}
class Child extends TestEquals{

    public void test(){
        super.test();//调用父类的方法
        System.out.println(super.id);//调用父类的属性
        id=200;//重写了父类的属性
        System.out.println("id="+id);
        System.out.println(id);
    }
}

古倪啷虚宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象详解（5）继承的作用和特点，instanceof操作符，方法的重写，final关键字，组合，Object类和toString的重写，equals ,super关键字

目录1：继承1.1继承的两个作用1.2 继承的实现和继承的特点1.3：instanceof操作符1.3方法的重写1.4：final关键字1.5：组合2：Object类和重写toString方法2.1.当其他的类没有调用extends是那么该类的父类就是java.lang.Object2.2.toString方法2.3重写toString方法1：继承1.1继承的两个作用1.代码复用，便于类的扩展2.便于建模1.2 继承的实现和继承的特...
复制链接

扫一扫