继承性(inheritance)

为什么要有继承？

作用：

继承举例

方法的重写

重写举例

四种访问权限修饰符

关键字—super

关键字super举例

调用父类的构造器

调用父类构造器举例

子类对象的实例化过程

多态性

概念

使用

多态性应用举例

虚拟方法调用(Virtual Method Invocation)

方法的重载与重写

多态小结

总结

继承性(inheritance)

为什么要有继承？

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类 ( 派生类 ) ，单独的这个类称为父类 ( 基类或超类) 。可以理解为 : “子类 is a 父类

作用：

 继承的出现减少了代码冗余，提高了代码的复用性。
 继承的出现，更有利于功能的扩展。
 继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：不要仅为了获取其他类中某个功能而去继承

子类继承了父类，就继承了父类的方法和属性。

 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

关于继承的规则：子类不能直接访问父类中私有的(private)的成员变量和方法

Java只支持单继承和多层继承，不允许多重继承

 一个子类只能有一个父类
 一个父类可以派生出多个子类

继承举例

// Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法,Student都可以使用
class Person {
    public String name;
    public int age;
    public Date birthDate;
    public String getInfo() {
        // ...
    }
}
class Student extends Person {
    public String school;
}

方法的重写

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常

 注意：

子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

重写举例

public class Person {
    public String name;
    public int age;
    public String getInfo() {
        return "Name: "+ name + "\n" +"age: "+ age;
    }
}
public class Student extends Person {
    public String school;
    public String getInfo() { //重写方法
        return "Name: "+ name + "\nage: "+ age +"\nschool: "+ school;
}
public static void main(String args[]){
    Student s1=new Student();
    s1.name="Bob";
    s1.age=20;
    s1.school="school2";
    System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
    }
}

四种访问权限修饰符

Java 权限修饰符 public 、 protected 、 ( 缺省 ) 、 private 置于 类的成员 定义前，用来限定对象对该类成员的访问权限。

对于 class 的权限修饰只可以用 public 和 default( 缺省 ) 。

 public 类可以在任意地方被访问。

 default 类只可以被同一个包内部的类访问

访问控制分析

父类 Parent 和子类 Child 在同一包中定义时

关键字—super

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

super的追溯不仅限于直接父类

super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

关键字super举例

class Person {
    protected String name = "张三";
    protected int age;
    public String getInfo() {
        return "Name: " + name + "\nage: " + age;
    }
}
class Student extends Person {
    protected String name = "李四";
    private String school = "New Oriental";
    public String getSchool() {
        return school;
    }
    public String getInfo() {
        return super.getInfo() + "\nschool: " + school;
    }}
public class StudentTest {
    public static void main(String[] args) {
        Student st = new Student();
        System.out.println(st.getInfo());
}}

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过this(参 数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一” ，且必须放在构造器的首行
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

调用父类构造器举例

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
        this.name = name;
        this.age = age;
        this.birthDate = d;
}
public Person(String name, int age) {
    this(name, age, null);
}
public Person(String name, Date d) {
    this(name, 30, d);
}
public Person(String name) {
    this(name, 30);
    }
}

public class Student extends Person {
    private String school;
    public Student(String name, int age, String s) {
    super(name, age);
    school = s;
}
public Student(String name, String s) {
    super(name);
    school = s;
}
// 编译出错: no super(),系统将调用父类无参数的构造器。
public Student(String s) { 
    school = s;
    }
}

子类对象的实例化过程

class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
}}
class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
}
public Animal(String name, int age) {
    this(name);
    System.out.println("Animal带两个参数的构造器，其age为" + age);
}}
public class Wolf extends Animal {
    public Wolf() {
    super("灰太狼", 3);
    System.out.println("Wolf无参数的构造器");
}
public static void main(String[] args) {
    new Wolf();
}}

多态性

概念

对象的多态 — 在 Java 中 , 子类的对象可以替代父类的对象使用

一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象

使用

多态性，是面向对象中最重要的概念，在Java中的体现：

对象的多态性：父类的引用指向子类的对象 可以直接应用在抽象类和接口上

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

多态情况下， “看左边” ：看的是父类的引用
（父类中不具备子类特有的方法） “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

Person p = new Student();

Object o = new Person(); //Object 类型的变量 o ，指向 Person 类型的对象

o = new Student(); //Object 类型的变量 o ，指向 Student 类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向 上转型 (upcasting) 。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类 对象，那么该变量就 不能 再访问子类中添加的属性和方法

Student m = new Student();

m.school = “pku”;

// 合法 ,Student 类有 school 成员变量

Person e = new Student();

e.school = “pku”;

// 非法 ,Person 类没有 school 成员变量

属性是在编译时确定的，编译时 e 为 Person 类型，没有 school 成员变量，因而编 译错误。

多态性应用举例

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

public class Test {
    public void method(Person e) {
        // ……
        e.getInfo();
}
public static void main(Stirng args[]) {
    Test t = new Test();
    Student m = new Student();
    t.method(m); // 子类的对象m传送给父类类型的参数e
    }
}

虚拟方法调用(Virtual Method Invocation)

正常的方法调用

Person e = new Person();

e.getInfo();

Student e = new Student();

e.getInfo();

虚拟方法调用(多态情况下)

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父

类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法 确定的。

Person e = new Student();

e.getInfo();

// 调用 Student 类的 getInfo() 方法

编译时类型和运行时类型

编译时 e 为 Person 类型，而方法的调用是在运行时确定的，所以调用的是 Student 类的getInfo() 方法。 —— 动态绑定

方法的重载与重写

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。

Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

多态小结

多态作用： 提高了代码的通用性，常称作接口重用
前提： 需要存在继承或者实现关系有方法的重写
成员方法： 编译时：要查看引用变量所声明的类中是否有所调用的方法。运行时：调用实际new的对象所属的类中的重写方法。
成员变量： 不具备多态性，只看引用变量所声明的类

总结

package com.jyc.p2;
/*
① 面向对象的特征之 继承性

 一.继承性的好处
 减少了代码的冗余，提高了代码的复用性
 便于功能扩展
 为了多态性的使用提供了前提

二.继承性的格式
class A extends B{}
A：子类 派生类 subclss
B ：父类 超类 基类 superclass
 体现：：
    1. 一但子类a继承 子类b后 子类a中获取了b类中声明的结构属性方法
    特别的父类中声明为private的属性或方法 子类继承父类以后，仍任为获取了父类的私有结构
    只是因为封装性的影响 使得子类不能够直接调用父类的结构而已
    2.子类继承父类以后，还可以声明自己特有的属性和方法

 三 java中关于继承的规定
    1.一个类可以有多个子类继承
    2.  java类中的单继承性：一个类只能有一个父类
    3.字符类是相对的概念
    4.子类直接继承的父类 称为直接父类 间接继承的父类：间接父类
    5.子类继承父类以后，就获得了直接父类以及间接父类中声明的属性和方法

  四 如果我们没有显示的定义一个类的父类的话则此类继承于java.lang.object类
      所以的java类（除java.lang.object）都直接或者间接的继承了java.lang.object类
      意味着 所以的java类具有 java.lang.object类声明的功能
      
② 方法的重写
   重写：子类继承父类以后，可以对父类中同名同参数的方法进行覆盖
   应用 重写以后，当创建子类对象以后，通过子类对象调用父类中同名的参数方法时，实际执行的是子类重写的方法

   重写的规定
   方法声明：权限修饰符 返回值 方法名（形参列表）throws异常类型{方法体}
   约定俗称：子类中叫重写的方法，父类中叫被重写的方法
     1.子类重写的方法的方法名和形参列表与父类被重写的方法的法名和形参列表相同
     2.子类重写的方法修饰符不小于父类被重写的方法的权限修饰符
            特殊情况 子类不能重写父类中声明为private权限符
   3.返回值类型：
    父类被重写的方法返回值是void，则子类重写的方法的返回值只能是void
    父类被重写的返回值类型是A类型 则子类重写的方法的返回值类型可以是a类或者a类的子类
    父类被重写的返回值类型是基本数据类型(int)，则类重写的方法的返回值类型必须是相同的基本数据类型（int）
   4.子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
   5.子类和父类的同名参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（非重写）

 ③四种不同权限修饰符
    同一个包中的其他类不可以调用私有的属性方法（private）
    在不同包的子类中，不能调用声明为 private && 缺省 权限的结构
    在不同包下的普通类（非子类）不可以调用声明为 private && 缺省 && protected 权限的属性和方法

④ super关键字的使用
    super 理解为父类的 可以用来调用 属性 方法 构造器

  super的使用
    一.调用属性和和方法
       1. 我们可以在再子类的方法或者构造器中，通过super.属性 或者super.方法 可以显示的调用父类中声明的属性和方法
       2. 单数通常情况下我们习惯省略“super”
       3. 特殊情况，当子类和父类中定义了同名的属性时，我们要想在子类中调用父类声明的属性，则必须显示的使用super.属性的方式表明
        的是父类的属性
       4.特殊情况当子类重写了父类方法以后，我们想在子类的方法中调用父类被重写的方法时，则必须显示的使用super.方法的方式表明
        的是父类的方法
    二.调用构造器
        1.我们可以在子类的构造器中显示的使用super（形参列表）的方式，嗲用父类中声明的指定构造器
        2.super（形参列表）必须声明在子类构造的首行
        3.我们在类的构造器中针对于“this（形参列表）”或  super（形参列表）只能二选一
        4.在构造器的首行，没有显示的声明“this（形参列表）”或  super（形参列表） 则默认调用父类中空参的构造器
        5.在类的构造器中，至少有一个类的构造器使用了“super（形参列表），调用父类中的构造器

⑤ 子类实例化的全过程
   1.结构上来看
        子类继承父类以后就获取了父类中声明的属性和方法
        创建子类的对象，在堆空间中就会加载所有父类中声明的属性和方法

    从过程上来看
        当我们通过子类的构造器创建子类对象时，我们一定会直接或者间接的调用父类构造器，进而调用父类的父类的
       构造器，直到调用了java.lang.Object类中的空参构造器为止，正因为加载了所有的父类构造器，所以才可以看到内存中
       所以的父类中的结构，子类对象才可以考虑进行调用

    虽然创建子类对象时，调用了父类构造器，但是自始至终就创建过一个对象，即为 new的子类对象

⑥ 面向对象特征 多态性
  1.多态性的理解 可以理解为一个事物的多种形态，
  2.何为多态性:对象的多态性 （父类的引用指向了子类的对象） 子类的对象赋给父类的引用

 3.多态的使用
    当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法----虚拟方法调用
    有了对象的多态性以后，我们在编译器，只能调用父类中声明的方法，但在运行期我们实际执行的是子类重写的父类方法
    总结 编译看左边 执行看右边

 4.多态性的使用前提;  1.类的继承关系，2.要有方法的重写
 
 5.对象的多态性 只适用于方法，不适于属性（编译和运行都看左边）









* */
public class ExendsTest {
    public static void main(String[] args) {
        System.out.println("------父类--------");
        Person p1= new Person();
         p1.age=1;
        p1.eat();
        System.out.println("------子类--------");
        Student s1=new Student();
//        s1.eat();
//        s1.sleep();
        s1.setAge(10);
        s1.sleep();
        System.out.println(s1.getAge());
        System.out.println("------老师子类--------");
        Teacher t1=new Teacher("tom",18);
        t1.show();
        System.out.println("------多态性--------");
        Person d1=new Teacher();
        d1.eat();
        System.out.println("------多态性举例--------");
        ExendsTest test= new ExendsTest();
        test.func(new Dog());
        test.func(new Cat());


    }
    public void func(Animal anilm){//Animal anilm=new Dog()
        anilm.eat();
        anilm.shout();

    }
}
class Person{
    String name;
    int age;
     int id=100;//身份证
    public  Person(){
        System.out.println("我无处不在");
    }
    public Person(String name, int age){
        this.name=name;
        this.age=age;
    }
    public  void  eat(){
        System.out.println("吃饭");
    }
    public   void  sleep(){
        System.out.println("睡觉");
        eat();
        show();
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
    private  void show(){
        System.out.println("我是一个人");
    }
    public  Object info(){
        return  null;
    }
}
 class Student extends Person{
//    String name;
//    int age;
        String major;
     public Student(){

     }

     public Student(String name, int age,String major){

         this.name=name;
         this.age=age;
         this.major=major;
     }
//     private   void  sleep(){
//         System.out.println("睡觉");
//     }
     //重写
     public  void  eat(){
         System.out.println("吃饭应该多吃营养的食物");
     }
     public  void  study(){
         System.out.println("学习");
     }
     public void show(){
         System.out.println("我是一个学生");
     }
     public  String info(){
         return  null;
     }
}
class  Teacher extends Person{
    String job;
    int id=1; //工牌
    public Teacher(){

    }
    public Teacher(String name, int age){
        super(name, age);
    }
    public  void  show(){
        System.out.println("name="+name+",age"+age);
        System.out.println("id="+this.id);
        System.out.println("id="+super.id);
        this.eat();
        super.eat();
    }
    public  void  eat(){
        System.out.println("老师吃饭");
    }
}

//多态性的举例
class  Animal{

    public  void eat(){
        System.out.println("动物，进食");
    }
    public  void shout(){
        System.out.println("动物，叫");
    }
}
class  Dog extends  Animal{
    public  void eat(){
        System.out.println("狗吃骨头");
    }
    public  void shout(){
        System.out.println("汪汪汪");
    }
}
class  Cat extends  Animal{
    public  void eat(){
        System.out.println("猫吃鱼");
    }
    public  void shout(){
        System.out.println("喵喵喵");
    }
}