Java继承

最新推荐文章于 2024-11-04 22:26:34 发布

才尽散人

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量592

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/kr20021127/article/details/130329315

版权

1.继承概述

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

2.继承的格式

父类:

public class Father {
    
}

子类:

public class Son extends Father {

}

3.继承中成员变量的访问方式

1.直接通过子类对象访问成员变量:等号左边是谁就优先用谁,没有则向上找

2.直接通过子类对象访问成员变量:该方法属于谁就优先用谁,没有则向上找

public class Father {
    int numFather = 10;
    int num = 20;

    public void methodFather() {
        // 使用的是本类当中的,不会向下找子类
        System.out.println(num);
    }
}

public class Son extends Father {
    int numSon = 30;
    int num = 40;

    public void methodSon() {
        // 因为本类当中有num,所以这里用的是本来类当中的num
        System.out.println(num);
    }
}

public class test {
    public static void main(String[] args) {
        Father father = new Father();
        System.out.println(father.numFather);
        System.out.println("========");

        Son son = new Son();
        System.out.println(son.numFather);
        System.out.println(son.numSon);
        System.out.println("========");

        // 等号左边是谁就有限用谁
        System.out.println(son.num);
        System.out.println("========");

        // 这个方法是子类的,优先用子类的,没有再向上找

        son.methodSon();//40
        son.methodFather();//20
    }
}

4.变量重名的三种区分方式

1.局部变量: 直接写成员变量

2.本类的成员变量: this.成员变量

3.父类的成员变量: super.成员变量名

public class Father {
    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }
}

public class Son extends Father {
    int num = 20;

    public void methodSon() {
        int num = 30;
        System.out.println(num);//该方法中的num
        System.out.println(this.num);//子类中的num
        System.out.println(super.num);//父类中的num
    }
}

public class test {
    public static void main(String[] args) {
        Son son = new Son();
        son.method();
    }
}

5.继承中成员方法访问特点

1.在父子的继承关系中,创建子类对象,访问成员方法的规则

2.创建的对象是谁,就优先用谁,如果没有则向上找

注意事项

无论是成员方法还是成员变量,如果没有都是向上找父类,不会向下找子类

6.方法重写

1.概念

在继承关系当中,方法的名称一样,参数列表也一样。

2.与重载的区别

重写(Override):方法的名称一样,参数列表也一样。覆盖、覆写。

重载(Overload):方法的名称一样,参数列表不一样。

3.特点

创建的是子类对象,则优先使用子类方法

4.注意事项

1.必须保证父子之间的方法名称相同,参数列表也相同

@Override:写在方法前面,用来检测是不是有效的覆盖重写

这个注释就算不写,只要满足要求,也是正确的方法重写

2.子类的返回值必须小于等于父类方法的返回值范围

Object是所有类的公共最高类

3.子类的访问权限必须大于等于父类方法的权限修饰符(public>protected>default>private)

public class Father {
    public void method() {
        System.out.println("父类方法重名");
    }
}

public class Son extends Father {
    @Override
    public void method() {
        System.out.println("子类方法重名");
    }
}

public class test {
    public static void main(String[] args) {
        Son son = new Son();
        son.method();
        son.method();
    }
}

7.super关键字的三种用法

1.在子类的成员方法中访问父类的成员变量

2.在子类的成员方法中访问父类的成员方法

3.在子类的构造方法中访问父类的构造方法

public class Father {
    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }
}

public class Son extends Father {
    int num = 20;

    public Son() {
        super();// 在子类的构造方法中访问父类的构造方法
    }

    public void methodSon() {
        System.out.println(super.num);// 在子类的成员方法中访问父类的成员变量
    }

    public void method() {
        super.method();
        System.out.println("子类方法");// 在子类的成员方法中访问父类的成员方法
    }

}

public class test {
    public static void main(String[] args) {
        Son son = new Son();
        son.method();
        son.methodSon();
    }
}

8.this关键字的三种用法

1.在本类的成员方法中访问本类的成员变量

2.在本类的成员方法中访问本类的另一个成员方法

3.在本类的构造方法中访问本类的另一个构造方法

注意事项：1.也必须是构造方法的第一个语句，唯一一个

2.super和this两种构造调用不能同时使用

public class Father {
    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }
}

public class Son extends Father {
    int num = 20;

    public Son() {
        this(123);// 在本类的构造方法中访问本类的另一个构造方法

    }

    public Son(int n) {

    }

    public void method() {
        int num = 10;
        System.out.println(num);
        System.out.println(this.num);// 在本类的成员方法中访问本类的成员变量
    }

    public void method1() {
        System.out.println("method1");

    }

    public void method2() {
        this.method1();// 在本类的成员方法中访问本类的另一个成员方法
        System.out.println("method2");
    }
}

public class test {
    public static void main(String[] args) {
        Son son = new Son();
        son.method();
        son.method1();
        son.method2();
    }
}