1.类的概念 对象的概念
  1)现实世界是由很多很多对象组成的
    基于对象抽出类
  2)对象:真实存在的单个的个体
    类:类别/类型，代表一类个体
  3)类中可以包含:
    3.1)所有对象所共有的属性/特征---------------成员变量
    3.2)所有对象所共有的行为--------------------方法
  4)一个类可以创建多个对象，
    同一类型所创建的对象，结构相同，数据不同
  5)类是对象的模板，对象是类的具体的实例
 

2.构造方法

0.方法的签名:方法名+参数列表
1.方法的重载(Overload):
  1)在同一个类中，方法名称相同，参数列表不同
  2)编译器在编译时根据方法的签名自动绑定调用的方法
2.构造方法:构造函数、构造器、构建器
  1)给成员变量赋初值
  2)与类同名，没有返回值类型
  3)在创建(new)对象时被自动调用
  4)若自己不写构造方法，则编译器默认一个无参构造方法
    若自己写了构造，则不再默认提供
  5)构造方法可以重载

3.this:指代当前对象，哪个对象调方法它指的就是哪个对象
       只能用在方法体中，方法中访问成员变量之前默认有个this.
  this的用法:
    1)this.成员变量名-----------------访问成员变量
    2)this.方法名()-------------------调用方法(一般不用)
    3)this()--------------------------调用构造方法

4.null:空，没有指向任何对象
       若引用的值为null，则该引用不能再进行任何操作了，
       若操作则发生NullPointerException空指针异常

5.引用类型之间画等号:
  1)指向同一个对象
  2)通过一个引用对数据的修改会影响另一个引用对数据的访问
    eg:房子钥匙
  基本类型之间画等号:
  1)赋值
  2)对一个变量的修改不会影响另一个变量的值
    eg:身份证复印件

6.内存管理:由JVM管理的
1)堆:存储new出来的对象(包括成员变量)
2)栈:存储局部变量
3)方法区:存储.class字节码文件(包括方法)

 

1.引用类型数组:
  1)Airplane[] as = new Airplane[3];
    as[0] = new Airplane();
    as[1] = new Airplane();
    as[2] = new Airplane();
    as[1].x = 100; //给as中第2个元素的x赋值为100
  2)Airplane[] as = new Airplane[]{
      new Airplane(),
      new Airplane(),
      new Airplane()
    };
  3)int[][] as = new int[3][];-------------数组的数组
    as[0] = new int[2];
    as[1] = new int[3];
    as[2] = new int[2];
    as[1][0] = 100; //给as中第2个元素中的第1个元素赋值为100
  4)int[][] as = new int[3][4];------------数组的数组
    for(int i=0;i<as.length;i++){
      for(int j=0;j<as[i].length;j++){
        as[i][j] = 100;
      }
    }

2.继承:
  1)作用:实现代码复用
  2)通过extends来实现继承
  3)超类/父类:所有派生类所共有的属性和行为
    派生类/子类:派生类所特有的属性和行为
  4)派生类继承超类后，派生类具有:超类的+派生类的
  5)一个超类可以有多个派生类
    一个派生类只能有一个超类----------单一继承
  6)继承具有传递性
  7)java规定:构造派生类之前必须先构造超类
    若派生类的构造方法中没有调用超类的构造方法，
    -------则默认super()调用超类的无参构造方法
    若派生类的构造方法中调用了超类的构造方法，
    -------则不再默认提供
    super()调用超类的构造方法必须位于派生类构造方法的第一行
3.super:指代当前对象的超类对象
  super的用法:
    1)super.成员变量名-------------访问超类的成员变量
    2)super.方法名()---------------调用超类的方法(年后回来说)
    3)super()----------------------调用超类的构造方法

 

1.向上造型:
  1)超类型的引用指向派生类的对象
  2)能点出来什么，看引用的类型

 

1.方法的重写(Override):重新写、覆盖
  1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
  2)重写方法被调用时，看对象的类型
  3)遵循"两同两小一大"原则:
    3.1)两同:
        3.1.1)方法名相同
        3.1.2)参数列表相同
    3.2)两小:
        3.2.1)派生类方法的返回值类型小于或等于超类方法的
              3.2.1.1)void时，必须相等
              3.2.1.2)基本类型时，必须相等
              3.2.1.3)引用类型时，小于或等于
        3.2.2)派生类方法抛出的异常小于或等于超类方法的------异常之后讲
    3.3)一大:
        3.3.1)派生类方法的访问权限大于或等于超类方法的------明天讲
2.重写与重载的区别:-----------常见面试题
  1)重写(Override):
    1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
    1.2)遵循"运行期"绑定，看对象的类型调用方法
  2)重载(Overload):
    2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
    2.2)遵循"编译期"绑定，看引用/参数的类型绑定方法

 

1.package:
  1)作用:避免类名的冲突
  2)包名可以有层次结构
  3)类的全称: 包名.类名，同包中的类不能同名
  4)建议:包名所有字母都小写
  import:
  1)同包中的类可以直接访问，
    不同包中的类不能直接访问，想访问有如下两种方式:
      1.1)先import声明类再使用类-----建议
      1.2)类的全称-------------------太繁琐，不建议

2.访问控制修饰符:
  1)public:公共的，任何类
  2)private:私有的，本类
  3)protected:受保护的，本类、子类、同包类
  4)默认的:什么也不写，本类、同包类
  说明:
    1)类的访问修饰为public或默认的
    2)类中成员的访问修饰如上四种都可以

3.final:最终的、不可改变的------应用率低
  1)修饰变量:变量不能被改变
  2)修饰方法:方法不能被重写
  3)修饰类:类不能被继承

4.static:静态的
  1)静态变量:
    1.1)由static修饰
    1.2)属于类的，存储在方法区中，只有一份
    1.3)常常通过类名点来访问
    1.4)何时用:所有对象共享的数据(图片、音频、视频等)
  2)静态方法:
    2.1)由static修饰
    2.2)属于类的，存储在方法区中，只有一份
    2.3)常常通过类名点来访问
    2.4)静态方法没有隐式的this传递，
        静态方法中不能直接访问实例成员
    2.5)何时用:方法的操作仅与参数相关而与对象无关
  3)静态块:
    3.1)属于类的，在类被加载期间自动执行
        因类只被加载一次，所以静态块也只执行一次
    3.2)何时用:加载/初始化静态资源(图片、音频、视频等)

 

1.static final常量:
  1)必须声明同时初始化
  2)通过类名点来访问，不能被改变
  3)建议:常量所有字母都大写，多个单词之间用_分隔
  4)编译器在编译时将常量直接替换为具体的值，效率高
  5)何时用:数据经常使用，永远不变

2.抽象方法:
  1)由abstract修饰
  2)只有方法的定义，没有方法具体的实现(连大括号都没有)

3.抽象类:
  1)由abstract修饰
  2)包含抽象方法的类必须是抽象类
    不包含抽象方法的类也可以声明为抽象类------我乐意
  3)抽象类不能被实例化
  4)抽象类是需要被继承的，派生类:
    4.1)重写抽象类中的所有抽象方法-----常用
    4.2)也声明为抽象类-----------------不常用
  5)抽象类的意义:
    5.1)封装派生类共有的属性和行为---------代码复用
    5.2)为所有派生类提供一种公共的类型-----向上造型
    5.3)可以包含抽象方法，为所有派生类提供统一的入口
        派生类的具体行为不一样，但入口是一致的

 

1.成员内部类:应用率不高
  1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
  2)内部类通常只服务于外部类，对外不具备可见性
  3)内部类对象通常是在外部类中创建的
  4)内部类中可以直接访问外部类的成员(包括私有的)
    内部类中有个隐式的引用指向了创建它的外部类对象
      eg: 外部类名.this

2.匿名内部类:
  1)若想创建一个类(派生类)的对象，并且对象只被创建一次，
    此时该类不必命名，称之为匿名内部类
  2)匿名内部类中若想访问外部的变量，该变量必须是final的
    ----------jdk1.7(包含)之前

常见面试题:
 问:内部类有独立的.class吗?
 答:有

实现功能规则:
1)先写行为:
  1.1)某一个对象所特有的行为，就将方法设计在对应的特定类中
  1.2)所有对象所共有的行为，就将方法设计在超类中
2)页面调用:
  2.1)定时发生的，写在run()中
  2.2)事件触发的，写在侦听器中

 

1.接口:
  1)是一种数据类型(引用类型)
  2)由interface定义
  3)只能包含常量和抽象方法
  4)接口不能被实例化
  5)接口是需要被实现/继承，实现类/派生类:
      必须重写接口中的所有抽象方法
  6)一个类可以实现多个接口，用逗号分隔
    若又继承又实现时，必须先继承后实现
  7)接口可以继承接口

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-------抽共性
2)所有派生类的行为都一样，设计为普通方法
  所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
  接口是对继承的单根性的扩展--------------多继承
  既继承又实现时，使用接口

打桩: System.out.println(数据);

 

1.多态:
  1)意义:
    1.1)同一类型的引用指向不同的对象时，有不同的实现
        ------行为的多态: cut(),run(),step()...
    1.2)同一对象被造型为不同的类型时，有不同的功能
        ------对象的多态: 我,水...
  2)向上造型:-------自动类型转换
    2.1)超类型的引用指向派生类的对象
    2.2)能造型成为的类型有: 超类+所实现的接口
    2.3)能点出来什么，看引用的类型
  3)强制类型转换，成功的条件只有如下两种:
    3.1)引用所指向的对象，就是该类型
    3.2)引用所指向的对象，实现了该接口
  4)强转时若不符合如上两个条件，则发生ClassCastException类型转换异常
    建议:在强转之前先通过instanceof来判断引用指向的对象是否是该类型

 

1.内存管理:由JVM来管理的
  1)堆:
    1.1)存储new出来的对象(包括实例变量)
    1.2)垃圾:没有任何引用所指向的对象
        垃圾回收器(GC)不定时到内存中去清扫垃圾
        GC的回收过程是透明的(看不到)，不一定一发现垃圾就立刻回收
        可以调用System.gc()建议虚拟机尽快调度GC来回收垃圾
    1.3)实例变量的生命周期:
          创建对象时存储在堆中，对象被回收时一并被回收
    1.4)内存泄漏:不再使用的内存还没有被及时的回收
        建议:若对象不再使用时应及时将其引用设置为null
  2)栈:
    2.1)存储正在调用的方法中的所有局部变量(包括方法的参数)
    2.2)调用方法时会为该方法在栈中分配一块对应的栈帧，
        栈帧中包含方法中的局部变量(包括参数)，
        当方法调用结束时，栈帧被清除，局部变量一并被清除
    2.3)局部变量的生命周期:
          调用方法时存储在栈中，方法结束时与栈帧一并消失
  3)方法区:
    3.1)存储.class字节码文件(包括方法、静态变量)
    3.2)方法只有一份，通过this来区分具体的访问对象

 

面向对象三大特征:
1.封装:
  1)类:封装的是对象的属性和行为
  2)方法:封装的是具体的业务逻辑实现
  3)访问控制修饰符:封装的是具体的访问权限
2.继承:
  1)作用:代码复用
  2)超类:所有派生类所共有的属性和行为
    接口:部分派生类所共有的行为
    派生类:派生类所特有的属性和行为
  3)传递性，单一继承，多接口实现
3.多态:
  1)意义: 
    1.1)行为多态(抽象方法都是多态的)
    1.2)对象多态(所有对象都是多态的)
  2)向上造型、强制类型转换、instanceof
  3)多态的表现形式:
    3.1)重写:根据对象的不同来表现多态
    3.2)重载:根据参数的不同来表现多态

如果程序的运行结果与你预期不同时，需要调试:
1)打桩: System.out.println(数据);
2)Debug调试工具: 先添加断点
  2.1)掌握4个键
      2.1.1)F5:单步调试(会进入到方法中)
      2.1.2)F6:逐过程调试(不会进入到方法中)
      2.1.3)F7:结束方法的调试
      2.1.4)F8:跳到下一个断点位置，若后面没有断点了，则调试结束
  2.2)会看2个东西
      2.2.1)看变量
      2.2.2)添加监视