重写、覆盖、重载、静态方法的概念透析

参考：https://blog.csdn.net/ericbaner/article/details/3857268

override->重写=(覆盖）

overload->重载

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。

重写（覆盖）的规则：
   1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
   2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
   3、重写的方法的返回值类型必须和被重写的方法的返回一致；
   4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
   5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。

6、静态方法不能被重写为非静态的方法（会编译出错）。

代码实例：

public class FatherClass {
	private int i = 1;
	
	private void name3() {
		System.out.println("private name3()");
	}

	public int name() {
		// System.out.println(111);
		return i;
	}

	public void name(int i) {
		// TODO Auto-generated method stub
		System.out.println(i);
	}

	protected static void name1() {
		System.out.println("protected name1");
	}

	protected void name2() {
		System.out.println("protected name2");
	}

}

public class SonClass extends FatherClass {
	private static int i = 2;

	// 1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
	@Override
	public int name() {// 3.重写的方法必须和父类的方法的方法名和返回类型必须一样
		// TODO Auto-generated method stub
		super.name();
		System.out.println(i);
		return i;
	}

	@Override
	public void name(int i) {
		// TODO Auto-generated method stub

		System.out.println(1215);
		System.out.println(1215);
	}

	@Override
	public static void name1() {// 报错 ！6. 父类静态方法不能被重写为静态方法否则会报错
		// TODO Auto-generated method stub

		System.out.println("protected static void name1() can't be extended");
	}

	@Override
	public void name2() {// 2.重写方法的访问修饰符一定要大于被重写方法的修饰符（public>protected>default>private）
		// TODO Auto-generated method stub
		super.name2();
		System.out.println("protect name2 in son to public name2");
	}

	private void name3() {// 5.被重写的方法不能为private，否则在其子类中只是定义了一个新的方法而已，并没有对其重写
		System.out.println("private name3() in son");
	}

	public static void main(String[] args) {
		FatherClass fatherClass = new FatherClass();
		FatherClass fatherClass2 = new SonClass();
		fatherClass.i//报错 ！父类的private成员变量不能被调用，可以通过get属性方法return获取到
		fatherClass.name1();//报错！
		fatherClass2.name1();

	}

}

扩展:

1.private属性和方法不能被实例变量调用。

2.类的属性和成员的区别:

都可以叫变量，硬要说区分的话 就是他们的作用域不同 类的属性(或变量)在整个class中都能被使用，而方法或者其他代码块里面的局部变量只能在那对大括号里面使用。

3.字段和属性：

Java中的属性(property)，通常可以理解为get和set方法。

而字段(field)，通常叫做“类成员”，或 "类成员变量”，有时也叫“域”，理解为“数据成员”，用来承载数据的。

java静态方法能否被继承？

参考：https://www.cnblogs.com/mxmbk/articles/5151095.html

结论：java中静态属性和静态方法可以被继承，但是没有被重写(overwrite)而是被隐藏.

原因：

1). 静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成对，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在"隐藏"的这种情况。

2). 多态之所以能够实现依赖于继承、接口和重写、重载（继承和重写最为关键）。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是："重写"后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。

3). 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。

public class A {
	static int k = 1;// 静态属性
	int i = 2;// 非静态属性

	public static void play() {// 静态方法
		System.out.println("A静态方法play");
	}

	public void play1() {// 非静态方法
		System.out.println("A非静态方法play1");
	}
}

public class B extends A {
	static int k = 5;// 静态属性
	int i = 6;// 非静态属性

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A a = new B();
		System.out.println(a.k + " " + a.i);// 静态属性和非静态属性都可以被继承，但没有被重写
		a.play();
		A.play();
		a.play1();
	}

	public static void play() {// 静态方法都可以被继承但没有被重写
		System.out.println("B静态方法");
	}

	@Override
	public void play1() {// 非静态方法通过重写实现多态
		// TODO Auto-generated method stub

		System.out.println("B非静态方法play1");
	}

}

重载：overload->重载

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。

一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

举个例子：
public class Shape 
{
   public static void main(String[] args){
     Triangle tri = new Triangle();
     System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
     Shape shape = new Triangle();
     System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
     Rectangle Rec = new Rectangle();
     Shape shape2 = Rec;
     System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
   }
   public boolean isShape(){
     return true;
   }
   public int getSides(){
     return 0 ;
   }
   public int getSides(Triangle tri){ //重载
     return 3 ;
   }
   public int getSides(Rectangle rec){ //重载
    return 4 ;
   }
}
class Triangle extends Shape 
{
   public int getSides() { //重写,实现多态
     return 3;
   }
}
class Rectangle extends Shape 
{
   public int getSides(int i) { //重载
    return i;
   }
}

注意Triangle类的方法是重写，而Rectangle类的方法是重载。对两者比较，可以发现多态比重载的优点：
如果用重载，则在父类里要对应每一个子类都重载一个取得边数的方法；
如果用多态，则父类只提供取得边数的接口，至于取得哪个形状的边数，怎样取得，在子类里各自实现(重写)。

重写、覆盖、重载、静态方法的概念透析

重载：overload->重载

猜你喜欢