接口（interface）

1：接口(interface)

(1)接口的由来：当一个类中的方法都是抽象的时候，你没必要定义为抽象类，

               定义为接口就可以了。

(2)解决了java中只能单继承的问题。(对多继承进行了优化)

A：类与类：只能是单继承。

B：接口与接口：可以是单继承，也可以是多继承。

C：类与接口：可以是单实现，也可以是多实现。

(3)成员特点：

A：只有成员变量和成员方法。

B：成员变量 默认修饰符 public static final

**int x = 20;

**其实是这样的 public static final int x = 20;

C：成员方法 默认修饰符 public abstract

**void show();

**其实是这样的 public abstract void show();

建议：自己手动加上修饰符。

(4)接口特点：

A：接口是对外暴露的规则

B：接口是功能的扩展

C：接口降低了程序的耦合性。

**内聚(自己实现功能的能力) 

**高内聚，低耦合。

举例：主板和CPU,USB接口,电源插座。

D：扩展说了下接口的理解

**狭义的理解就是java中的接口。

**广义的理解就是：任何定义的规范都是接口。

(5)接口和抽象类的区别：

A：抽象类只能被单继承；接口可以被多实现。

B：抽象类中的成员：成员变量:可以是常量，也可以是变量。

   成员方法:可以是抽象的，也可以是非抽象的。

   构造方法:虽然不可以创建对象，但是可以给子类实例化用。

   接口中的成员：成员变量：只能是常量。默认修饰符 public static final

 成员方法：只能是抽象的。默认修饰符 public abstract

C：抽象类中定义的是体系结构中的共性的内容。

   接口中定义的是对象的扩展功能。

D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

   接口被实现表示的是: "like a"的关系。xx像yy中的一种。

(6)学生：Student

A：属性：学号,姓名,年龄 

B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

         interface Smoking

 {

public abstract void smoking();

 }

   描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

SmokeStudent ss = new SmokeStudent();

ss.eat();

ss.study();

ss.smoking();

  老师：Teacher

A：属性 教师编号,姓名,年龄

B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

      但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。

      这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，

      我们定义一个接口来放抽烟这个功能。

         interface Smoking

 {

public abstract void smoking();

 }

  描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking

SmokeTeacher st = new SmokeTeacher();

st.eat();

st.teach();

st.smoking();

  最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。

  所以，我们进一步向上抽取。来了一个Person类

  Person：属性：姓名，年龄

          行为：吃饭(抽象eat)

 

2：多态

(1)某一类事物的多种存在形态。

**方法重载(静态多态)

**方法重写(动态多态,对象多态)

(2)对象多态的前提

A：类与类(或接口)要有继承(或实现)关系。

B：一定要有方法的重写。

C：一定要有父类或者接口的引用指向子类的对象。

(3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

A：Animal Cat Dog

**method(Animal a){a.eat();}

B：同学们吃饭

C：士兵打仗(抬枪，瞄准，射击)。

(4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)

Fu f = new Zi();

A：成员变量：编译和运行都看Fu。

B：非静态方法：编译看Fu，运行看Zi。

C：静态方法：编译和运行都看Fu。

举例： 动物的例子：

向上转型

Animal a = new Cat();

a.eat();

//a.catchMouse();

向下转型

Cat c = (Cat)a;

c.eat();

c.catchMouse();

//向上转型

Animal a = new Dog();

//向下转型 转换异常

//Cat c = (Cat)a;

Dog d = (Dog)a;

孔爹的例子：

孔爹:教课(Java)

孔子:教课(论语),看小说(),打游戏()。

孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了

k.教课(论语)。

//k.看小说();

孔子 kz = (孔子)k;//把衣服脱了

kz.教课(论语);

kz.看小说();

kz.打游戏();

3：Object

(1)Object类：java中所有类的父类。它是java类体系结构中的根类。

     java中的类都直接或者间接继承自Object类。

(2)学习了里面的几个方法:重点掌握 toString(),equals()。

A：boolean equals(Object obj) 

   指示其他某个对象是否与此对象“相等”。 

B：String toString() 

   返回该对象的字符串表示。 

C：int hashCode() 

   返回该对象的哈希码值。 

D：Class<?> getClass() 

   返回此 Object 的运行时类。 

E：protected void finalize() 了解

   当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 

   **final,finally,finalize

(3)重点看下面两个方法

//重写toString()方法

public String toString()

{

//return "HelloWorld";

return "name:"+name+",age"+age;

}

//重写Object的equals方法

public boolean equals(Object obj)//s2--obj

{

//为了提高效率

if(this == obj)

{

return true;

}

//为了程序的健壮性

if(!(obj instanceof Student))//格式：对象 instanceof 具体的类名

{

return false;

}

Student s = (Student)obj;

if(this.age==s.age)

{

return true;

}

else 

{

return false;

}

}