黑马程序员-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

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值