「java」重载&重写&多态

最新推荐文章于 2023-07-19 17:09:58 发布

qq_1144521901

最新推荐文章于 2023-07-19 17:09:58 发布

阅读量269

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_36098284/article/details/106127601

版权

java 专栏收录该内容

68 篇文章 3 订阅

订阅专栏

在学习继承后，很多同学会混淆：继承后重载，重写和多态的问题，我就写了一个小程序对下面对几个事情进行下解释。

我建议不理解或则有疑惑的地方，可以自己写个类测试一下就会明白其中的含义。

有些图由于csdn网站的原因，一直显示服务器存在错误，我明天再次上传。

1.首先大家需要先理解重载和重写对定义。

我简单对介绍一下哈，重载就是发生在一个类中，同名函数但是不同参数的多个函数的称呼。而重写就是发生在继承之后，子类重写了父类的一些函数，子类可能因为某些原因认为父类函数过于抽象等原因，进行重写。

二者的区别如下：

下面的例子可以很好的解释我刚的话

参考：https://www.quora.com/What-is-the-difference-between-overload-and-override

2. 用代码来解释一些问题

2.1对继承后，构造函数的理解

如果父类的变量是public修饰时，会被子类继承，那么子类的构造函数的写法就要注意，因为要取决于父类的写法。

2.1.1

先简单的写个父类：都是public修饰，并且只有一个有参的构造函数。

public class Dog {
	public String name;
	public Dog(String name)
	{
		this.name = name;		
	}
//只有一个代参的构造函数时
	public Dog(String name)
	{
		this.name = name;
				
	}
}

子类对其进行继承后，对几种构造函数的解释。

package helloword;

public class hund extends Dog{
	public int size;
	//对构造函数的解释
	//空参数---会报错，因为hund继承了Dog的name，因此它的构造函数一定是有参数的，
	public hund()
	{
		
	}
	// 当构造函数只有一个String是可以的，那么默认，在使用的时候，hund中定义的size就是0，不可以是别的值
	public hund(String name) 
	{
		//调用Dog的构造函数
		super(name);
	}
	//错误，没有name的定义
	public hund(int size)
	{
		this.size = size;
	}
	//正确
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
	}
}

测试：

	public static void main(String args[])
	{
		hund h1 = new hund(); // 报错
		hund h2 = new hund("dog"); // name = dog ；size = 0；
		hund h3 = new hund(2); //报错
		hund h4 = new hund("luckly",2);	 name = luckly size = 2
	}

也就是说使用hund 的实例的时候，必须有name的传参，但是这主要取决于父类Dog的构造函数，只有一个带参数的name

2.1.2

但是如果Dog的构造函数如下，添加一个无参构造函数时，结果就不同。

package helloword;

public class Dog {
	public String name;
	private double price;
	public Dog()
	{
		
	}
	public Dog(String name)
	{
		this.name = name;
				
	}
	public void eat()
	{
		System.out.print("eat food");
	}
	public void drink()
	{
		System.out.print("drink water");
	}
}

hund类如下，则都可以声称和运行。

package helloword;

public class hund extends Dog{
	public int size;
	//对构造函数的解释
	public hund()
	{
		
	}
	// 当构造函数只有一个String是可以的，那么默认，在使用的时候，hund中定义的size就是0，不可以是别的值
	public hund(String name) 
	{
		//调用Dog的构造函数
		super(name);
	}
	public hund(int size)
	{
		this.size = size;
	}
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
	}
	public static void main(String args[])
	{
		hund h1 = new hund();
		System.out.print(h1.size);
		System.out.print(h1.name);
		hund h2 = new hund(2);
		hund h4 = new hund("luckly",2);	
	}
}

2.1.3 子类对实例优先调用父类对构造函数

父类如下：

package helloword;

public class Dog {
	public String name;
	private double price;
	public Dog()
	{
		System.out.println("我是父类无参构造函数");
	}
	public Dog(String name)
	{
		this.name = name;
		System.out.println("我是父类有参构造函数");
				
	}
}

子类：

package helloword;

public class hund extends Dog{
	public int size;
	//对构造函数的解释
	public hund()
	{
		System.out.println("我是子类无参构造函数");
	}
	// 当构造函数只有一个String是可以的，那么默认，在使用的时候，hund中定义的size就是0，不可以是别的值
	public hund(String name) 
	{
		//调用Dog的构造函数
		super(name);
		System.out.println("我是子类有参name构造函数");
	}
	public hund(int size)
	{
		this.size = size;
		System.out.println("我是子类有参size构造函数");
	}
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
		System.out.println("我是子类有参size+name构造函数");
	}
	public static void main(String args[])
	{
		hund h1 = new hund();
		hund h2 = new hund(2);
		hund h4 = new hund("luckly",2);	
	}
}

测试：

我是父类无参构造函数
我是子类无参构造函数
我是父类无参构造函数
我是子类有参size构造函数
我是父类有参构造函数
我是子类有参size+name构造函数

2.2 重写和重载

2.2.1 普通重写

父类定义了一个函数eat

public class Dog {
	public String name;
	public Dog(String name)
	{
		this.name = name;		
	}
	public void eat()
	{
		System.out.print("我是父类的eat函数");
	}
}

子类重写了这个函数：

package helloword;

public class hund extends Dog{
	public int size;
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
	}
	public void eat()
	{
		System.out.println("我是子类的eat函数");
	}
	public static void main(String args[])
	{
		hund h4 = new hund("luckly",2);	
		h4.eat();
	}
}

在h4调用eat函数的时候，观察结果是调用了子类的函数，而不是父类的，输出结果如下：

我是子类的eat函数

结论：通过这里例子可以发现，其实重写就是覆盖了父类的eat函数，但是如果定义的是父类的子类，肯定父类的eat函数还是可以使用的。

2.2.2 重载和重写

当我们把子类的eat函数，添加一个int的参数时，调用eat（），就是调用父类的eat（）了，而调用eat（2）就是调用子类的eat（int temp）函数

父类：

public class Dog {
	public String name;
	public Dog(String name)
	{
		this.name = name;		
	}
	public void eat()
	{
		System.out.println("我是父类的eat函数");
	}
}

子类；

public class hund extends Dog{
	public int size;
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
	}
	public void eat(int temp)
	{
		System.out.println("我是子类的eat函数:我吃了"+temp+"食物");
	}
	public static void main(String args[])
	{
		hund h4 = new hund("luckly",2);	
		h4.eat();
		h4.eat(2);
	}
}

结果：

我是父类的eat函数

我是子类的eat函数:我吃了2食物

结论：其实本质上讲，子类继承了父类的eat（），但是写了一个eat（int temp）也就是带参数的函数，那么这里的eat（）就不是重写了，而是重载了。所以当使用h4.eat()的时候，调用的其实是父类的eat（），而使用h4.eat(2)的时候，就是使用子类自己定义的函数。

其实子类也函数在运行的时候可以理解成如下的形式，而eat()是父类给它的

public class hund extends Dog{
	public int size;
	public String name;
	public hund(String name,int size)
	{
		super(name);
        //这里的super（name）就是调用父类public Dog（String name）函数，这里没法加入
		this.size = size;
	}
	public void eat()
	{
		System.out.println("我是父类的eat函数");
	}
	public void eat(int temp)
	{
		System.out.println("我是子类的eat函数:我吃了"+temp+"食物");
	}
	public static void main(String args[])
	{
		hund h4 = new hund("luckly",2);	
		h4.eat();
		h4.eat(2);
	}
}

2.3. 多态

2.3.1 普通多态

父类：

public class Dog {
	public String name;
	public Dog(String name)
	{
		this.name = name;		
	}
	public void eat()
	{
		System.out.println("我是父类的eat函数");
	}
	public void drink()
	{
		System.out.println("我是子类的drink函数");
	}
}

子类：

package helloword;

public class hund extends Dog{
	public int size;
	public hund(String name,int size)
	{
		super(name);
		this.size = size;
	}
	// drink函数重写
	public void drink()
	{
		System.out.println("我是子类的drink函数");
	}
	// eat函数重载
	public void eat(int temp)
	{
		System.out.println("我是子类的eat函数:我吃了"+temp+"食物");
	}
	public static void main(String args[])
	{
		Dog h4 = new hund("luckly",2);	
		h4.eat();
		h4.drink();
	}
}

结果：

我是父类的eat函数

我是子类的drink函数

但是如果使用下面的语句，会报错：

h4.eat(2);

结论：eat是重载的，因此调用的肯定是父类的eat函数，drink是重写的，调用的肯定是子类重写之后的函数

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

3. 经典案例分析

下面来看一个经典的案例

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

public class D extends B{

}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

输出结果：

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

解释：

其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

首先解释下第二个，a1.show（c），为什么是 A-A

因为根据优先级，会先找A类的show（C），但是函数不存在，而A类的super函数是object，所以第二个super.show(C)也是没有的。然后就是看第三个，this.show((super)C)，因为C继承B，B继承A，因此AB都是C的父类。因此就调用A类的函数：public String show(A obj)。

下面的都同理！！

参考：https://www.cnblogs.com/chenssy/p/3372798.html