[java]类的三个基本特征之一 ---- 继承

前言

在前面我们学习过了类和对象的知识，我们都知道，在Java的学习中或者是以后的运用中类和对象时候非常重要的，所以，关于类就有很多知识需要学习，今天，我们一起来学习有关类的三个基本特性之一——继承。

目录

• 继承
  • 继承的特性
  • 关键字
  • 继承种类

• 重写
  • 原则
  • 实例

一：继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。所有的类都默认继承Object类

1.继承的特性：

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。

注意:

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类。

2. 继承的关键字是 extends

A继承于B或者B继承A的格式语法为：

class B extends A{
//实现的内容
}

public class Animal { 
private String name;   
private int id; 
public Animal(String myName, String myid) { 
    //初始化属性值
  } 
  public void eat() {  //吃东西方法的具体实现  } 
   public void sleep() { //睡觉方法的具体实现  } 
 } 

 public class Penguin  extends  Animal{ 
}

3. 继承的种类

单继承：一个子类之继承一个父类就是单继承如下：

 public class A{
 ...........
 }
public class B extends A{
 .......
 }

多层继承：就是上面所说的，B 类继承A 类，C 类继承 B 类

public class A{ ........... }
public class B extends A{ ....... }
public classC extends B{ ....... }

同一个类被多个类继承：

public class A{ ........... }
public class B extends A{ ....... }
public classC extends A{ ....... }

下面来个例子，给大家瞧一瞧，到底继承是怎样使用的

首先定义一个Person类，如下：

 public class Person {
   protected String name;
   protected int age;

   public Person(String name, int age){
    this.name = name;
    this.age = age;
   }

   public void walk(){
  }

   public void eat(){
   }
}

然后定义一个 CivilServant 类继承Person类：

class CivilServant extends Person{
private int salary;
private int count;

public CivilServant(String name, int age,
                    int salary, int count){
    super(name, age);
    this.salary = salary;
    this.count = count;
}

@Override
public void walk() {
    System.out.println("走路！");
}

@Override
public void eat() {
    System.out.println("吃饭！");
}


public void cShow() {
    System.out.println("CivilServant{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", salary=" + salary +
            ", count=" + count +
            '}');
   }
}

定义一个Worker类也继承Person类，代码如下：

class Worker extends  Person{
private int salary;
private String tec;

public Worker(String name, int age, int salary,
              String tec){
    super(name, age);
    this.salary = salary;
    this.tec = tec;
}

@Override
public void walk() {
    System.out.println("快跑呢");
}

@Override
public void eat() {
    System.out.println("急匆匆吃");
}

public void wShow() {
    System.out.println( "Worker{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", salary=" + salary +
            ", tec='" + tec + '\'' +
            '}');
   }
}

定义TesT类，实现main函数。

class Test{
  public static void main(String[] args){
     ArrayList<Person> peoples = new ArrayList<>();

    Person c1 = new CivilServant("小王", 30, 5000, 30);
    Person c2 = new CivilServant("小李", 32, 7000, 34);
    Person c3 = new CivilServant("张三", 33, 2000, 32);

    //peoples.add((Person2)c1);
    peoples.add(c1);
    peoples.add(c2);
    peoples.add(c3);

    Person w1 = new Worker("Jack",23,8922, "Android开发");
    Person w2 = new Worker("Rose",22,10323, "iOS开发");
    Person w3 = new Worker("Merry",20,8123, "web开发");

    peoples.add(w1);
    peoples.add(w2);
    peoples.add(w3);

    for (Person p: peoples){
       //找到p到底是哪个类型的对象
        if(p instanceof CivilServant){
            //公务员
            CivilServant c = (CivilServant)p;
            c.cShow();
            c.walk();
            c.eat();
        }else{
            //员工
            Worker w = (Worker)p;
            w.wShow();
            w.walk();
            w.eat();
          }
       }
   }
}

程序运行结果：

 CivilServant{name='小王', age=30, salary=5000, count=30}
走路！
吃饭！
CivilServant{name='小李', age=32, salary=7000, count=34}
走路！
吃饭！
CivilServant{name='张三', age=33, salary=2000, count=32}
走路！
吃饭！
Worker{name='Jack', age=23, salary=8922, tec='Android开发'}
快跑呢
急匆匆吃
Worker{name='Rose', age=22, salary=10323, tec='iOS开发'}
快跑呢
急匆匆吃
Worker{name='Merry', age=20, salary=8123, tec='web开发'}
 快跑呢
急匆匆吃
Process finished with exit code 0

那么继承了父类之后，我们就拥有父类的非私有化属性和方法，我们可以使用这些属性和方法，有些时候根据需要，我们也可以重写这些方法，那么什么嘛是重写呢？？

二：重写(Override)

原则：

1. 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
2. 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
3. 不能重写为更为严格的权限，如：父类是Public，不能重写为private 的权限，
   4.重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

实例

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

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

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

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 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管b属于Animal类型，但是它运行的是Dog类的move方法，之所以能编译成功，是因为Animal类中存在move方法，然而运行时，运行的是特定对象的方法。就像我们上面的Preson类，CivilServant类和worker 类继承了Person，但是调用CivilServant 和worker 的对象时，运行的是CivilServant 和worker 对象的方法。

好了，今天的内容就结束了，有不足的地方，大家多多指教，欢迎投稿！