java 之继承

### 继承

​    继承后的特点--成员方法

    #### 成员方法不重名

​    如果子类  父类  出现不重名的成员方法，这时的调用  没有 【任何的影响】,对象在调用方法的时候， 会现在 子类中查找有没有对应的方法 ，若子类中存在该放法  那么就执行子类中的该方法 ，若子类中不存在该方法 那么会执行父类当中的成员方法。

```java
public class Fu{
    public void show(){
        System.out.println("Fu 类中Show方法在执行！");
        System.out.println("Fu类中的成员变量num: " + num);
    }
}

public class Zi extends Fu{
    int num;
    public void show2(){
        System.out.println(" Zi类中的show方法在执行！");
        System.out.printlm("Zi类中的成员变量num：" +num);
    }
}
public class TestExtends{

    public static void main(String[] args){
        // 构建子类对象
        Zi zi = new Zi();
        zi.show(); //调用父类当中的方法  10
        zi.show2(); // 调用子类当中的show2方法 20
        
    }
}


```

#### 成员方法重名---重写（override）

如果父子类中 出现了同名的成员方法，这时的访问是一种 特殊的情况，叫做方法重写（Override）。

- 方法重写： 子类中

  出现与父类一摸一样的成员方法时（返回值类型，方法名，参数列表），会出现覆盖效果。也成为覆写，简称"【声明不变，重新实现】"

  示例代码：

  ```java
  public class Fu{
      int num = 10;
      public void show(){
          System.out.println("Fu show() 方法在执行！");
          System.out.println("Fu 成员变量num！" +num);
      }
  }
  public class Zi extends Fu{
      int num = 20;
        public void show(){
          System.out.println("Zi show() 方法在执行！");
          System.out.println("Zi 成员变量num！" +num);
      }
  }
  public class TestExtends02(){
      public static void main(String[] args){
          // 先构建一个子类的对象
          Zi zi = new Zi();
          //调用 show方法
          // 子类中 有该方法故只 执行 子类中的方法 不在往上寻找 该方法
          zi.show();  // Zi.show() 方法调用  结果为 20
          
      }
  }
  ```

  ### 重写的应用：

  子类可以 根据需要，定义特定于自己的行为，即沿袭了父类的功能名称，又根据子类的需要 重新实现父类方法，从而进行功能扩展

​    

```java
public class Phone{
    //打电话
    public void call(){
        System.out.println("打电话！");
        
    }
    // 发短信
    public void sendMessage{
        System.out.println("发短信")
    }
    // 来电显示
    public void show{
        System.out.println("来电显示电话号码!")
    }
    
    public class IPhone12 extends Phone{
        
        // 重写父类中的来电显示功能，并增加自己的显示姓名和显示头像功能
        public void show(){
            // 父类中的功能保持不变
            super.show();
              // 新增新功能
            System.outprintln(" 显示姓名");
               System.outprintln(" 显示头像");
        }
         
      
        public void TextExtends03{
             public static void main(String[] args){
                 //创建一个子类对象
                 IPhone12 iphone = new IPhone12();
                 // 调用父类中的打电话
                 iphone.call();
                 // 调用重写之后的来电显示
                 iphone.show();  // 子类中重写后的  功能
             }
        }
        
        
        
    }
    
}
```

### 重写：方法的名称一样，参数列表【一样】，返回值类型【也一样】，重写前提要有继承关系

### 重载：方法的名称一样，参数列表【不一样】，返回值类型无要求。在本类中

### 注意事项：

- ​    子类重写父类方法，必须要保证权限要大于等于父类权限
- 子类方法覆盖父类方法，返回值类型，函数名称和参数列表必须要一摸一样。

#### 继承后的特点-------构造方法

​    构造方法的定义 和作用：

1. ​        构造方法的名字和类名保持一致, 所以子类时=是无法继承父类当中的构造方法
2. 构造方法的作用一般是用来初始化成员变量，所以子类在初始化的过程中，必须先执行父类中的初始化动作,子类的构造方法当中默认有一个super()方法，表示调用的父类的构造方法，父类的成员变量初始化之后，才可以给子类使用。

```java
public class Fu{
    private int n;
    public Fu(){
        System.out.println("Fu()");
    }
}

public class Zi extends Fu{
    
    public Zi(){
        // super() 调用父类中的构造方法  隐式调用
        System.out.print("z()")
    }
}

public calss TextExtends04{
    public static void main(String[] args){
        Zi zi = new Zi();
    }
}

//输出结果




```

### super() 和 this()

​    父类的空间优先于子类对象产生

​        在每次创建子类对象的时候，先初始化父类空间，再创建子类对象，目的在于子类对象中包含了 其对应的 父类空间，便可以 包含父类的成员，如果父类成员非私有，则子类可以随意使用父类成员。代码体现在 子类的构造方法调用时，会先调用父类中的构造方法