java方法的定义调用(重载覆盖多态)

最新推荐文章于 2021-07-14 11:05:32 发布

不会起名字啦

最新推荐文章于 2021-07-14 11:05:32 发布

阅读量261

点赞数

分类专栏： java基础文章标签： javase

本文链接：https://blog.csdn.net/weixin_50776418/article/details/112579305

版权

java基础专栏收录该内容

13 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中方法的定义、调用方式，包括有返回值和无返回值类型的方法，以及实参与形参的概念。接着讨论了方法的重载和覆盖，强调了this和super的区别，final的特性。最后，深入探讨了多态的原理，包括多态成员的特点、向上转型和向下转型以及多态的优缺点。

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

方法:类中一段具有特定功能的程序,提高了代码的复用性和可维护性

调用方式分为有返回值类型,无明确返回值类型

方法:类中一段具有特定功能的程序,提高了代码的复用性和可维护性

格式:

public static 返回值类型(void用于没有返回值的情况) 方法名(参数类型参数名, 参数类型参数名2){//形参

方法体;}

调用方式分为有返回值类型,无明确返回值类型

有返回值类型:

赋值调用:将方法的返回值赋值给一个变量
输出调用:使用输出语句直接输出方法的返回值
直接调用:无法获取方法的返回值

没有明确返回值

直接调用(没有办法获得方法返回值)

实参与形参

形参:方法声明的变量,只能是变量,接受方法时调用传进来的参数

实参:代用方法时传递的数据,可以是常量也可以是变量

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-14-13:08
 */
public class mehthoDemo {
    public static void main(String[] args) {
        //赋值调用
      int sum = sum(1,2);
        System.out.println(sum);
        //输出调用
        int a = 2, b=4;
        System.out.println(sum(a,b));
    }//这里的ab是调用方法sum时传递的数据,可以为常量或变量
    
    //sum方法声明
    public static int sum(int a,int b){
        return a+ b;//这里a与b为形式变量,仅用于接受数据
    }
}

方法重载

类中的同名方法,具有相同的名字，但有不同的参数列表。

也就是说，方法名（等同于函数名）可以相同，只要保证形参类型不同就可以了区分参数类型不同具体有以下几种方式

1.参数的数量不同，例如method(int)和method(int, int)
2、参数的类型不同，例如method(int)和method(String)
3、参数的顺序不同，例如method(int, String)和method(String, int) 参数的顺序不同的前提必须是顺序不同的几个参数类型不能一样

如果编写一个类时没有编写构造器,系统会提供一个所有实力域都为默认值的无参数构造器

如果类中给出了一个构造器,就必须提供一个默认的构造器(不带参数),然后才能通过 new 构造实例

方法覆盖(重写)

目的:对父类已有功能进行改写或直接重新构造

在子类继承(extend)父类时对父类方法的改写操作,在子类方法访问私有(private)父类参数时需要用get方法,需要super关键字区分子类与父类参数调用,不然程序报错

优点: 提高代码复用性,可维护性
缺点:类的耦合性增强了

开发原则:高内聚,低耦合内聚:单个类完成某个任务的能力耦合:类与类之间的关联

package CeShi;

import java.time.LocalDate;

/**
 * @author Lzy
 * @creat 2021-01-13-20:09
 */
public class Employee {
    private final String name;
    private double salary;
    private final LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
        this.name = name;
        this.salary = salary;
        hireDay = LocalDate.of(year,month,day);
    }
    public String getName()
    {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }
    public void raiseSalary(double byPercent)
    {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

经理类,对Employee继承覆盖其中对继承的父类参数调用使用super关键字修饰,如果父类参数发生改变,那么通过super调用的参数也随之改变

方法重写注意:不能重写父类私有参数(private) 权限必须大于等于父类方法权限

@Override(注解):使得代码更规范,作用:当子类重写父类的方法名打错时会提醒

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-13-20:19
 */
public class Manager extends Employee{
    private double bonus;

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        bonus = 0;
    }

    @Override
    public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary + bonus;
    }

    public void setBonus(double b) {
        bonus = b;
    }
}

测试类

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-13-20:23
 */
public class ManagerTest {
    public static void main(String[] args) {
        Manager boss = new Manager("Jack",5000,1998,10, 6);
        boss.setBonus(3000);

        Employee[] staff = new Employee[3];

        staff[0] = boss;
        staff[1] = new Employee("Rock",6000,1999,5,7);
        staff[2] = new Employee("Tommy",8000,2000,9,5);

        for (Employee e: staff)
            System.out.println("name="+e.getName()+ " ,salary= "+e.getSalary()+" ,birthdate= "+e.getHireDay());
    }
}

继承中构造方法的执行

在有子类继承关系的类中,创建子类对象的对象,调用子类构造方法,如子类构造方法第一行代码没有调用父类的构造方法,则会默认调用父类的无参构造
子类构造方法第一行可以使用super()调用父类构造方法
每次执行父类的成员变量都要初始化,且调用子类构造前必须先调用父类构造

package CeShi;

import java.sql.SQLOutput;

/**
 * @author Lzy
 * @creat 2021-01-17-15:38
 */
public class Extend {
    public static void main(String[] args) {
        Son son = new Son();
    }
    static class Dad{
        public Dad(){
            System.out.println("父类无参构造");
        }
        public Dad(String  d){
            System.out.println("父类有参构造");
        }
    }

    static class Son extends Dad{
        public Son(){   //子类构造方法第一行可以使用super()调用父类构造方法
//            super("调用父类有参");
//            this("调用子类有参");
            System.out.println("子类无参构造");
        }
        public Son(String s){
            System.out.println("子类有参构造");
        }
    }
}

单独放开将super那行注释单独放开this那行注释

this和super区别

this: 用于当前对象的引用

调用子类成员变量
调用子类成员方法
调用子类其他构造方法(在子类构造方法第一行)

super:子类对象的父类引用

调用父类的成员变量
调用父类的成员方法
调用父类的构造方法(在子类构造方法第一行)

final的特性

可以用来修饰类,成员方法和成员变量

修饰后

final修饰类: 不能被继承,不能有子类
final修饰的方法:不能被重写
final修饰的变量:作为常量存在,不能被修改

注意:自定义常量(命名规则为全部大写)必须初始化,可以选择显示初始化或构造初始化

多态

前提:

子父类的继承关系
方法的重写
父类引用指向子类对象

动态绑定:运行期间调用的方法根据具体的类型

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 */
public class Poymorphic {
    public static void main(String[] args) {
        Animal a = new Cat();//创建父类(Animal)引用指向子类Cat对象
        a.eat();//通过父类引用调用子类成员变量
    }
}

class Animal{
    public void eat(){
        System.out.println("吃");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

多态成员特点:

成员变量:编译时看的是左边,运行同样看左边

成员方法:编译时看的是左边,运行时看的是右边

静态方法:编译时看的是左边,运行同样看左边

编译时看的都是左边,运行时成员方法看的是右边,其他(成员变量和静态方法)看的都是左边

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 成员变量:编译时看的是左边,运行同样看左边*/
public class Poymorphic {
    public static void main(String[] args) {
       Dad d = new Son();//创建父类(Dad)引用指向子类对象
        System.out.println(d.n);//通过父类引用调用子类成员变量
    }
}

class Dad {
    int n = 1;//父类成员变量定义为1
}

class Son extends Dad{
    int n = 2;//子类成员变量定义为2
}

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 成员方法:编译时看的是左边,运行时看的是右边 */
public class Poymorphic {
    public static void main(String[] args) {
       Dad d = new Son();//创建父类(Dad)引用指向子类对象
       d.method();//通过父类引用调用子类方法
    }
}

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

class Son extends Dad{
    public void method(){
        System.out.println("子类方法");
    }
}

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 静态方法:编译时看的是左边,运行同样看左边*/
public class Poymorphic {
    public static void main(String[] args) {
       Dad d = new Son();//创建父类(Dad)引用指向子类对象
        d.function();//使用变量去调用静态方法,其实相当于用变量类型的类名去调用
    }
}

class Dad {
   public static void function(){
       System.out.println("父类静态方法");
   }
}

class Son extends Dad{
    public static void function(){
        System.out.println("子类静态方法");
    }
}

多态中的向上转型和向下转型

向上转型:子类型转换为父类型(由小到大) 当父类引用指向子类对象时候应用

向下转型:父类型转换为子类型(由大到小) 当使用子类特有成员,父类型需要转换为子类型,这里转换的前提是只能转换为自身

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 */
public class Poymorphic {
    public static void main(String[] args) {
        //向上转型,cat类向Animal父类转换
        Animal a = new Cat();
        a.eat();
        System.out.println("----------");
        //向下转型,由大到小强制转换
        Cat c = (Cat) a;
        c.Catch();
    }
}

class Animal{
   public static void eat(){
       System.out.println("吃东西");
   }
}

class Cat extends Animal{
    public static void eat(){
        System.out.println("吃鱼");
    }

    public void Catch(){
        System.out.println("抓老鼠");
    }
}

多态的优缺点

优点:可以提高可维护性(多态前提所保证的),提高代码可扩展性
缺点:无法直接访问子类特有的成员

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-18-13:26
 通过定义接口使得代码可扩展性提高,添加同类方法不需要在School类中一个个添加,只需完成接口即可*/
public class Poymorphic {
    public static void main(String[] args) {
        School sl = new School();
        sl.creatStudent(new Boy());
        sl.creatStudent(new Gail());
    }
}
class School{
//    public void creatStudent(Boy b){
//        b.study();
//    }
    public void creatStudent(Stu s){
        s.study();
    }
}

interface Stu{
    public void study();
}

class Boy implements Stu{
    public void study(){
        System.out.println("男孩儿学习");
    }
}

class Gail implements Stu{
    public void study(){
        System.out.println("女孩儿学习");
    }
}