就业班总结第一波 - 黑马程序员技术交流社区

接口：
      Java语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹）
      Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口

      接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现。

一个类如何实现接口：
            implements 关键字

            格式：权限修饰符 interface 接口名1，接口名2{}

      public interface boss{}//创建接口
      public class Programmer{}//创建父类
      public class Billgame abstract Programmer interface boss{}

接口的成员特点：
      只能有抽象方法
      只能有常量
      默认使用public&abstract修饰方法
      只能使用public&abstract修饰方法
      默认使用public static final来修饰成员变量


      建议：建议手动给上默认修饰符

      注意：
            接口不能创建对象，（不能实例化）
            类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法


类与类：继承关系，单一继承，多层继承
类与接口：实现关系，多实现
接口与接口：继承关系，多继承
实现或继承多个接口是，接口名用，


接口的优点：
      1.类与接口的关系：实现关系，一个类可以实现多个接口
            类与类之间是继承关系，java中的继承是单一继承，一个类       只能有一个父类，
                              打破了继承的局限性。
      2.对外提供规则（usb接口）
      3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）

接口和抽象类的区别
            共性：不断地抽取，抽取出抽象的概念
            区别1：与类的关系不同：
                              类与接口是实现关系，而且是多实现，一个类可以实现多个接口
                              类与抽象类是继承关系，java中的继承是单一继承一个类只能有一个父类，java中的继承是多层继承
            区别2：成员
                              成员变量定义不同：
                                             抽象类可以有成员变量也可以由常量
                                             接口只能有常量
                              成员方法定义不同：
                                             抽象类可以有抽象方法，也可以有非抽象方法
                                             接口只能有抽象方法，而且方法有默认修饰符public abstract
                              构造方法定义不同：
                                             抽象类有构造方法的
                                             接口没有构造方法
什么时候用抽象类，什么时候用接口？
      当需要等译的类可以作为子类的父类，且里面有抽象方法是，则定义为抽象类
      *如动物和猫，猫属于动物，动物中包括猫
      当需要定义的类不足以作为子类的父类，而只是用于扩展功能是，则定义为接口
      *如爬树和猫，猫不属于爬树，猫只能具有爬树的功能
多态的前提：

      子父类的继承关系
      子类重写了父类的方法
      父类引用指向子类对象 Animal cat=new Cat();

动态绑定：运行期间调用的方法，是根据其具体的类型

               编译期间

多态的成员特点：Dad x=new kid();
      成员变量编译时看的是左边，运行时看左边 student.age
      静态方法编译时看的是左边，运行时看左边       student.staticFunc();
      成员方法编译时看左边，运行时看右边             student.eat();


      编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态方法）都是左边

多态中的向上转型和向下转型：
      引用类型之间的转换
            向上转型
                     由小到大（子类型转换成父类型）
            向下转型
                     有大到小（父类型转换成子类型）
      基本数据类型的转换
            自动类型转换
                     由小到大
                              byte short char-- int -- long --float --double
            强制类型转换
                     有大到小


多态的优缺点
      优点：提高可维护性(多态前提所保证的)，
               提高代码的可扩展性
               提高代码复用性
      缺点：父类无法直接访问子类特有的成员

多态的应用：
      向上转型：作为参数类型，简化代码
      向下转型：调用子类对象特有的方法


instanceof语句
      作用：判断一个对象是否是某个类的对象，如果是则返回true，如果不是则返回false
      格式：对象 instanceof 类名
      常见用法： if（s instanceof Student）{}

内部类：
      成员内部类：类中，方法外
                     非静态成员内部类
                     静态成员内部类
                     在内部类中，可以直接访问外部类的成员，包括私有成员
            创建非静态成员内部类的对象
                     格式：外部类名.内部类名对象名=new 外部类名（）.new 内部类名（）；
                     Outer.Inner i =new Outer().new Inner();

      成员内部类的修饰符：
            我们可以使用权限修饰符修饰成员内部类，但是如果使用公司有来修饰，则无法在其他类中访问
            我们可以使用static修饰成员内部类，不用创建外部类的对象了

      局部内部类：
            在方法内，除了方法之后就无法使用

      匿名内部类：
            可以把匿名内部类堪称是一个没有名字的局部内部类
            定义在方法中
            必须在定义匿名内部类的时候创建他的对象

            格式：
                     new类/接口（）{
                              如果是创建了继承这个类的子类对象，我们可以重写父类的方法
                              如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法
                     }；
            原理：创建了继承这个类的子类对象或者是创建了实现这个接口的自乐对象

      共性：
            （虽然编写时在同一个java文件中，但是编译后都是独立的.class字节码文件）
            内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
            （内部类编译后的字节码文件名是外部类名内部类）
            内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论时候是private的。
abstract：关键字，用于修饰方法和类
抽象包括两种：
      抽象方法：不同类的方法是相似的，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
      抽象类：有抽象方法的类必须是抽象类

注意：一个类继承了抽象类需要重写他所有的抽象方法，否则这个类就得是抽象类

抽象类
      abstract class Animal{

            public abstract void eat（）；
      }
抽象类的特点：
      成员变量
            可以有成员变量
            可以有常量
      成员方法
            可以有抽象方法
            可以有非抽象方法
      构造方法
            可以有构造方法的，需要对抽象类的成员变量进行初始化、

抽象类的细节
      abstract不能与final,private 共存

抽象类的思想
      Java中应用的抽象
            Reader/Writer类
            利用抽象起到规范作用





匿名内部类的应用应用场景：
            作为参数进行传递

匿名对象：没有名字的对象
      调用

      匿名对象的应用场景：
            当方法只调用一次的时候可以使用匿名对象
            可以当作参数进行传递，但是无法在传参之前做其他的事情

      注意：匿名对象可以调用成员变量并赋值，但赋值并没有意义
static:
      含义：
            静态
            是一个关键字
      作用：
            用来修饰成员变量和成员方法，是其他该类的所有对象共享

      如何调用static修饰的变量和方法
            类名.静态成员属性：system.out
            类名.静态成员方法（）：Arrays.toString(arr);

      特点：
      静态成员被所有的对象所共享
      静态成员可以直接使用类名来调用
      静态成员的加载优先于对象
            。静态资源在创建类时加载并初始化（在方法区中）
            。非晶态资源在创建对象时才能加载并初始化（在堆内存中）
      静态成员生命周期
            。随着类的加载而创建，直到程序结束

静态成员和非静态成员的区别
      * 生命周期不同
            * 静态成员: 随着类的加载而创建, 随着程序结束而销毁
            * 非静态成员: 随着对象的创建而创建, 随着对象的销毁而销毁
            * 所以, 静态成员的生命周期优先于非静态成员创建, 晚于非静态成员销毁
      * 内存中的定义位置不同
            * 静态成员: 方法区中类字节码区域的静态区中
            * 非静态成员: 堆内存中
      * 初始化时机不同
            * 静态成员: 类加载时初始化
            * 非静态成员: 对象创建时初始化

static注意事项：
      静态方法中：
            可以调用静态的成员变量
            可以调用静态的成员方法
            不可以调用非静态的成员变量
            不可以调用非静态的成员方法

            只能在静态的方法中调用静态的成员

            在静态的方法中是否有this对象？
                     在静态方法中没有this对象，因为this引用当前类的对象，而静态方法在类加载时已经加载，此时没有对象可以引用

      非静态方法中：
            可以调用静态的成员变量
            可以调用静态的成员方法
            可以调用非静态的成员变量
            可以调用非静态的成员方法

            非静态方法中可以调用静态和非静态成员