面向对象——三大特性之——继承（二）

【抽象类】
当描述事物时，没有足够的信息对该事物进行描述，那么该描述对应的类就是一个抽象类。

狼 ，狗 ——犬科；

【抽象类的特点：】
1. 没有方法体的方法是抽象方法，一般定义在抽象类中。

2. 抽象类和抽象方法必须用abstract关键字所修饰。

3. 抽象类不可以被实例化。为啥？（逆向思考）

因为调用抽象方法没有意义，啥也没有，调用个毛！

4. 抽象类必须由其子类覆盖掉所有的抽象方法后，其子类才可以进行实例化。
否则，该子类还是一个抽象类。

【细节问题】

1. 抽象类一定是个父类？
是，因为他由子类继承。

2. 抽象类是否有构造函数？
有，因为是给子类提供初始化动作的!

3. 抽象类中是否可以不定义抽象方法？
可以的。它存在的目的，不让其创建对象。这种情况在Java的体系中就有存在，比如windowAdapter

4. 抽象关键字不能和那些关键字共存。
final：final如果修饰抽象类or抽象方法 ，就把 类 or 方法固定了，不能再改动了！
private：private 是私有，表封装，加了private后，抽象方法将不能被复写。
static：static表示静态的意思，当加了static后，调用静态方法就不需要再创建类的对象了，那还有什么劲呢?

【一般类和抽象类有什么异同呢？】

相同之处：
一般类和抽象类都用于描述事物；里面都可以定义属性和行为，以及构造函数。

不同之处；
一般类中不可以定义抽象函数，抽象类可以。
一般类可以被实例化，抽象类不行。

一般类可以被继承，也可以不被继承，抽象类一定要被继承，需要其子类覆盖所有的抽象方法子类才可以被实例化。

【接口】————重点

当一个抽象类中全都是抽象方法的时候，这时候，可以将这个抽象类定义成接口。

接口是一个特殊的抽象类。初期的一种简单理解。

意味着接口中的方法都是抽象方法。

什么是接口？(自己的理解)
哈哈：程序写好后，为后期的功能扩展（以不修改原有代码为前提），对外提供的供补充的功能与原有程序进行连接的端口。

【接口定义的格式】

interface 接口名{接口内容}

interface Inter

{

//接口成员

常见接口成员：并且都有固定修饰符；

1.常量； public static final int num = 3

常量有固定的修饰符： public static final ；如果忘记写final会自动加上；

全局常量；

2.抽象方法；

固定修饰符：public abstract ；

}

【接口特点】

1. 接口用interface来定义

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

3. 接口不能被实例化

4. 接口必须由其子类覆盖了所有的抽象方法，该子类才可以实例化，

否则，该子类还是一个抽象类、

5. 接口中的成员都是public修饰的。

【implements】——接口是要被实现的。

【重点】

1. 类与类之间是继承关系；

2. 类与接口之间是实现关系。

，必须覆盖接口中的所有抽象方法，否则该类还是抽象类。

【接口的好处】

1. 接口可以被多实现，这就是多继承机制在Java中被改良后的结果。

一个类可以实现多个接口。丰富类的功能

2. 一个类在继承一个类的同时还可以实现多个接口。接口的出现避免了单继承的局限性。

【思考】接口中两个抽象方法一样，但返回值类型一样，会出现什么后果。

答：这样会造成调用函数的不确定性。

【误区】

抽象函数，也要遵从函数的基本定义格式，要明确结果，要明确未知内容。只不过函数体由子类来完成。

【继承 and 实现】

1.类与类之间是继承，而且是单继承。

2.类与接口之间是实现，而且可以多实现。

3.接口与接口之间是继承关系，而且可以多继承。

【接口可以多继承的——根本原因：】没有方法体，没有了方法调用的确定性

【接口的思想】——
【举例】笔记本的电源线。提高扩展性，降低了耦合性。

1. 接口的出现降低了耦合性；有一方在定义接口(规则)，另一放实现接口(规则)

2. 接口的出现提高了扩展性。

3. 接口就是对外暴露的规则。

【举例】笔记本电脑的usb插口
接口定义好后，一方在使用这个接口，另一方负责实现这个接口。
所以，接口的出现降低了双方的耦合性。

【接口和抽象类的区别】

1.类是用来继承的，只能单继承；

接口是用来实现的，可以多实现；

2. 类中可以定义非抽象内容，直接提供给子类使用；

接口中只能定义抽象 方法，需要子类全部实现。

3.类存在着继承关系是 is a 关系。

接口的实现关系，是 like a 关系。

【共同点】
他们都是不断向上抽取而来的。

【什么时候定义抽象类，什么时候定义接口】——

1.抽象类一般定义的都是一个体系中的基本共性功能，并且在抽象类中可以有具体的方法。

2.接口一般定义的都是一个体系中额外的扩展功能。

——————————————————————————————————————————————

【没有抽象方法的抽象类】
如果有一个接口：

interface Inter

{

void show1();

void show2();

void show3();

void show4();
}

当子类要实现这个接口的时候，需要覆盖四个方法，但是子类就想针对其中一个方法进行具体内容的指定。

其他方法不需要用到。但是为了创建对象，还必须得覆盖。如果又有其他子类要用到其中的一个方法，

还是如此要覆盖四个方法。忒麻烦！这时候——【没有抽象方法的抽象类】就发挥作用了！

可以这样做：定义一个抽象类，然后由子类继承并复写需要的方法。

//没有抽象方法的抽象类，可以方便创建接口对象，去覆盖指定的功能。

//为了让使用者都继承它，并且覆写里面的方法，定义为abstract类。

abstract class Test implements Inter
{
public void show1(){}
public void show2(){}
public void show3(){}
public void show4(){}
}//此类毫无意义，因为方法中，方法体没有实际的内容，调用类中的方法后没有结果
class Test1 extends Test
{
public void show1()
{
System.out.println("show1 run");
}

}

class Test2 extends Test
{
public void show2()
{
System.out.println("show2 run");
}
}
class Demo1
{
public static void main(String[] args)
{
Test1 t = new Test1();
}
}

【代码体现】

interface Inter
{
	public abstract void show1();
	public abstract void show2();
	public abstract void show3();
}
abstract class Test implements Inter
{
	public void show1(){}
	public void show2(){}
	public void show3(){}
}
class Test1 extends Test
{
	public void show1()
	{
		System.out.println("show1 now : RUN ！");
	}
}
class Test2 extends Test
{
	public void show2()
	{
		System.out.println("show2 now : RUN !");
	}

}
class Test3 extends Test
{
	public void show3()
	{
		System.out.println("show3 now : RUN !");
	}
}
class DemoAbstract
{
	public static void main(String[] args)
	{
		Test1 t1 = new Test1();
		Test2 t2 = new Test2();
		Test3 t3 = new Test3();
		t1.show1();
		t2.show2();
		t3.show3();
	}
}

【举例】
描述犬：
分类：导盲犬，缉毒犬；
犬中有一些 ：共性内容而且是不需要抽象的。
所以犬应该用class来定义。
//在不同的问题领域中分析问题的也有不同。

/*
什么时候定义抽象类，什么时候定义接口？——这个时候就拿出来用一下
1. 当对象中与很多共性的内容时，可以抽取出来，定义抽象类
2. 当对象要补充额外的扩展功能，定义接口
*/

【代码体现】

package day01;

abstract class Dog{
	public void eat(){
		System.out.println("Dog now : EAT !");
	}
	public abstract void houjiao();
}

abstract class Cat1{
	public void eat(){
		System.out.println("Cat now : EAT !");
	}
	public abstract void CatchMouse();
}

interface SouBao{
	public abstract void soubao();
}

class SouBaoDog extends Dog implements SouBao{
	public void soubao(){
		System.out.println("I'm Dog , I want to SouBao !");
	}
	public void houjiao(){
		System.out.println("here ! here !");
	}
}

class SouBaoCat extends Cat1 implements SouBao{
	public void soubao(){
		System.out.println("I'm Cat , I want to SouBao!");
	}
	public void CatchMouse(){
		System.out.println("Oh , God ! Such a big Mouse !");
	}
}
public class InterfaceDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SouBaoCat c = new SouBaoCat();
		SouBaoDog d = new SouBaoDog();
		c.soubao();
		c.CatchMouse();
		c.eat();
		System.out.println("\n");
		d.soubao();
		d.houjiao();
		c.eat();
	}

}

【补充】

1. 抽象：

a) 如果一个子类是从一个具有abstract 方法的超类继承的，并且在子类中没有为那个abstract方法提供定义（即在子类中那个方法没有被覆盖），则那个方法在子类中仍然为 abstract方法。因此，子类也是 abstract 方法，并且必须被显示 声明为 abstract 类。

b) 声明一个方法为abstract使类的设计者可以决定子类在类层次结构中的实现方法。任何要继承这个类的新类必须覆盖 abstract方法（直接继承 或者 从已覆盖该方法的类中继承）。否则新类将包含 abstract 方法，并因此成为不能 实例化对象的abstract 类。

c) abstract 类可以用实例数据 和 非abstract 方法，并且他们遵循一般的子类继承规则。abstract 类可以有构造函数。

2. 接口

a) 接口的定义由关键字 interface 开始。

i. 里面的方法必须用—— public abstract 修饰。

ii. 里面的数据用—— public static final 修饰。

为了使用接口，一个类必须声明它 implements 接口，而且必须定义接口中的方法，方法的参数个数 及返回类型要 与 接口中定义的相同。如果有接口中的方法没有在类中定义，这个类就成为 abstract 类。

接口功能：

1. 除了继承一个类之外，类还可以根据需要实现若干接口，这个可以极大的扩展类的功能。

2. 可以定义一些变量，以供其他类使用。