黑马程序员-JAVA面向对象之抽象、接口、多态
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
一、抽象
抽象定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。
抽象方法：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。
抽象类的特点
1，抽象方法一定在抽象类中。抽象方法和抽象类都必须被abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2，抽象方法只定义方法声明，并不定义方法实现。
3，抽象类不可以用new创建对象(实例化)。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用（继承），必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。即只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
抽象类注意点：
1，抽象类有构造函数，用于子类对象初始化
2，抽象关键字abstract和final ,private , static不可以共存
3，抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
4，抽象类中有构造函数，抽象类是一个父类，可以给子类提供实例初始化
代码实例：
我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名，工号以及工资，经理也是员工，除了含有员工的属性外，另外还有一个奖金属性，请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法进行属性访问。
class Employee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
} 模板方法设计模式：
解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现abstract class GetTime
{ //获取某段时间的代码，其中runcode();是不确定的，暴露到外边去。其他的是确定的。
public final void getTime()//此功能如果不需要复写，可加final限定
{
long start = System.currentTimeMillis();
runcode();//不确定的功能部分，提取出来，通过抽象方法实现
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//抽象不确定的功能，让子类复写实现
}
class SubTime extends GetTime
{
public void runcode()//子类复写功能方法
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
} -------------------------------------------------------------------------------------------------------------------
二、接口
接口：
可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。接口看上去是一个特殊的抽象类。里面存的都是抽象方法。
格式：
interface Innter{}
修饰常量：public static final
修饰方法：
public abstract interface Inter
{
public static final intNUM = 3;
public abstract void show();
}interface A
{
void methodA();
}
interface B extends A
{
void methodB();
}
interface C extends B
{
void methodC();
}
class D implements C
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}//建立D的对象必须实现3个方法。 接口之间可以多继承。Java支持多继续，只有接口之间有多继承 。类之间是单继承
接口特点：
1：接口是对外提供的规则。
2：接口是功能的扩展。
3：接口的出现降低了耦合性
抽象类和接口的区别：
1：抽象类只能被继承，而且只能单继承。接口需要被实现，而且可以多实现。也就是说：接口的出现避免了单继承的局限性。
2：抽象类中可以定义抽象方法和非抽象方法，子类可以直接继承使用。
接口中只能定义抽象方法，需要子类去实现。
3：继承和实现的关系不一致，抽象类使用的是 is a 关系。
接口使用的 like a关系。
4：抽象类的成员修饰符可以自定义。
接口中的成员修饰符是固定的。全都是public的。
------------------------------------------------------------------------------------------------------------
三、多态
定义：某一类事物的多种存在形态。即可以理解为事物存在的多种体现形态
1，多态的体现
父类的引用指向了自己的子类对象。Animal a = new Cat();
父类的引用也可以接收自己的子类对象。
2，多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖操作。
3，多态的好处
多态的出现大大的提高程序的扩展性。
4，多态的弊端：
当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)即：提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5，多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。
代码范例：
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}
class Pig extends Animal
{
public void eat()
{
System.out.println("饲料");
}
public void gongDi()
{
System.out.println("拱地");
}
} 关键字 instanceof
判断对象是否实现了指定的接口或继承了指定的类
格式：
对象 instanceof类型
Student instanceof Person = true;//student继承了person类
多态在子父类中的成员上的体现的特点：
1，成员变量：在多态中，子父类成员变量同名。
在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
再说的更容易记忆一些：成员变量---编译运行都看 =左边。
2，成员函数。
编译时期：参考引用型变量所属的类中是否有调用的方法。
运行时期：参考的是对象所属的类中是否有调用的方法。
为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。
更简单：成员函数 --- 编译看 =左边，运行看 = 右边。
3，静态函数。
编译时期：参考的是引用型变量所属的类中是否有调用的成员。
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------
详情请查看：http://edu.csdn.net/heima