构造方法 1.用来描述对象创建的过程，构造方法在对象创建的过程中被调用 2.如果类中没有写构造方法，系统会默认提供一个无参的构造方法；如果类中出现了构造方法，系统不会提供默认的无参构造方法  语法： 访问修饰符 构造方法名（）{   //初始化代码  }

方法重载  原则：1.方法名相同        2.参数列表不同        3.与返回值，访问修饰符无关 方法重写;  原则：1.方法名相同        2.参数列表相同        3.返回值类型相同或者是其子类        4.访问权限不能严于父类

this关键字（代表当前对象，在有参构造方法中不能省略）

封装的好处： 1.隐藏类的实现细节 2.只能通过规定方法访问数据 3.方便加入控制语句 4.方便修改实现

封装的步骤： 1.修改属性的可见性 2.创建get，set方法 3.在get，set方法中加入属性 4.实现get，set方法

static关键字（修饰：属性，方法，代码块，内部类）  修饰的属性：属于对类所有实例对象共享的变量        方法：属于静态方法，可以直接类名.方法名（）调用      代码块：在类加载的时候执行，因为类只加载一次所以static代码块也只运行一次，一般是使用static代码块来加载一些静态资源

static修饰与非static修饰的区别     static，非private修饰  非static，private修饰     属性  类属性，类变量  实例属性，实例变量     方法  类方法   实例方法           类名.属性 调用方法  类名.方法（）   对象.属性           对象.属性   对象.方法（）           对象.方法（）     归属  类    单个对象

继承的优点： 1.提高代码的重用性 2.提高代码的后期的可维护性

使用继承  编写父类 class Pet{ //公共的属性和方法}  编写子类继承父类 class extends Pet{ //子类特有的属性和方法}

继承的步骤： 1.将多个类的属性和方法提取出来，建一个父类 2.在子类后面使用extends关键字完成继承 3.在子类中可以调用父类的代码 注意：在java中属于单继承，在extends关键字后面只能有一个父类

super关键字（代表父类对象）super.方法名 1.只能必须出现在子类的方法和构造方法中 2.在构造方法中调用且必须是第一句 3.不能访问父类的private成员 4.可以访问父类的成员

不能被继承的父类成员 1.private成员（1.可以修饰属性和方法2.本类，同包，子类可以访问） 2.子类与父类不在同包，使用默认访问权限的成员 3.构造方法

访问修饰符protected 1.可以修饰属性和方法 2.本类，同包，子类可以访问

访问修饰符： private   friendly   protected   public

多重继承关系： 父类属性->父类构造方法->子类属性->子类构造方法

对象初始化过程 1.在创建类之前，检查类是否已加载，如果没有价值就先价值父类的文件，再加载本类的文件 2.分配对象的空间，递归分配所有的父类和子类的属性空间 3.给属性赋值 4.调用父类的构造方法 5.调用本类的构造方法

abstract关键字 1.修饰类，抽象类（-public abstract class 类名{} -抽象类用来表示一些抽象的概念）  抽象类的特点：  1.抽象类不能被实例化  2.抽象类中可以有属性，方法，构造方法，都是用来给子类继承  3.抽象类中的方法不一定全部都是抽象方法 2.修饰方法，抽象方法（-访问修饰符 abstract 返回值类型 方法名 （参数列表）； -抽象方法不需要自己实现，由子类来实现）  抽象方法的特点：  1.抽象方法没有方法体  2.抽象方法必须出现在抽象类中  3.一个类继承抽象类之后必须要实现里面的所有的抽象方法 3.抽象类可以继承抽象类

final关键字（最终的） 1.可以用来修饰类，属性，方法 2.修饰的类不能再被继承 3.修饰的方法，不能再被子类重写 4.修饰的变量，初始化以后值不能再发生改变 5.修饰的引用类型的变量，引用地址不能发生改变，但是只限定的是第一层，引用类型的属性是可以发生改变的

abstract，final的对比  abstract可以用来修饰类和方法，不能用来修饰属性和构造方法  final可以用来修饰类，方法和属性，不能修饰构造方法

多态的实现（两个要素:1.子类重写父类方法2.使用父类的类型） 1.编写父类 2.编写子类，子类重写父类方法 3.运行时，使用父类的类型，子类的对象

子类到父类的转换（向上转型） 父类到子类的转换（向下转型）-将一个指向子类对象的父类引用赋给一个子类的引用

使用多态的两种形式： 1.使用父类操作为方法形参实现多态 2.使用父类操作为返回值实现多态

instanceof运算符（用来判断一个对象是否属于一个类或者实现了一个接口） 通常和强制类型转换结合使用，提高代码的健壮性 语法 对象 instanceof 类或接口

多态的好处：多态可以减少类中代码量，可以提高代码的可扩展性和可维护性

接口  语法 [修饰符] interface 接口名 extends 父接口1，父接口2，...{           //常量定义           //方法定义     }       class 类名 extends 父类名 implement 接口1，接口2，...{    //类成员                          }

接口的特征： 1.接口不可以被实例化 2.实现类必须实现接口的所有方法 3.实现类可以实现多个接口 4.接口中变量都是静态常量

接口的原则： 1.可以降低代码间的耦合性 2.提高了代码的可扩展性和可维护性

接口和抽象类的区别：  抽象类利于代码复用  接口利于代码维护

interface关键字（C#） 语法 [修饰符] interface 接口名：父接口1，父接口2，...{          属性定义          方法定义        }      class 类名：父类名，接口1，接口2，...{}

implements关键字  一个可以实现多个接口，多个接口之间使用“.”隔开

接口有比抽象类更好的特征: 1.可以被多继承 2.设计和实现完全分离 3.更自然的使用多态 4.更容易搭建程序框架 5.更容易更换实现

内部类（在类里面还有一个类，把class写入class中）-最大作用：封装 1.静态内部类  使用static修饰，声明在类体中  静态内部类中可以访问外部类的静态成员 2.成员内部类  声明在类体中，不使用static，具有类的成员特征。也就是必须有类的实例才能创建内部类实例  内部类实例可以访问共享外部类成员变量 3.局部内部类  把类声明在方法中，就是局部内部类，作用域类似局部变量 4.匿名内部类（回调模式）  匿名类可以写在任何地方，就像一般的语句  语法更像是创建对象： Date d=new Date（）{//...}  匿名类是对原类的一个继承，同时创建了实例，{}就是继承以后的类体  类体中可以使用所有类的语法  匿名类不能写构造器  匿名类可以从抽象类或者接口继承，必须提供抽象方法的实现

异常（Exception）-指在程序中的运行过程中所发生的不正常的事件，它会中断正在运行的程序                                                                                    错误（Error）

if-else缺点： 1.代码臃肿，加入了大量的异常情况判断和处理代码 2.减少了编写业务代码的时间，必然影响开发效率 3.很难穷举所有的异常情况，程序仍旧不健壮 4.异常处理代码和业务代码交织在一起，影响代码的可读性，加大日后程序的维护难度

if（in.hasNextInt()）:判断输入是否是int类型，如果是返回true，否则返回false

java的异常处理通过5个关键字来实现： try   catch   finally   throw   throws try，catch，finally捕获异常 throws声明异常（声明某个方法可能抛出各种异常） throw抛出异常

使用try-catch块捕获异常 第一种情况：正常  try  catch  try-catch块后的代码段 第二种情况：出现异常      发生异常    try ------->产生异常对象         进入catch块   |  catch <----------异常类型匹配    |程序继续进行  try-catch块后的代码段 第三种情况：异常类里不匹配      发生异常  try ------->产生异常对象       | catch        异常类型不匹配      |程序中断运行      \ try-catch块后的代码段

在catch块中处理异常  加入用户自定义处理信息   System.err.println("自定义内容");  调用方法输出异常信息   e.printStackTrace()  异常对象常用的方法   void printStackTrace()：输出异常的堆椎信息   String getMessage()：返回异常信息描述字符串，是printStackTrace()输出信息的一部分

Java异常机制 1.当代码运行到可能出现异常的代码是，由程序员或JVM抛出异常对象。异常对象会记录异常的相关信息 2.异常对象抛出之后，就会去寻找异常处理的相关代码（catch），如果找到了，异常到此结束 3.如果未找到，异常对象会继续上抛，寻找异常处理的代码 4.如果到main还未找到异常处理的代码，就会由main将异常抛给虚拟机 5.异常抛出的每一层代码都会被中断

常见的异常类型 Exception    异常层次结构的根类 ArithemticException   算数错误情形，如零作除数 ArrayIndexOutOfBoundsException  数组下标越界 NullPointerException   尝试访问null对象成员 ClassNotFoundException   不能加载所需的类 InputMismatchException   欲得到的数据类型与实际输入的类型不匹配 IllegalArgumentException  方法接收到非法参数 ClassCastException   对象强制类型转换出错 NumberFormatException   数字格式转换异常，如把"abc"转换成数字

try-catch-finally      try       |有异常     catch块  System.exit();  中断程序，退出java虚拟机        finally块

存在return的try-catch-finally块      发生异常   try---1--->产生异常对象       进入catch块   |  catch<----2-----异常类型匹配  return    |   |3执行finally块    4   |---> 执行return| 退出方法  |        |  |       finally

try-catch-finally块使用规则    try{//必须出现，且只能出现一次       }catch（Exception ex）{//可以出现0-n次，                              //如果没有catch，就必须有finally       }finally{//可以出现0-1次       }

多重catch块 1.排序catch语句的顺序，先子类后父类 2.发生异常时按顺序逐个匹配 3.只执行第一个与异常类型匹配的catch语句       发生异常    try-------->产生异常对象                      |    catch      与异常类型1不匹配          进入catch块    |    catch<-----------与异常类型2不匹配      |      |  catch      |    return的try-catch-finally块后的代码段

java中的异常分为两类： 1.运行时异常 2.检查异常/检测异常

自定义异常 第一步：写一个异常类继承Exception 第二步：手动实现Exception的所有各种方法

日志分类 1.SQL日志 2.异常日志 3.业务日志

开源日志记录工具log4j  控制日志的输出级别  控制日志信息输送的目的地是控制台，文件  控制每一条日志输出格式

使用log4j记录日志步骤 1.在项目中加入log4j的JAR文件 2.创建log4j.properties文件 3.配置日志信息 4.使用log4j记录日志信息

Object  在java类继承结构中java.lang.Object类位于顶端  如果定义了一个java类时没有使用extends关键字声明其父类，则其父类为java.lang.Object类  Object定义了"对象"的基本行为被子类默认继承  public class Foo{...}  等价于      一切皆对象  public class Foo extends Object{...}

toString  Object类中定义toString方法，用于返回对象的字符表示（一个可以表示该对象属性内容的字符串）  所有java类都继承了toString方法，Object类toString方法返回的字符串的形式为："类名@hashCode值"  Java类可以根据需要重写toString方法返回更有意义的信息

equals  Object的equals方法用于对象的"相等"逻辑  equals方法的逻辑为：如果认为调用方法的对象（this）与参数对象相等返回true，否则返回false  按照Object类equals方法的调用，只有在this和obj是同一个对象时才返回true，java可以根据需要重写的继承自Object的equals方法

hashCode  默认的hashCode()值是当前堆对象地址转换的一个整数，这个整数不是内存地址  一般使用对象的OID值作为hashCode的值  OID是对象的唯一编号，在项目中一般采用数据库生成OID，也就是数据库中的"主键"

封装类（包装类）     包装类   对应的基本类型 java.lang.Integer      int java.lang.Long       long java.lang.Double      double java.lang.Character      char java.lang.Boolean      boolean java.lang.Byte       byte java.lang.Float       float java.lang.Short       short

编译器对包装类的支持 "拆箱"：运算前先包装类对象所封装的基本类型数据 "装箱"：运算后再讲结果封装成包装对象

JDK5t增加了自动"拆箱"和"装箱"的功能 Integer i=100； Integer j=200； Integer i+j； 事实上，JDK5的自动"装箱"和"拆箱"是依靠JDK5的编译器在编译时的"预处理"工作

Date（表示特定的瞬间，精确到毫秒）类long（表示时间，日期）  getTime Date->毫秒差 用于获取对应的毫秒差  setTime 毫秒差->Date 用于通过毫秒差设置时间 //无参的构造方法，构造的Date对象封装当前的日期及时间信息  Date date=new Date(); SimpleDateFormat类（用于实现Date对象和字符串表示的日期信息的转换）  常用格式字符串      字符 含义  示例       Y  年  YYYY年-2017年；YY-17年       M         月              MM-01月；M-1月       d         日              dd-06日；d-6日       E        星期             E-星期日（sun）       a     AM或PM标识          a-下午（PM）       H    小时（24小时）       a-h时-下午12时       h    小时（12小时）       HH：mm：ss-12:46:33       m        分钟             hh(a):mm:ss-12(下午):47:48       s         秒

Calendar及GregorianCalendar（用于封装日历信息）  主要作用在于其方法可以对时间分量进行运算

Calendar c=Calendar.getlnstance（）；  getlnstance方法将根据系统的地域信息返回不同的Calendar 类的实现

getActualMaximum（可以返回某个时间分量最大值）  add方法可以对某一日期分量增加数值（减少）

接口 Collection-List，Set List：ArrayList，LinkedList Set;hashSet,TreeSet Map:hashMap,TreeMap

Collections（集合工具类）-->提供了对集合进行排序，遍历等多种算法实现 Collection接口

java面向对象