java中封装,继承,多态

类
 1: 属性
    对象是类的实例，类是对象的模板。
 2: 方法 
 3: 构造方法(无返回值)
      语法: 修饰符 名字(){ }
 4: 程序块(无参数 无返回值 无修饰符 无名字) 
      语法:{}
方法重载:
   概念: 一个类的方法 相同的名字 不同的参数列表 这样的一组方法构成了方法重载
   JDK 1.5版本之后 出现了一个新的写法
          int...x 动态参数列表    类型固定  个数可以有多个
          x的本质就是一个数组, 有length 有下标 [index] 不能与数组构成重载 
构造方法:    
   1: 作用、用来创建当前类的对象
   2: 结构和写法、没有返回值,  有返回值类型
   3: 调用、通过New关键字调用
   4: 每一个类都有默认无参数的构造方法 我们自己定义了新的 默认的构造方法即被覆盖
       构造方法也可以构成重载
   5: 构造方法要早于一般方法  和类名相同
this 关键字的使用
   1: 是一个关键字, 代替某一个对象(当前调用属性或方法时的那个对象)
   2: this 可以调用属性和方法
   3: 调用的属性和方法可以在任意地方写 
   4: 只能在构造方法里调用,调用构造方法只用this不用添加名字
程序块(代码块)
   1: 只有一个方法的执行体
   2: 程序块是在每一次调用构造方法之前都会默认自动执行
   3: 程序块没有重载 却可以存多个  按照创建的顺序逐一执行 
   4: 不能来回调用方法,写法可用
        (执行可能产生异常(StackOverFlowError))栈溢出错误
          Exception异常 Error错误( 计算机根本处理不了, 内存溢出 )
编译时异常 javac
运行时异常 java

继承 
    1: 子类继承父类 , 通过一个关键字extends 
    2: 子类的对象可以调用父类中的(public protected)属性和方法 当做自己的来使用
    3: 子类可以添加自己独有的属性和方法
    4: 子类从父类中继承过来的方法不能满足子类的需求,  可以在子类中重写(覆盖)父类的方法  更多指的是内容
    5:  每一个类都有继承类  如果不写继承extends 关键字  ,则继承Object, 若果写了extends 则继承后面那个父类
               object类是任何引用类型的父类(之间或间接的继承Object) Object类没有父类  
    6:  java中继承是单继承  每个类只能继承一个类  可以传递的方式实现多继承           
    7:  继承在内存中的存储形式  
    8: this和Super都是指代词  代替的是对象
         this代替的是当前执行方法时的那个对象  不一定是当前类
          super代替的是当前执行方法时的对象的父类对象    
         this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行
           只是不能在构造方法同时调用
           只能出现在方法中
    9: 子类不可以继承父类的所有资源  (1: private 2: 子类和父类不在同包, 使用默认访问权限  3: 构造方法 )
============================================================================
继承的关系
    1:  构造方法严格来说 不算做子类继承过来的类
             只是单纯的在子类调用构造方法时默认调用构造方法
    2: 程序块严格意义上来说 不算做子类继承过来的  ( 因为子类自己调用不到 没有名字  )
          程序块子类不能直接调用   子类调用构造方法之前
         默认调用父类的构造方法  父类构造方法之前默认执行父类的块
    3: 子类除了能继承父类的属性和方法外       子类还可以添加自己独有的成员 ( 属性和方法 )
    4: 当父类继承过来的方法无法满足子类的需要,  可以进行方法重写 ( override)    
    类和类的关系
          is-a                              继承   实现
         has-a                            组合  聚合   关联 
          use=a(need-a)            依赖    
=================================================================================
                                  方法重写 override                                                   方法重载overload
        1 类              产生两个继承关系的类                                            一的类中的一组方法
                             子类重写父类的方法
        2 权限          子类权限大于或等于父类                                          没有要求
        3 特征          final  static  abstract 
                           父类的方法是 final  子类不能重写
                           父类的方法是 static  子类不存在
                           父类的方法是 abstract 子类必须重写
                           (子类是具体必须重写 否则子类是抽象类 可以不重写)   
        4 返回值     子类可以小于等于父类                                                 没有要求
        5 名字         子类于父类的名字一样                                                子类于父类的名字一样 
        6 参数         子类于父类的参数一样                                               必须不一致                  
        7 异常          如果父类方法抛出运行时异常
                            子类可以不用理会
                           如果父类的方法抛出的是编译时异常
                           子类抛出异常的个数少于等于父类
                           子类抛出异常的类型少于等于父类     
         8方法体      和父类内容不一样                                                         每一个重载的方法 执行过程不一致                       

接口就是一种公共的规范标准  
接口就是一种约定和能力
 定义接口:
   语法:  public interface 类名{}
java.7
 包含有
     1: 常量
     2: 抽象方法
java.8
     3: 默认方法  
                   是可以有方法体 也可以覆盖重写  
                         语法  public default 返回值类型  方法名称 (参数列表 ){}
     4: 静态方法 
                语法 public static 返回值类型  方法名称 (参数列表 ){}
                不能通过接口实现类的对象来调用接口当中的静态方法  
java.9
     5: 私有方法
注意事项
    1:   接口当中的抽象方法,  修饰符必须是两个固定的关键字 ;  public absteact 默认也是public 
    2:   方法的三要素, 可以随意定义     
接口的使用步骤
   1: 接口不能直接使用 ,必须有一个 "实现类" 来实现该接口
   格式
   public class 实现类名称  implements  接口名称{  }
   2: 接口的实现类必须覆盖重写 (实现) 接口中所有的抽象方法
注意事项
  1: 如果实现类并没有覆盖重写接口所有的方法, 那么这个类必须是抽象类
  2: 接口里的变量名字必须完全大写
  3: 没有构造方法, 不能有代码块

  权限修饰符
    public                    公共的          本类     同包   子类   任意类的位置
    protected             受保护的       本类     同包   子类  ( 通过子类对象在子类范围内部访问)  
    默认不写                默认的          本类     同包
    private                  私有的          本类     只能在本类
      1: 权限修饰符可以用来修饰  类本身 和类中的成员 [ 除了程序块 ]
      2: 权限修饰符用来修饰类的时候只有两个可以用 [ public 默认不写 ]
      3:  权限修饰符可以用来修饰类中其他成员                   
==================================================================================                          
  特征修饰符
    final                     最终的 不可以修改  
    static                   静态的
    abstract              抽象的
    native                 本地的     其他语言实现的代码
    transient             瞬时的  短暂的
    synchronized     同步的
    volatile               不稳定的
 =================================================================================
     final
         1: 修饰变量  
                               如果在定义变量的时候没有初始值  可以给变量依次赋值的机会
                               注意变量类型是基本类型还是引用类型  
                               如果是基本类型, 则变量内的值不让更改...........常量
                               如果是引用类型, 则变量内的地址引用不让更改
         2: 修饰属性
                            全局变量  存储在内存的对象内一个空间
                            属性如果没有赋值  有默认值的存在
                            属性用final修饰后  必须给属性付初始值  否则编译报错   
                               其他特点和修饰变量一致   
         3: 修饰方法 
                            子类继承父类的方法   将父类的方法重写(覆盖)
                            final修饰的方法   要求不可以被子类重写(覆盖)  
         4: 修饰类本身          
                                此类不可以被继承  
==================================================================================
  static                   静态的       
        1. 可以修饰 [ 修饰属性  修饰方法   修饰快  修饰(内部类) ]
        2. 特点: 
                    1:  静态元素在类加载时初始化, 创建的非常早 ,此时没有创建对象
                    2:  静态元素存储在静态元素中, 每一个类有一个自己的区域, 与别的类不冲突
                    3:  静态元素只加载一次(只有一份)  全部的类本身和对象共享
                    4:  类名字直接访问它,  静态元素属于类的
                    5:  静态元素区 垃圾回收器 ( Garbage  Collection) 无法管理,   可以粗暴的认为常驻内存
                    6:  非静态元素可以访问静态成员
                    7:  静态成员可以访问静态成员
                    8:  静态成员不能访问非静态成员
                    9:  静态元素中不能出现this或super关键字(静态元素只属于类)                  
==================================================================================
  abstract        抽象的
           1:  修饰类
           2:  修饰方法  
           抽象方法: 只有方法的结构, 没有方法执行体, 称之为抽象方法( 与native区别)
           抽象类:   用abstract修饰的类, 称之为抽象类
           抽象类的特点:
                          1. 含有的成员
                                     属性:  一般的  static final 都可以
                                     方法:  一般的  static final  都可以的  也可以重载
                                                               ----->允许含有抽象方法
                                       块:  一般的 static的块都可以
                                       构造方法:  可以含有构造方法 ,也可以重载
                         2:  抽象类虽然含有构造方法, 但是不能直接调用构造方法创建该类的对象
                              只能通过子类单继承来做事,  构造方法是留给子类创建对象时间接调用
                         3:  类和类之间的关系
                                        抽象类可以直接单继承抽象类
                                        抽象类可以直接单继承具体类
                                        具体类不可以直接单继承抽象类           

内部类
  用法:  外部类名称.内部类名称   对象名=外部类名称().new 内部名称();
  访问外部类变量:  类名.this.变量名
局部内部类:
  在方法里面写;  不能写修饰符 , 将一个类定义在方法里面,作为成员的内部结构,  于临时的局部变量一个层次
   java.8 开始, 只要局部变量不变, 那么final关键字可以省略 
匿名类:
   接口类名  对象名=new 接口类名 { 重写内容 }; 一定要写分号

格式 
   父类名称   对姓名=new 子类名称();
访问成员变量的两种方式
 1: 直接通过对象名称访问成员变量, 看等号左边是谁, 优先用谁,  没有则向上找
 2: 间接通过成员方法访问   
对象向上转型一定是安全的
 父类名称   对姓名=new 子类名称();
一旦向上转型, 就无法调用子类原本特有的内容
对象向下转型
  子类名称   变量名=(子类名称) 父类对象名称;
  if( 对象名  instanceof  类名称){ }
注意事项:
     1: 如果子类中将父类的方法重写,  那么调取方法后执行的结果是子类重写之后的那个结果
     2: 如果子类和父类有同名的属性,             执行父类的属性
     3: 如果父类与子类有同名的方法(重载)    执行子类重写之后的方法
     4: 父类引用指向了子类的对象   能够调用子类重写的方法和父类所有的成员
     5: 编写具有继承关系的父类和子类
     6: 子类重写父类的方法
     7: 父类调用子类的方法