Java的方法重写、super、this、abstract

最新推荐文章于 2024-04-17 00:59:01 发布

丶嘟嘟

最新推荐文章于 2024-04-17 00:59:01 发布

阅读量164

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_51149294/article/details/132683703

版权

方法的重写

1.概述:

子类中有一个和父类方法名以及参数一模一样的方法

2.检测:

@override —>注解

如果在方法上写上此注解,注解报错,证明此方法不是重写的方法,反之就是

3.访问特点:

看new的是谁就调用谁中的方法, 子类没有就去父类访问

4.注意事项

子类方法重写父类方法,必须要保证权限大于等于父类权限.(权限指的是权限修饰符)

public -> protected -> 默认 -> public
子类重写父类方法, 方法名和参数列表都要一模一样
私有方法不能被重写, 构造方法不能被重写, 静态方法不能被重写
子类重写父类方法之后, 返回值类型应该是父类方法返回值类型的子类类型 , 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型。
子类方法抛出的异常不能大于父类被重写方法的异常
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

5.使用场景

一般都是作为对父类某个方法的一个升级改造, 子类对父类中已经实现好的功能进行重写改造

public class OldPhone {
    public void call(String str){
        System.out.println("给"+str+"打电话");
    }

    public void sendMessage(){
        System.out.println("发短信");
    }

    public void show(){
        System.out.println("来电显示");
    }
}

public class NewPhone extends OldPhone{
    @Override
    public void show() {
        System.out.println("来电显示");
        System.out.println("归属地显示");
    }
}

public class Test {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call("花园宝宝");
        newPhone.sendMessage();
        newPhone.show();
    }
}

super和this

1.继承中构造方法的特点

注意:创建子类对象时,先初始化父类(调用父类的无参构造器)
原因:构造方法中的第一行,会默认有一个super(),这是jvm自动为每个构造方法提供的
super关键字:代表的是父类引用
super():代表的是调用父类的无参构造方法,必须在构造方法的第一行

2.super的具体使用

概述:super代表的是父类引用
作用: 调用父类中的成员
使用:
- 调用父类构造方法:在子类的构造中写
  - super() —> 调用父类的无参构造器
  - super(实参) —>调用父类有参构造
- 调用父类成员变量
  - super . 成员变量名
- 调用父类成员方法
  - super . 成员方法名(参数)

3.this的具体使用

this概述 : 代表的是当前对象
作用 :
- 区分重名的成员变量和局部变量
- 调用当前类中的成员
使用 :
- 调用当前类的构造 : 在当前类的构造中写
  - this() : 调用当前类的无参构造
  - this(实参) : 调用当前类的有参构造
- 调用当前类的成员变量
  - this . 成员变量名
  - this . 成员方法名()
  - this . 成员方法名(参数)
注意 :
- 不管是super还是this , 只要在构造器中使用 , 都必须在第一行 , 二者不能同时使用

继承的特点

继承只支持单继承,不能多继承
```
public class A extends B,C{} -> 错误
```

继承支持多层继承

 public class A extends B{}
 public class B extends C{}

一个父类可以有多个子类

 public class A extends C{} 
 public class B extends C{}

构造方法不能继承 , 也不能重写

私有方法可以继承 , 但不能重写

静态方法可以继承 , 但不能重写

如何为父类中的private的成员变量赋值

1.利用set赋值

public class Employee {
    private String name;
    private int age;

    public Employee() {
    }

    public Employee(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;
    }

    public void work(){
        System.out.println("在工作");
    }
}

public class Teacher extends Employee{
    
}

public class Test {
    public static void main(String[] args) {
        //set赋值
        Teacher teacher = new Teacher();
        teacher.setName("猪猪侠");
        teacher.setAge(18);
        System.out.println(teacher.getName()+"---"+teacher.getAge());
    }
}

2.利用构造方法赋值

public class Test {
    public static void main(String[] args) {
        //构造器赋值
        Teacher teacher1 = new Teacher("超人强", 17);
        //首先创建子类Teacher对象的有参构造器
        //然后teacher的有参构造器中第一行为super(name,age)去调用父类的有参构造器
        //有参构造器中  this.name = name    this.age = age;成功赋值
        System.out.println(teacher1.getName()+"---"+teacher1.getAge());
    }
}

抽象

抽象的介绍

当将共性方法抽取出来时 , 发现不同的子类针对次方法的实现细节不同 , 此时抽取出来的方法体无法直接在父类中确定 , 此时抽取出来的方法体无法直接在父类中确定 , 就可以定义为抽象方法

1.抽象方法所在的类一定是抽象类

2.关键字:abstract

a. 修饰符 abstract 返回值类型方法名(参数); --------抽象方法

b. public abstract class 类名{}; -------抽象类

3.特点

a. 子类继承抽象父类之后 , 必须要重写所有的抽象方法

b. 抽象类是不能直接new对象的 , 需要通过new子类对象 , 调用重写的方法

c. 抽象方法所在的类一定是抽象类

d. 抽象类中不一定非得有抽象方法

抽象的注意事项

抽象类不能直接new对象 , 只能创建非抽象子类的对象
抽象类中 , 可以有构造方法 , 是提供给子类创建对象时 , 初始化父类中属性使用的
抽象类中可以有成员变量 , 构造 , 成员方法
抽象类中不一定非得有抽象方法 , 但是有抽象方法的类一定是抽象类
抽象类的子类 , 必须重写父类中的所有抽象方法 , 否则, 编译无法通过 , 除非该子类也是抽象类
通过多态创建的子类对象 , 无法调用子类特有的方法

综合案例

某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部、维护部）。
研发部(Developer)根据所需研发的内容不同，又分为 JavaEE工程师 、Android工程师 ；
维护部(Maintainer)根据所需维护的内容不同，又分为 网络维护工程师 、硬件维护工程师 。

公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。

工作内容:

- JavaEE工程师： 员工号为xxx的 xxx员工，正在研发淘宝网站
- Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
- 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
- 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机

请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

通过set来设置对象属性

public abstract class Employee {
    private String name;
    private int id;

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

    public Employee() {
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public abstract void work();
}

public abstract class Developer extends Employee{
}

public class JavaEE extends Developer{
    @Override
    public void work() {
        System.out.println("员工号为"+getId()+"的"+getName()+"员工,正在开发淘宝网站");
    }
}

public class Test {
    public static void main(String[] args) {
        JavaEE javaEE = new JavaEE();
        javaEE.setName("二狗");
        javaEE.setId(18);
        javaEE.work();
    }
}

通过构造器来创建对象

public abstract class Employee {
    private String name;
    private int id;

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

    public Employee() {
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public abstract void work();
}

public abstract class Developer extends Employee{
    public Developer(String name, int id) {
        super(name, id);
    }

    public Developer() {
    }
}

public class JavaEE extends Developer{
    public JavaEE(String name, int id) {
        super(name, id);
    }

    public JavaEE() {
    }

    @Override
    public void work() {
        System.out.println("员工号为"+getId()+"的"+getName()+"员工,正在开发淘宝网站");
    }
}

public class Test {
    public static void main(String[] args) {
        JavaEE javaEE = new JavaEE("二狗", 001);
        javaEE.work();
    }
}

通过构造器创建对象时,利用super来调用父类的构造器 , 注意:super只能调用到直系父类的构造器 , 不能跨辈分调用 , 也就是说儿子不能调用到爷爷的构造器

设计模式

丶嘟嘟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java的方法重写、super、this、abstract

子类中有一个和父类方法名以及参数一模一样的方法当将共性方法抽取出来时 , 发现不同的子类针对次方法的实现细节不同 , 此时抽取出来的方法体无法直接在父类中确定 , 此时抽取出来的方法体无法直接在父类中确定 , 就可以定义为抽象方法 1.抽象方法所在的类一定是抽象类 2.关键字:abstract a. 修饰符 abstract 返回值类型方法名(参数);--------抽象方法。
复制链接

扫一扫