（四）黑马程序员——抽象类&接口

------- <a href="http://www.itheima.com" target="blank">android培训</a>、

<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、抽象类的概述及其特点

* A:抽象类概述

* 抽象就是看不懂的 

* B:抽象类特点

* a:抽象类和抽象方法必须用abstract关键字修饰

* abstract class 类名 {}

* public abstract void eat();//当不知道该方法具体是怎么实现的

                //比如动物吃，你知道它吃什么吗？怎么吃？都不知道

* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

* c:抽象类不能实例化那么，抽象类如何实例化呢?

* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

* d:抽象类的子类

* 要么是抽象类

* 要么重写抽象类中的所有抽象方法

案例：

class Demo1_Abstract {
public static void main(String[] args) {
//Animal a = new Animal();//错误: Animal是抽象的; 无法实例化
Animal a = new Cat();//父类引用指向子类对象
a.eat();
}
}
abstract class Animal {//抽象类
public abstract void eat();//抽象方法
 
public Animal() {
System.out.println("父类空参构造");
}
}
 
class Cat extends Animal {
public Cat() {
super();
}
public void eat() {
System.out.println("猫吃鱼");
}
}

抽象类的成员特点:

* A:抽象类的成员特点

* a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量

* b:构造方法：有。

* 用于子类访问父类数据的初始化。

* c:成员方法：既可以是抽象的，也可以是非抽象的。

* B:案例演示

* 抽象类的成员特点

* C:抽象类的成员方法特性：

* a:抽象方法 强制要求子类做的事情。

* b:非抽象方法 子类继承的事情，提高代码复用性。

案例：

class Demo2_Abstract {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
abstract class Demo {
int num1 = 10;//变量
final int num2 = 20;//常量
 
public Demo(){}//构造方法
 
public void print() {//非抽象方法，子类可以直接使用
System.out.println("111");
}
 
public abstract void method();//抽象方法，子类必须实现
}
 
class Test extends Demo {
public void method() {
System.out.println("111");
}
}

二、接口的概述及其特点

* A:接口概述

* 从狭义的角度讲就是指java中的interface

* 从广义的角度讲对外提供规则的都是接口 

* B:接口特点

* a:接口用关键字interface表示

* interface 接口名 {}

* b:类实现接口用implements表示

* class 类名 implements 接口名 {}

* c:接口不能实例化

* 那么，接口如何实例化呢?

* 按照多态的方式来实例化。

* d:接口的子类

* a:可以是抽象类。但是意义不大。

* b:可以是具体类。要重写接口中的所有抽象方法。

案例：

class Demo1_Interface {
public static void main(String[] args) {
//Inter i = new Inter();//接口不能被实例化,因为调用抽象方法没有意义
Inter i = new Demo();//父类引用指向子类对象
i.print();
}
}
interface Inter {
public abstract void print();//接口中的方法都是抽象的
}
 
class Demo implements Inter {
public void print() {
System.out.println("print");
}
}

接口的成员特点:

* A:接口成员特点

* 成员变量只能是常量，并且是静态的并公共的。

* 默认修饰符：public static final

* 建议：自己手动给出。

* 构造方法：接口没有构造方法。

* 成员方法：只能是抽象方法。

* 默认修饰符：public abstract

* 建议：自己手动给出。

案例：

class Demo2_Interface {
public static void main(String[] args) {
Demo d = new Demo();
d.print();
System.out.println(Inter.num);
}
}
interface Inter {
public static final int num = 10;
//public Inter(){}接口中没有构造方法
/*public void print() {接口中不能定义非抽象方法
}*/
public abstract void print();
}
class Demo /*extends Object*/ implements Inter {//一个类不写继承任何类,默认继承Object类
public void print() {
//num = 20;
System.out.println(num);
}
public Demo() {
super();
}
}

面向对象(类与类,类与接口,接口与接口的关系)

* A:类与类,类与接口,接口与接口的关系

* a:类与类：

* 继承关系,只能单继承,可以多层继承。

* b:类与接口：

* 实现关系,可以单实现,也可以多实现。

* 并且还可以在继承一个类的同时实现多个接口。

* c:接口与接口：

* 继承关系,可以单继承,也可以多继承。

案例：

class Demo3_Interface {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
interface InterA {
public abstract void printA();
}
interface InterB {
public abstract void printB();
}
interface InterC extends InterB,InterA {
}
//class Demo implements InterA,implements InterB {//这么做不允许是非法的
class Demo extends Object implements InterA,InterB {
public void printA() {
System.out.println("printA");
}
public void printB() {
System.out.println("printB");
}
}

三、抽象类和接口的区别:

* A:成员区别

* 抽象类：

* 成员变量：可以变量，也可以常量

* 构造方法：有

* 成员方法：可以抽象，也可以非抽象

* 接口：

* 成员变量：只可以常量

* 成员方法：只可以抽象

* B:关系区别

* 类与类

* 继承，单继承

* 类与接口

* 实现，单实现，多实现

* 接口与接口

* 继承，单继承，多继承

* C:设计理念区别

* 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

* 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。 

        * 对事物本质的抽象用抽象类，对事物功能的扩展用接口