Java学习条记--继承方法的重写先容,重写方法的留意事项，方法重写的利用场 ...

目次


一，方法的重写

二，重写方法的留意事项
三，方法重写的利用场景
四，super和this
1.继承中构造方法的特点
2.super和this的具体利用
super的具体利用
this的具体利用

---

一，方法的重写


1.概述:子类中有一个和父类方法名以及参数列表相同的方法
2.条件:继承
3.访问:看new的是谁,先调用谁中的,如果new的是子类,调用调用子类重写的方法,子类没有,找父类
4.检测是否为重写方法:在该方法上写
  @Override  
依旧创建三个类

1. public class Fu {
2.     public void methodFu(){
3.         System.out.println("我是父类中的methodFu方法");
4.     }
6.     public void method(){
7.         System.out.println("我是父类中的method方法");
8.     }
9. }

复制代码

1. public class Zi extends Fu{
2.     public void methodZi(){
3.         System.out.println("我是子类中的methodZi方法");
4.     }
6.     @Override
7.     public void method(){
8.         System.out.println("我是子类中的method方法");
9.     }
10. }

复制代码

如果是重写，@Override不会报错，如果方法名和参数列表有一个差别就会报错
测试类

1. import com.atthruster.c_extends.Zi;
3. public class test {
4.     public static void main(String[] args) {
5.         Fu fu = new Fu();
6.         fu.methodFu();//自己的methodFu方法
7.         fu.method();//new的是父类对象,那么调用的就是父类中的method
9.         System.out.println("================");
11.         Zi zi = new Zi();
12.         zi.methodZi();
13.         zi.methodFu();//继承
14.         zi.method();//子类中的method方法
15.     }
16. }

复制代码

二，重写方法的留意事项


1.子类重写父类方法之后,权限必须要包管大于即是父类权限(权限指的是访问权限)
  public -> protected -> 默认 -> private，例子如下，去掉method前面的public，将会报错

但父类去掉一点事没有

2.子类方法重写父类方法,方法名和参数列表要一样
3.私有方法不能被重写,构造方法不能被重写,静态方法不能被重写
静态方法

私有方法

构造方法

4.子类重写父类方法之后,返回值类型应该是父类方法返回值类型的子类类型  
如许返回的是父类方法返回值类型的子类类型

相反就不可以

三，方法重写的利用场景


1.利用场景:功能升级改造,子类需要对父类中已经实现好的功能进行重新改造
比如对旧手机的来电表现进行改造，假设老年机只能表现电话号码，如今升级可以表现来电人和归属地
创建老手机

1. public class Oldphone {
2.     public void call(){
3.         System.out.println("打电话");
5.     }
6.     public void message(){
7.         System.out.println("发短信");
8.     }
9.     public void show(){
10.         System.out.println("显示手机号");
11.     }
12. }

复制代码

新手机

1. public class Newphone extends Oldphone{
2.     @Override
3.     public void show(){
4.         System.out.println("显示手机号");
5.         System.out.println("显示归属地");
6.         System.out.println("显示来电人");
8.     }
9. }

复制代码

测试类

1. public class test {
2.     public static void main(String[] args) {
3.         Newphone newphone = new Newphone();
4.         newphone.call();//继承
5.         newphone.message();//继承
6.         newphone.show();
7.     }
8. }

复制代码

效果

四，super和this

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


1.留意:new子类对象时,会先初始化父类(先走父类无参构造方法)
2.缘故原由:
  每个构造方法的第一行,默认都会有一个super(),不写jvm自动提供一个
  super()代表的是父类无参构造
例子，依旧三个类

1. public class Fu {
2.     public Fu(){
3.         //super();
4.         System.out.println("我是父类中的无参构造");
5.     }
6. }

复制代码

1. public class Zi extends Fu{
2.     public Zi(){
3.         //super();
4.         System.out.println("我是子类中的无参构造");
5.     }
7.     public Zi(int i){
8.         //super();
9.         System.out.println("我是子类中的有参构造");
10.     }
11. }

复制代码

测试

1. public class test {
2.     public static void main(String[] args) {
3.         Zi zi = new Zi();
6.         System.out.println("=======================");
7.         Zi zi1 = new Zi(10);
9.     }
10. }

复制代码

效果

2.super和this的具体利用

super的具体利用

1.概述:代表的是父类引用
2.作用:可以调用父类中的成员
3.利用:
  a.调用父类构造方法-> 在子类中的构造中写
    super() -> 调用父类无参构造
    super(实参)  -> 调用父类有参构造
      
  b.调用父类成员变量:
    super.成员变量名
        
  c.调用父类成员方法:
    super.成员方法名(实参)

//直接调用方法里的num遵循就近原则
三个类

1. public class Fu {
2.     int num = 10;
3.     public Fu(){
4.         System.out.println("我是父类中的无参构造");
5.     }
7.     public Fu(int data){
8.         System.out.println("我是父类中的有参构造");
9.     }
11.     public void method(){
12.         System.out.println("我是父类中的method方法");
13.     }
14. }

复制代码

1. public class Zi extends Fu{
2.     int num = 100;
3.     public Zi(){
4.         super();//调用父类中的无参构造
5.         System.out.println("我是子类中的无参构造");
6.     }
8.     public Zi(int num){
9.         super(10);//调用父类的有参构造
10.         System.out.println("我是子类中的有参构造");
11.     }
13.     public void method(){
14.         super.method();//调用父类的method方法
15.         System.out.println("我是子类中的method方法");
16.         System.out.println(num);//子类自己的
17.         System.out.println(super.num);//调用父类的num
18.     }
19. }

复制代码

测试类

1. public class Test01 {
2.     public static void main(String[] args) {
3.         Zi zi = new Zi();
4.         System.out.println("============");
5.         Zi zi1 = new Zi(10);
6.         System.out.println("============");
7.         Zi zi2 = new Zi();
8.         zi2.method();
10.     }
11. }

复制代码

前面加了super，就可以直接调用父类引用，效果

this的具体利用

1.this概述:代表的是当前对象(哪个对象调用的this地点的方法,this就代表哪个对象)
2.作用:
  a.区分重名的成员变量和局部变量
  b.调用当前对象中的成员
3.利用:
  a.调用当前对象的构造:在构造中写
    this():调用当前对象的无参构造
    this(实参):调用当前对象的有参构造
  b.调用当前对象的成员变量:
    this.成员变量名
  c.调用当前对象的成员方法:
    this.成员方法名(实参)
4.留意:
  不管是super照旧this,只要在构造中利用,都必须在第一行,所以二者不能同时手写出来

创建一个Person类
如今调用内里的有参/无参构造，那就在无参/有参构造内里加一个this
//直接调用方法里的num遵循就近原则

1. public class Person {
2.     int num = 10;
3.     public Person(){
4.         //this(10);
5.         System.out.println("我是Person中的无参构造");
6.     }
8.     public Person(int data){
9.         //super();super和this不能同时再构造中出现
10.         this();
11.         System.out.println("我是Person中的有参构造");
12.     }
14.     public void method(){
15.         int num = 20;
16.         System.out.println(num);//20
17.         System.out.println(this.num);//10
18.         this.method01();
19.         System.out.println("我是Person类中的method方法");
20.     }
22.     public void method01(){
23.         System.out.println("我是Person类中的method01方法");
24.     }
25. }

复制代码

测试类

1. public class Test01 {
2.     public static void main(String[] args) {
3.         Person person = new Person();
4.         System.out.println("========");
5.         Person person1 = new Person(10);
6.         System.out.println("========");
7.         Person person2 = new Person();
8.         person2.method();
9.     }
10. }

复制代码

效果

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。