[Java知识库]【Java】基础5面向对象：继承|重写|重载|多态

继承

关键字extends表示继承。

public class 父类 {

}
public class 子类 extends 父类 {

}

!Java不支持多继承！

继承的特性：

1. 子类拥有父类非 private 的属性、方法。
2. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。
4. Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
5. 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super 与 this

• super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

• this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

重写(Override)与重载(Overload)

重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");//重写了父类的move方法
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

反例👇

public class S {
	public static void main(String[] args) {
		 Animal a = new Animal(); // Animal 对象
	     Animal b = new Dog(); // Dog 对象
	 
	      a.move();// 执行 Animal 类的方法
	      b.move();//执行 Dog 类的方法
	     // b.bark();//编译不通过，因为 new Dog()的返回值是用它的父类接收的，
	     			//所以它只能用父类已有的方法。brak这个方法父类中没有，所以编译报错
	}
}

class Animal {
	public void move() {
		System.out.println("动物可以移动");
	}
}

class Dog extends Animal {
	public void move() {
		System.out.println("狗可以跑和走");
	}

	public void bark() {
		System.out.println("狗可以吠叫");
	}
}

方法的重写规则

1. 参数列表与被重写方法的参数列表必须完全相同。
2. 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7及更高版本可以不同）。
3. 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected
4. 父类的成员方法只能被它的子类重写。
5. 声明为 final 的方法不能被重写。
6. 声明为 static 的方法不能被重写，但是能够被再次声明。
7. 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
8. 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
9. 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
10. 构造方法不能被重写。
11. 如果不能继承一个类，则不能重写该类的方法。

重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。
  实例代码👇

public class Overloading {
    public int test(){//无参方法
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){//一个参数
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){//两个参数
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

多态

!多态是同一个行为具有多个不同表现形式或形态的能力。继承、接口、抽象类都是实现多态的方式

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：父类 父 = new 子类();

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性

可替换性表现在面向接口编程，一个接口可以被多个类实现，这个类的实现方式不行的时候可以用别的实现。

3. 可扩充性

这个特性体现在类的继承，重写。子类继承父类，子类可以重写父类的方法，也可以有自己独立的方法，这事可扩充性的表现。

4. 接口性

面向接口编程！

5. 灵活性

2，3，4都是灵活性的表现。

6. 简化性

多态代码实例👇

public class Test {
    public static void main(String[] args) {
      show(new Cat());  
      show(new Dog());  
      

	  //1.这里new  的是Cat，用父类接收。这种的被称作向上转型
  //👇father f = new son();
      Animal a = new Cat(); 
      a.eat();//运行时绑定，最终会找到这个子类的eat方法    

      // 👇向下转型（强制转型）      
      Cat c = (Cat)a;        
      c.work();        // 调用的是 Cat 的 work
  }  
    //1.这里参数只能接收的是Animal类，或者Animal的子类     
    //2.这里虽然是用抽象类接收的参数，但是一般传过来的都是实现类的引用   
    public static void show(Animal a)  {
      //👇这里实际调用的是子类重写的方法，动态绑定问题。						
      a.eat();  
        // 类型判断
        //这里不能用Animal调用work方法，因为他没这个方法。
        //这里的a一般都是子类对象的引用，所以去判断到底是那个子类对象
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  //类型强制转换
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
} 

//抽象类，需要被子类继承
abstract class Animal {  
    abstract void eat();  //抽象方法，需要被子类重写
}  

class Cat extends Animal {  
    public void eat() { //重写父类的方法 
        System.out.println("吃鱼");  
    }  
    public void work() {  //自己的方法
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  //重写父类方法
        System.out.println("吃骨头");  
    }  
    public void work() {  //自己的方法
        System.out.println("看家");  
    }  
}

动态绑定

涉及到多态的地方多会涉及到动态绑定！

静态绑定👇

• 静态绑定发生在编译时期，动态绑定发生在运行时
• 使用private或static或final修饰的变量或者方法，使用静态绑定。而虚方法（可以被子类重写的方法）则会根据运行时的对象进行动态绑定。
• 静态绑定使用类信息来完成，而动态绑定则需要使用对象信息来完成。
• 重载(Overload)的方法使用静态绑定完成，而重写(Override)的方法则使用动态绑定完成。

动态绑定👇
发生在代码的运行期，在运行期间判断对象的类型，并分别调用适当的方法。

动态绑定的过程👇

1. 编译器查看对象的声明类型和方法名。

假设调用x.f(param)，且隐式参数x声明为C类的对象。需要注意的是:有可能存在多个名字为f，但参数类型不一样的方法。例如，可能存在方法 f(int)和方法 f(String)。编译器将会―一列举所有C类中名为f的方法和其超类中访问属性为public且名为f的方法(超类的私有方法不可访问)。

附录

作者的话

继承、重写重载、多态是面向对像中比较重要的概念，要想设计出好的程序，这些必须掌握好并且能够灵活应用才行。继承、重写一般发生在父子类之间，为什么要继承，目的就是要抽共性，抽父类，这样做的好处是让代码更简洁不冗余，可括展并且共性的东西可重复利用。同时，重写又保证了子类可括展的特性。自己体会，这门语言真是面面俱到！

怎么理解多态呢！自己看来，多态多半体现的是面向接口的编程的思想。多态想象成它就像个老板，只关注事情的结果，提出事情的要求和准则，这个事的具体实现不管，然后交给下边的人去做。一千个人有一千个哈姆雷塔，肯定有不同的实现方式，所以不管以什么样的方式去做，最后返回给老板的结果是对的好的就可以了。

转型是多态的体现，向上转型，向下转型。需要注意，其实用到比较多的是向上转型，向下转型是强制转型，所以你在不了解类的继承关系上这种做法是很危险的！