接口

接口

定义：

接口是一种约束形式，其中只包括成员定义，不包含成员实现的内容。

        初期可理解为方法都是抽象的抽象类，那么该类可以通过接口的形式来表示。

        class用于定义类 ；interface 用于定义接口。

格式：

    1.接口中常见定义：常量，抽象方法。

    2.接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract 

         记住：接口中的成员都是public的。

        

         如果格式没有写全，系统会默认补全成上面的格式

接口：是不可以创建对象的，因为有抽象方法。

        需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

        否则子类是一个抽象类。

    类与类之间存在着继承关系，类与接口中间存在的是实现关系。

    继承用extends；实现用implements ；

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

       

接口与接口也可继承，不是实现，implement是要写内容的，extends不用写内容。

其实 java中是有多继承的。接口与接口之间存在着继承关系， 接口可以多继承接口

     

接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）

1：接口是对外提供的规则。(主板都遵守国际标准化，都遵守这个规则)

2：接口是功能的扩展。

3：接口的出现降低了耦合性。（可以实现模块化开发，不用大家一起开发）

抽象类与接口：

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取

        可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。

        它里面定义的都是一些体系中的基本内容。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

 

抽象类和接口的共性：都是不断向上抽取的结果。

抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都是抽象方法，需要子类去实现。

3：抽象类使用的是 is a 关系。

接口则使用的是 like a 关系。

4：抽象类的成员修饰符可以自定义。

接口中的成员修饰符是固定的，全都是public的。

    在开发之前，先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。

    至于A是如何对规则具体实现的，B是不需要知道的。这样就降低了A和B直接耦合性。

       

多态

多态可以理解为事物存在的多种体现形态。

        人：男人  女人。

        如果大街上走来一个男人，可以说"走过来一个男人"或者"走过类一个人"。

        动物：猫 狗。

        可以管猫叫做"猫"或者叫做"动物" 。

        猫 x = new 猫();

        动物 x = new 猫();                   【Animal a = new Cat();】

         x具备猫和动物的两种属性，前提是猫和动物要有关系(继承或实现)。

定义：

        多态（Polymorphism）按字面的意思就是“多种状态”。在 面向对象语言 中，接口的多种不同的实现方式即为多态。

      

Animal a = new Cat(); 类型提升. 向上转型。如：byte b = 2; int x = b;b就被提升为int型。

多态的弊端是当父类引用指只能访问父类中具备的方法，不可以访问子类中特有的方法。

如果想要调用猫的特有方法时，如何操作？

    

 

通过 毕姥爷与 毕老师理解向下转型：

      

 

如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？

   instanceof： 

    格式：<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。

    Student instanceof Person = true;  (student继承了person类)

   多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

    在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

    再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

    编译时期：参考引用型变量所属的类中是否有调用的方法。

    运行事情：参考的是对象所属的类中是否有调用的方法。

    为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

    简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

    更简单：成员函数 --- 编译看 = 左边，运行看 = 右边。

3，静态函数。

    编译时期：参考的是引用型变量所属的类中是否有调用的成员。

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

    调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

    简单说：静态函数 --- 编译运行都看 = 左边。

   对于静态方法调用时：父类走父类 子类走子类（面试易问）

多态的主板示例：

   

多态连接数据库示例：

 

需求：数据库的操作。

数据是：用户信息。

1，连接数据库。JDBC  Hibernate

2，操作数据库。

   c create r read  u update  d delete

3，关闭数据库连接。

     

         

 

Object以及equals

一直在谈继承，子继承父，父还有没有父类，构造函数中第一行语句都是隐式的是super语句，通过它来访问父类。那么父类应该是有父类的

API：

public class Object

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.

Object:是所有对象的直接后者间接父类，传说中的上帝。

Object： Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

该类中定义的肯定是所有对象都具备的功能（不断向上抽取最后成了Object类）

 

 

 

Java认为所有的对象都具备比较性，都能比较两个对象是否相同。只要是实体，就可比较是同一个实体。所有对象都具备的方法，一定定义在Object类中

    

可以看住其实比较的是地址值。（不同类型的都可比较，因为只比较地址，与类型无关）

 

 

自己敲得equals出现的错误

 

toString()

Java又认为所有的对象都能变成字符串被打印.

故也把toString归到Object类上。

 

为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。类似覆写equals方法，让toString打印自己定义的内容

  

虽然所有的Object中方法都要覆写定义自己的内容，但是不能抽象，

抽象是强迫子类一定要用Object类中的方法，而此刻只是用就覆写，不用就do nothing.