黑马程序员—java基础学习--抽象类(abstract)、接口(interface)、多态

在我们日常的javase学习中，所接触的抽象累相对较少，所以抽象类的知识点也就没有记得相当牢固，但是抽象仍是不容忽视的一部分，今天我来总结一下抽象类(abstract)，也算是对知识的回顾。

*抽象类(abstract)

当多个类中出现了相同功能，但是功能主体不同，这时可以进行向上抽取。此时只抽取功能定义，而不抽取功能主体。

一、抽象类的特点：

1，抽象方法一定定义在抽象类中；

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象，因为调用抽象方法没意义。

4，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后建立子类对象调用。如果子类只覆盖了部分抽象方法，那么子类还是一个抽象类。

abstract class Student
{
abstract void study();	//抽象主体必须存在于抽象类中。
}
class BaseStudent extends Student
{
void study(){	//子类继承并复写父类的抽象方法。
System.out.println("base study");
}
}

class AdvStudent extends Student
{
void study(){
System.out.println("adv study");
}
}

class AbastractDemo
{
public static void main(String[] args)
{
System.out.println("hello");
//	new Student();//此处报错，因为调用抽象类无意义。
new BaseStudent().study();
}
}

二、抽象类和一般类的差距：
抽象类和一般类没有太大的不同，该如何描述事物就如何描述事物，只不过该事物出现了一些看不懂的东西，这些不确定的东西也是该事物的功能，要明确体现出来，但是无法定义主体。通过抽象方法来表示。
抽象类比一般类多个了抽象函数，就是在类中可以定义抽象方法。抽象类不可以实例化。

三、抽象类的特殊之处：

抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。 

*接口(interface)

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

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

一、接口的格式特点：

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

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

常量修饰符:public static final;

方法修饰符:public abstract;

记住：接口的成员都是public

二、注意：

1，接口是不可以抽象的，因为有抽象方法，需要被子类实现子类接口中的抽象方法全都覆盖后，子类才可以实例化。否则，子类是一个抽象类。

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

为什么可以多实现呢？代码如下：

class Demo<span style="white-space:pre">		</span>//父类Demo
{
<span style="white-space:pre">	</span>public void function(){}
}
interface InterA<span style="white-space:pre">	</span>//接口InterA
{
<span style="white-space:pre">	</span>public abstract void show();

}

interface InterB<span style="white-space:pre">	</span>//接口InterB
{
<span style="white-space:pre">	</span>public abstract void show();
}

class Test extends Demo implements Inter,InterA<span style="white-space:pre">	</span>//继承Demo父类，并实现InterA 和 InterB
{
<span style="white-space:pre">	</span>public void show(){}<span style="white-space:pre">	</span>//当多个接口有一个共有的方法时，覆盖可以填写方法主体。
}

3，接口与接口之间拥有继承关系，但是需要注意的是，接口之间可以多继承（接口之间没有方法体，不冲突）。

三、接口的特点：

1，接口的特点：

a,接口是对外暴漏的规则；

b,接口是程序的功能扩展；

c,接口可以用来多实现；

d,类与接口之间是实现关系，而且可以继承一个类的同时实现多个接口；

e,接口与接口之间可以有继承关系。

2，接口的举例体现，代码如下：

class Student	//父类Student类
{
abstract void study();
void sleep(){
System.out.println("sleep");
}
}

interface Smoking	//Smoking接口
{
void smoke();
}

class ZhangSan extends Student implements Smoking	//继承了Student，实现了Smoking
{
void study(){};		//	is..a 关系
public void smoke(){}	//	like..a 关系
}

*多态

多态的概念：

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

例：

人： 男人，女人；

动物：猫，狗；

1，多态的体现：

父类的引用指向了自己的子类对象；父类的类型也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系，要么继承，要么实现。

通常还有一个前提：存在覆盖

3，多态的好处

多态的出现大大的提高了程序的扩展性。

4，多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)。

class DuoTaiDemo
{
public static void main(String[] args)
{
Animal a = new Cat(); //类型提升。向上转型。
a.eat(); //只能调用eat()方法
//如果想要调用猫的特有方法时，如何操作？
//强制将父类的引用，转成子类类型。向下转型。
Cat c = (Cat)a;
c.catchMouse();

//千万不要出现这样的操作，就是将父类对象转成子类类型。
//我们能转的是父类引用指向了自己的子类对象时，该应用可以被提升。也可以被强制转换
//多态自始至终都是子类对象在做着变化。
// Animal a = new Animal();<span style="white-space:pre"> </span>//编译时报错，强制转换失败。
// Cat c = (Cat)a;
}
}

abstract class Animal
{
public abstract void eat();
}

class Cat extends Animal
{
public void eat(){
System.out.println("cat eat fish");
}
public void catchMouse(){
System.out.println("cat catch mouse");
}
}

class Dog extends Animal
{
public void eat(){
System.out.println("dog eat meal");
}
public void lookDoor(){
System.out.println("dog look door");
}
}

在多态中成员
4000
函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单的总结就是：成员函数在多态调用时，编译看左边，运行看右边。

class DuoTaiDemo2
{
public static void main(String[] args)
{
Fu f = new Zi();
f.method1(); //打印结果为 zi method_1 子类重写父类方法
f.nethod2(); //打印结果为 fu method_2
// f.method3(); //此行编译失败
}
}

class Fu
{
void method1(){
System.out.println("fu method_1");
}
void method2(){
System.out.println("fu method_2");
}
}

class Zi extends Fu
{
void method1(){
System.out.println("zi method_1");
}
void method3(){
System.out.println("zi method_3");
}
}


在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）。

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边。