26.0/方法重写/super/子类对象构造器加载顺序/ final/访问修饰符/Object类

光明是人的信仰

已于 2023-11-23 10:13:26 修改

阅读量40

点赞数 2

文章标签： java 开发语言

于 2023-11-22 12:27:00 首次发布

本文链接：https://blog.csdn.net/m0_65227896/article/details/134550510

版权

本文介绍了Java中的方法重写机制，包括为何需要、要求、super关键字的使用，以及构造器加载顺序。还讨论了final关键字对属性、方法和类的影响，以及访问修饰符的层次结构。最后提及了Object类的基础知识，如toString和equals方法的重写。

摘要由CSDN通过智能技术生成

26.1.1什么是方法重写

子类重写父类中的某些方法，重写的只是方法体的内容。

26.1.2 为什么需要方法重写.

因为父类中方法的功能无法满足子类的需求。子类就需要重写父类中这个方法。

26.1.3方法重写的要求

方法名要和父类中的名称一致且参数列表一致，返回类型一致。

访问修饰符不能小于父类，抛出的异常不能大于父类。

例子:

package demo02;


public class Test {
    public static void main(String[] args) {
        Coder coder=new Coder();
        coder.name="欧炜健";
        coder.no="004";
        coder.salary=15000;
        coder.work();

        Manager m=new Manager();
        m.name="赖林龙";
        m.no="001";
        m.salary=16000;
        m.comm=3000;
        m.work();
    }
}
class Emp {
    //工号
    public String no;
    //工资
    public int salary;
    //名字
    public String name;
    public void work(){
        System.out.println("工号为:"+no+"的"+name+",拿着"+salary+"的工资。");
    }
}
class Manager extends Emp{
    //管理员人员--父类中的方法work无法满足我的要求
    public int comm; //奖金属于管理人员特有的属性
    @Override
    public void work() {
        System.out.println("工号为:"+no+"的"+name+",拿着"+salary+"的工资和"+comm+"的奖金。");
    }
}
class Coder extends Emp{

}

1. 学生类: 

  属性: name, age, school; 

  方法:  introduction 自我介绍。 eat()吃饭

2. 老师类:

  属性: name,age, lesson

  方法: introduction 自我介绍。eat() 吃饭

根据上面两个类抽象一个父类，把公共的内容放入父类。打印如下:

"我叫:张三，今年26，所在学校为清华"

”我叫:闫克起,今年28，所教课程为java“

26.2super关键字

super表示父类对象。this表示本类对象。

使用super可以调用父类的成员。被重写的方法，以及构造方法。

public class Test {
    public static void main(String[] args) {
//        Coder coder=new Coder();
//        coder.name="欧炜健";
//        coder.no="004";
//        coder.salary=15000;
//        coder.work();

        Manager m=new Manager();
        m.name="赖林龙";
        m.no="001";
        m.salary=16000;
        m.comm=3000;
        m.work();
    }
}
class Emp {
    //工号
    public String no;
    //工资
    public int salary;
    //名字
    public String name;
    public void work(){
        System.out.print("工号为:"+no+"的"+name+",拿着"+salary+"的工资。");
    }
}
class Manager extends Emp{
    //管理员人员--父类中的方法work无法满足我的要求
    public int comm; //奖金属于管理人员特有的属性
    @Override
    public void work() {
        //如果想调用父类被重写的方法。使用super表示父类对象
        super.work();
        System.out.println("和"+comm+"的奖金。");
        //可能还需要父类中该方法的内容，在父类方法内容的基础上增强。
    }
}
class Coder extends Emp{

}

26.3创建子类对象时构造器加载顺序

先加载父类构造方法再加载子类的构造方法。

public class Test {
    public static void main(String[] args) {
        //new 类对象会调用对应的构造方法。 根据结果我们发现:创建子类对象时，先执行父类的构造方法再执行子类的构造方法。
        S s=new S();
    }
}
class F{
    //构造方法
//    public F(){
//        System.out.println("父类的构造方法");
//    }
    public F(String n){
        System.out.println("父类中有参构造方法");
        
    }
}
class S extends F{
    public S(){
        //super();//默认隐藏调用父类的构造方法这句话。这句话必须放在子类构造方法第一句。
        super("闫克起");
        System.out.println("子类的构造方法");
    }
}

package demo04;

public class Test {
    static {
        System.out.println("1. Test的静态代码");
    }
    //134256
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println("6.主函数代码");
        Son son1 = new Son();
    }
}
class Father{
    public Father(){
        System.out.println("2.父类的构造方法");
    }
    static{
        System.out.println("3.父类的静态代码块");
    }
}
class Son extends Father{
    static {
        System.out.println("4.子类的静态代码块");
    }
    public Son(){
        System.out.println("5. 子类的构造方法");
    }
}
//1. 静态代码块--会随着类的加载而被加载而且只会被加载一次。
//2. 先在家父类得到构造方法再加载子类的构造方法。

26.4final关键字

final最终的。它可以修改属性，修饰方法，修饰类。如果使用final修饰上面的成员会有什么变化。

修饰属性:--表示常量--不能改变它的值只能赋值一次。

修饰方法: 表示该方法不能被重写。[父类认为该方法是一个完美的方法s]

修饰类: 表示最终类，不能被继承。[里面所有方法都是完美的方法] String类。

public class Test {
}
final class A{
     public final String name="刘德华";
     public int age;

     public final void show(){
         //name="张学友"; //因为name使用final修饰，表示name为常量，其值不能改变了。
     }
}
class B extends A{//出错的原因是由于A使用final修饰了，所以不能被继承

//    @Override
//    public void show(){ 由于show使用final修饰不能重写该方法。
//
//    }
}

26.5访问修饰符有哪些?

public-->protected-->默认-->private

public 公共的。整个工程都能访问。

protected: 保护的。被本包以及不同包下的子类访问。

默认: 被本包访问。

private: 私有。本类访问。

26.6.Object类

它所有类的父类，所有类那么属于Object的子类，要么间接属于Object的子类。如果一个类没有显示的继承某个类，那么该类默认继承Object.

例如:

public class A{

}
等价于
public class A extends Object{

}

记住Object中如下方法：

toString（）方法。

package demo08;


public class Test01 {
    public static void main(String[] args) {
        Father f1=new Father("眼科其",19);
        System.out.println(f1);//打印一个对象时默认调用的是Object类中toString方法
        System.out.println(f1.toString());//打印一个对象时默认调用的是Object类中toString方法. 如果你打印对象时不想显示地址,可以重写Object类中的toString方法
    }
}

class Father{
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Father() {
    }

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

equals方法

package demo08;


public class Test01 {
    public static void main(String[] args) {

        String s1=new String("hello");
        String s2=new String("hello");
        System.out.println(s1==s2);//比较是两个字符串的引用地址是否相同
        System.out.println(s1.equals(s2));//比较字符串的内容是否相同

        Father f1=new Father("眼科其",19);
        Father f2=new Father("眼科其",19);

        System.out.println(f1==f2);//==比较的是两个对象的引用地址.

        System.out.println(f1.equals(f2));//因为String把Object类中的equals方法重写了. 默认Object类中的equals方法比较的还是两个对象的引用地址.如果想比较两个对象的值.那么必须重写equals方法

//        System.out.println(f1);//打印一个对象时默认调用的是Object类中toString方法
//        System.out.println(f1.toString());//打印一个对象时默认调用的是Object类中toString方法. 如果你打印对象时不想显示地址,可以重写Object类中的toString方法
    }
}

class Father{
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o){
        return true;
    }

    public Father() {
    }

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}