Java中的面向对象详解

类：种类、分类的意思。把具体事物的共同特征抽取出来归为一类， 类。
         抽象的：
         类包含：
            属性：静态的（年龄、体重、身高等）
            行为：动态的（吃饭、睡觉、说话）
     
       注意事项：
           类名要和文件名一致（大写）。
           类名要有意义。
           类名上面加一行注释
     
       标准类：
           属性
           方法
           有参/无参构造方法
           toString
     

    
      对象： 具体的一个事物，是类的具体体现。
     
      抽象： 提取共同特征
     
      类和对象之间的关系：
         类是对象的抽象，
         对象是类的体现
     
      姓名    人      动物
      对象--->类---->抽象类
     
     
      类  对象   抽象

 封装：
         封装就是把一个事物包装起来，不让别人知道内部的细节，从而保证安全性。
     
      java里的封装：  （封装是面向对象三大特征之一）
        1 把成员变量私有化    private(私有的)
        2 给成员变量添加set  get方法
     
     
        public   private
     

    
      访问修饰符： 4个,最常用的private  public
    
             private：私有的，只能在本类中使用
             default：同一个包里面可以用
             protected：同一个包或者子类
             public：   所有地方
     
       注意： private一般用来修饰属性
             public一般用来修饰方法
     

    
      重点： 本质文件夹，域名倒着写
     
      包： package 本质就是一个文件夹，把功能相同的类放到一个地方，方便管理。
      怎么写： 域名倒写。  DNS
      包名： 全限定名（可以区分相同类名的不同类）
      import  导包，引入文件的意思
      package:  告诉别人，我这个类是在那个包里面的。
     

    
      static :
           static 修饰成员变量和方法。被static修饰的只能static修饰的，不能调用非static修饰的  （需要记忆）
           static修饰的成员变量和方法属于类的， 非static修饰的属于对象。
           出生时间： 类是早于对象创建的。
               类是： 方法区（元空间）
               对象： 堆
     
      final: （需要记忆）
          变量：值不能发生变化.
          类： 不能被继承.  (太监类)
          方法：不能被重写.
      类：
      对象：
      抽象：
      举例子： 类和对象的例子（区别）
     
     
      封装：
        1 成员变量私有化
        2 成员变量 set  get方法
     
     
      访问修饰符： private、public
        private：
        defalut：
        protected：
        public：
     
       非访问修饰符：
           static:
           final：
     
      包：
           文件夹，方便管理
           域名倒着写
           （import  package）
     面向过程和面向对象的区别：
      
        继承：  extends
              继承父类非private的属性和方法   （一般继承方法）
      
        继承的使用场景:
      
      
        this和super
         1 都可以代表对象，对象可以调用属性和方法  this.xx  super.xx
         2 构造方法里面怎么用。 this（）  super（） 代表调用构造方法，并且只能在构造方法里面被调用，而且必须放在第一行
      
      
         抽象类：
             抽象类和普通类的区别：
                  1 普通类里面不能有抽象方法、抽象类里面可以有普通方法
                  2 抽象类里面可以有构造方法，但是不能实例化对象
                  3 普通类继承了抽象类，必须重写抽象方法

面向过程和面向对象的区别：
      
        继承：  extends
              继承父类非private的属性和方法   （一般继承方法）
      
        继承的使用场景:
      
      
        this和super
         1 都可以代表对象，对象可以调用属性和方法  this.xx  super.xx
         2 构造方法里面怎么用。 this（）  super（） 代表调用构造方法，并且只能在构造方法里面被调用，而且必须放在第一行
      
      
         抽象类：
             抽象类和普通类的区别：
                  1 普通类里面不能有抽象方法、抽象类里面可以有普通方法
                  2 抽象类里面可以有构造方法，但是不能实例化对象
                  3 普通类继承了抽象类，必须重写抽象方法

/  
       面向过程： C语言， 以方法为主体，所有的功能都是通过方法之间的调用完成的。
       面向对象： java，C++、C#、python、javascript 以对象为主体、对象和对象之间的调用。
      /

    /  
       继承： 子类拥有父类的属性和方法。（面向对象的三大特征之一）
           子类：
           父类： （基类、超类）
      
      
        特点：
            1 子类不能继承父类的private属性和方法
            2 类的继承是单继承，但是可以多重继承。
            3 一般属性用private修饰，方法用public修饰，所以我们以后开发的工作里面，主要是继承方法的。
      
      
      
        格式：  extends
           public 子类 extends 父类{
      
           }
      
        使用场景：
            如果多个类有共同的属性和方法，那么我们可以把这些类中共同的属性和方法放到父类中，让这些类（子类）去继承父类，减少代码的重复性。
      /

 this、super
         都可以代表对象，对象可以调用属性和方法  this.xx  super.xx
         构造方法里面怎么用。 this（）  super（） 代表调用构造方法，并且只能在构造方法里面被调用，而且必须放在第一行
      
       this：
            1 对象本身，new的对象就是这个this
            2 this()  调用构造方法，可以有参数，一般只在构造方法里面
            3 如果构造方法里面调用this()，只能放在第一行，否则报错。
      
      
       构造方法补充：
           如果类里面没有写构造方法，那么系统默认给一个无参构造方法。
           如果类里面有有参构造方法，那么系统不会给无参构造方法。
      
       super
          1 代表的就是父类对象
          2 子类的构造方法里面，默认第一句会添加super()
          3 如果子类构造方法手动调用super(),必须放在第一行

抽象类： 把具有共同特征的类提取出来就是抽象类。
      
       特点：
         1 不能实例化对象。
         2 抽象类就是当爹的。（抽象类就是用来被继承）
      
       格式：
         在创建类的时候，class前面加上abstract
      
      /

    /  
       抽象方法：被abstract修饰的方法就叫抽象方法，没有方法体。
          如果普通类继承了抽象类，那么抽象类中的抽象方法必须被重写，否则报错
      /

    /  
       抽象类和普通类的区别：
         1 普通类里面不能有抽象方法、抽象类里面可以有普通方法
         2 抽象类里面可以有构造方法，但是不能实例化对象

抽象类和普通类的区别：
         1 普通类里面不能有抽象方法、抽象类里面可以有普通方法
         2 抽象类里面可以有构造方法，但是不能实例化对象

方法重写： 在继承或者实现关系里面，如果子类和父类的方法名、参数列列表、返回值完全一致，就是方法重写。修饰符>父类，异常<父类
      
             1 在继承或者实现关系里面.
             2 方法名相同
             3 参数列表
             4 返回值
             5 修饰符
             6 异常
      
       方法重写的目的？
           父类的方法不适用子类，那么子类就要考虑重新定义这个方法

1 接口的特点：
           1 接口里面的方法都是抽象方法    public abstract
           2 接口里面的变量都是静态常量    public static final
           3 接口里面没有构造方法，所以也不存在实例化对象的概念。
           4 接口和接口可以多继承
           5 类和接口之间是实现关系，可以多实现。
      
       2 多态：
           1 三个条件
           2 使用场景
      
       3 异常
           1分类
            编译时异常
            运行时异常
           2 怎么解决异常  2种方式
           3 制造异常     throw  new RuntimeException();

1 接口： 定义规范的，主要是由抽象方法构成的。
            （一个类实现了接口，就要按照规矩重写接口里的所有抽象方法）
      
           关键字：
                定义接口：interface
                实现接口：implements
      
           接口中定义抽象方法的时候可以省略： public abstract
      
      
       2 接口的特点：
           1 接口里面的方法都是抽象方法    public abstract
           2 接口里面的变量都是静态常量    public static final
           3 接口里面没有构造方法，所以也不存在实例化对象的概念。
           4 接口和接口可以多继承
           5 类和接口之间是实现关系，可以多实现。
          [6 接口中的方法不能用static修饰]

多态：
            同一个数据类型的对象，使用相同的方法，表现出不同的结果。(面向对象的三大特征之一)
      
      必备的条件：
           1 继承或者实现
           2 方法重写
           3 父类的引用指向子类的对象
      
      
       使用场景：
           我们在定义方法的时候，方法的参数用父类类型，调用方法的时候传入子类类型，这样可以提供代码的扩展性。
      
       注意事项：
           满足多态的情况下，
              1 父类的引用不能调用子类特有的方法。
              2 如果父类有，子类没有，可以调用（继承）

异常： 代码发生的错误（报错）
           1 错误： 没办法挽回，纠正。  栈溢出（递归的时候）
           2 异常： 发生错误以后可以捕获，并且处理。
                |- 运行时异常： 代码跑起来以后报的错
                 1.NullPointerException(空指针异常)
                 2.ArithmeticException（运算非法异常）
                 3.IndexOutOfBoundsException(数组越界异常)
                 4.ClassCastException(类转换异常)
                 5.ArrayStoreException(数据存储异常，操作数组时类型不一致)
                 6.BufferOverflowException(字节溢出异常—IO流操作)
      
                |- 编译时异常： 代码还没跑就报错了
                1.ClassNotFoundException(类找不到异常)
                2.FileNotFoundException（编译文件夹中找不到，就是发布到tomcat中的，不是工程中）
                3.SQLException ：提供有关数据库访问错误或其他错误的信息的异常。（ 比如SQL语句写错，访问的表不存在，连接数据库失败等等）
                4.IOexception：IO流异常。一般在读写数据的时候会出现这种问题。
                5.EOFException:当输入过程中意外到达文件或流的末尾时，抛出此异常。
        异常解决：
             1 throws   把错误给了别人，谁调用谁解决，如果一层一层往上推，最终给了jvm   不推荐用（做练习的时候用用就行了）
             2 try...catch...finally   自己的错误字节解决
      
      
        制造异常：
            throw  new RuntimeException();