Java基础总结-继承

继承

继承(1.成员变量 2.成员函数 3.构造函数)    
          
1、类是对象的抽象，继承是类(子类)的在抽象(父类)。              
    ->父类是子类共性体现，子类是父类特性的表示方式              
              
2、程序中的继承在代码中的实现？
    例如：public class BMW extends Car{
    }              

3、继承在程序中的特点
    1).可以多层继承，但不可以多重继承
       继承的同时，实现某个接口，算是另类的多重继承(既保存了多重继承的好处，也把弊端排除了)    
    2).子类继承父类非私有的属性和(实例|静态)方法    -----☆☆☆     
    3).子类不能继承父类中的构造方法，但可以通过super关键字访问父类构造方法
       在子类构造方法中使用super(参数列表)--应该放在第一行，不写，默认有条隐式的super();
    4).子类可以重写父类中继承到的实例方法，也可以重写静态方法，但是静态方法没有多态。-----☆☆☆     
    5).子类要想明确调用父类中被重写的实例方法，需要使用super关键字(super.父类方法)
    6).子类除了可以继承父类的属性和方法外，还可以自己定义属性和方法。
    7).在父类中必须有一个public|protected修饰的构造方法，以便子类初始化调用。-----☆☆    
    
    问题1：子类不能继承父类的静态方法吗？
         答：子类可以继承父类的静态方法，也可以重写此方法，只是此方法没有多态.
         因此建议调用父类的静态方法时。类名.方法名(父名.静态方法|子名.静态方法)，静态方法存储在方法区中，子类仅仅持有指向它的引用
                 
           
    问题2：子类继承父类非私有的属性和实例方法，那么是不是每个子类实例都有一份父类的属性，多个子类同时修改父类的静态变量是否会影响其它子类
         答：子类实例都有一份自己从父类继承过来的非static属性(动态绑定到子类上)
                 在创建子类对象时，都会调用父类的构造方法初始化一次父类属性(相当于创建了一个父类对象，只是此对象的引用只有子类实例持有super指向)
             父类的static变量也继承了，但却是多个子类共享，一处变动重新赋值，其他调用得到的值也将随着改变(static成员静态绑定到类上) 
                 (静态数据存储在方法区)其实是子类持有父类的引用,同一个引用指向相同的static变量
                 
    总结：被static修饰的变量和方法独立于该类的任何对象，也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类加载，java虚拟机就能根据类名在运行时
            数据区的方法区中找到他们    
            
4、方法重写(Override)
    1).重写发生在继承关系中
    2).重写的方法需要和父类中的方法名字相同参数列表相同
    3).子类重写方法的访问修饰符允许比父类更大，但不能更小
    4).通过关键字super访问父类中的方法
    5).重载：只看同名函数的参数列表
      重写：子父方法要一模一样(静态方法也可以重写，但是没有多态)
              1.方法名一样
              2.参数列表一样
              3.返回值，一般是一样的，可以是更小的子类型
              4.修饰词，一般是一样的，可以是更加扩大
              5.异常，一般是一样的，可以是子类型或者子集

    6).重写的目的：允许动态的为父类方法中添加一些行为(子类特有的或新的)  
    7).静态覆盖静态(只能)，反之非静态也只能覆盖非静态。-----☆☆☆    

5、继承关系中对象的构建过程
    1)加载父类，加载子类
    2)分配父类空间，分配子类空间
    3)默认初始化父类属性，调用父类构造方法
    4)默认初始化子类属性，调用子类构造方法(显示初始化|构造代码块|自定义初始化)    
    
6、变量 -----☆☆☆☆
   规则：
    实例|构造函数中调用:
        1)(this.成员变量)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
        2)(super.成员变量)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
            
    静态函数中调用:
        1)(静态变量)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
    
    
  如果子类中出现非私有的同名实例变量时：
    1)访问本类中的变用this，访问父类中的同名变量用super.变量名
    2)(this.实例变量)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找
      (super.实例变量)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
      
    3)都存在与堆内存中，每个子类实例都有一份父类中的实例属性
       在创建子类对象时，都会调用父类的构造方法初始化一次父类属性(相当于创建了一个父类对象，只是此对象的引用只有子类实例持有super指向)
    
    4)变量在父类中是private修饰，则子类只能通过父类提供的方法区访问此变量    
    
  如果子类中出现非私有的同名静态变量时：
    1)(this.静态变量)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找
    2)(super.静态变量)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
    
    调用静态变量时，建议：类名.变量名 
               
7、函数 -----☆☆☆☆
   规则：
    实例函数中调用:
        1)(this.成员函数)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
        2)(super.成员函数)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
    
    静态函数中调用:
        1)(静态函数)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
    
    构造函数中调用:-----☆☆☆☆☆
        1)(this.实例函数)会优先在this实例(多态)所在的类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
        1)(super.实例函数)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
        
        1)(this.静态函数)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
        1)(super.静态函数)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
     
    1)构造函数中当子父类中定义了一模一样的函数，运行结果：子类(实例对象所在的类)的函数在运行(多态的体现)
    
    
8、子父类中的构造函数(子类实例化过程)
    1)子类中所有的构造函数，默认第一行都有一句隐式语句super();默认调用的是父类中的空参数的构造函数(隐式--默认)
    2)当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的父类构造函数(显式--指定)
    3)子类的构造函数第一行也可以手动指定this()语句来访问本类中的构造函数，子类中至少有一个构造函数要么this(),要么是super()语句;
    
    1.子类中的构造函数为什么第一句是隐式的super()语句？
      原因：子类会继承父类中非私有的属性和方法，所有子类在初始化时，必须先到父类中去执行父类的初始化动作，才可以更方便的使用父类中的内容。
     
    2.父类构造函数中是否有隐式的super语句？
      原因：有，只要是构造函数默认第一行都是super()；

    java体系在设计时，定义了一个所有对象的父类Object，如果这个类没有显示的指定继承哪个类，那么默认继承java.lang.Object此类(包括数组)  
    
9、继承的弊端
    1).打破封装性
      如何能保留自己想封装的，不让其打破，final修饰符提供安全的一种方式。

总结：1.java体系在设计时，定义了一个所有对象的父类Object，如果这个类没有显示的指定继承哪个类，那么默认继承java.lang.Object此类(包括数组)  
      2.创建任何对象总是从该类所在继承树最顶层的构造方法开始执行，然后依次向下执行，最后才执行本类的构造方法
      3.学习继承体系时，应该先参阅顶层类中的内容，了解这个体系的基本功能，使用这个体系时，创建最子类的对象(看顶层，建底层)     
      4.该使用继承还是组合？-->最清晰的判断办法就是问一问自己是否需要从新类向基类进行向上转型。      
      
☆☆☆☆☆☆
  规则：
    实例函数中调用:
        1)(this.成员变量|函数)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
        2)(super.成员变量|函数)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
        
    静态函数中调用:
        1)(静态成员)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)

    构造函数中调用:
       相同：1)(super.成员变量|函数)此类的直接父类中查找，如果没有，会逐步向上(父类的父类)查找，无，则报错。
             2)(this.成员变量)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
         3)(this.静态函数)会优先在本类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)
                
       不同：1)(this.实例函数)会优先在this实例(多态)所在的类中查找，如何本类中没有，才会逐步向上(父类)查找---通用(父类|子类|接口)  

        构造函数中实例函数有多态(总结：编译看本类，运行看子类)         
            

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。