精华内容
下载资源
问答
  • 抽象类属性注入实现

    千次阅读 2014-12-11 19:29:03
    比如我有个抽象类AbstractHtmlParser,而这个抽象类又有多个具体实现类BaiduHtmlParser、GoogleHtmlParser,这些具体实现类又都需要注入一些相同的实例,如果每个实现类都要去声明和注入一些相同的属性则显得太麻烦...
    由于抽象类不能实例化,所以在spring中就不能在xml配置文件中把值注入到抽象类中,比如我有个抽象类AbstractHtmlParser,而这个抽象类又有多个具体实现类BaiduHtmlParser、GoogleHtmlParser,这些具体实现类又都需要注入一些相同的实例,如果每个实现类都要去声明和注入一些相同的属性则显得太麻烦。这个时候我们可以使用spring的注解方式,在抽象类中把属性声明为protected并使用注解方式定义bean:
    
    package com.haochen.parser;

    import java.util.List;

    import org.springframework.beans.factory.annotation.Autowired;

    import com.haochen.dao.IHibernateDao;

    public abstract class AbstractHtmlParser {
    @Autowired
    protected IHibernateDao hibernateDao;

    public void setHibernateDao(IHibernateDao hibernateDao) {
    this.hibernateDao = hibernateDao;
    }

    public abstract List<String> parse();
    }


    这样,就可以直接在实现类使用hibernateDao属性了:
    package com.haochen.parser;

    import java.util.List;

    import org.springframework.stereotype.Service;

    @Service("googleHtmlParser")
    public class GoogleHtmlParser extends AbstractHtmlParser {

    @Override
    public List<String> parse() {
    hibernateDao.save(new Object());
    return null;
    }

    }


    HibernateDao.java
    package com.haochen.dao;

    import org.springframework.stereotype.Repository;

    @Repository("hibernateDao")
    public class HibernateDaoImpl implements IHibernateDao {

    @Override
    public void save(Object obj) {

    }

    }

    这儿只是为了演示,没有写具体实现过程。
    展开全文
  • 下面我们以水果为例,首先定义抽象类Fruit,抽象类中有公共属性vendor,抽象属性Price和抽象方法GrowInArea, public abstract class Fruit { public string vendor { get; set; } //默认为private public abstract...
  • C#中的抽象类、抽象属性、抽象方法

    千次阅读 2020-06-10 00:51:31
    抽象类不能实例化,抽象类可以包含普通属性和抽象属性,普通函数和抽象函数。 抽象函数就是只有函数定义没有函数体的函数。显然,抽象函数本身也是虚拟(virtual)的。 注意:类是一个模板,那么抽象类就是一个不...

    前言:本博文讲述了C#面向对象中的抽象类,通过本博文的阅读,读者可以掌握C#抽象类的概念、应用、好处以及一些特性。

    一、抽象类概念

    1. C#允许把类、属性和函数声明为abstract
    2. 抽象类不能实例化,抽象类可以包含普通属性和抽象属性,普通函数和抽象函数。
    3. 抽象函数就是只有函数定义没有函数体的函数。显然,抽象函数本身也是虚拟(virtual)的。

    注意:类是一个模板,那么抽象类就是一个不完整的模板。我们自然不可以使用不完整的模板去构造对象。

    二、示例讲解

    1、创建一个鸟类的抽象类

    // 鸟的抽象类
    abstract class Bird // 含有抽象属性和方法,就一定是抽象类
    {
    	// 鸟速度的属性
    	public double Speed { get; set; }
    	// 鸟体重的属性
        public abstract double Weight { get; set; }
        // 鸟飞翔的抽象方法 
        public abstract void Fly(); 
    }
    

    当一个类中如果有属性、方法被声明为 abstract时,这个类也要被声明为 abstract

    2、创建一个麻雀的类

    // 创建麻雀的类,继承自鸟
    class Sparrow : Bird // 继承了抽象类,此时必须要求实现抽象属性和方法
    {
    	// 麻雀体重的属性
    	public override double Weight { get; set; }
    	// 麻雀飞翔的方法 
        public override void Fly()
        {
            Console.WriteLine("麻雀的飞翔~");
        }
    }
    

    当继承一个抽象类时,必须去实现抽象属性、抽象方法。

    3、实例化一个麻雀和鸟

    // 用派生类声明和构造
    Sparrow sparrow = new Sparrow();
    sparrow.Fly();
    // 用抽象类声明,用派生类构造
    Bird bird = new Sparrow(); 
    bird.Fly();
    

    注意:我们可以通过抽象类去声明对象,但是不可以用抽象类去构造。

    4、执行结果,如下所示:

    在这里插入图片描述

    三、抽象类的作用

    当我们在写基类时,有的属性、方法是一定要被重写的,在基类中实现并没有意义。这时我们就可以将这种属性、方法写作抽象属性、抽象方法,并将基类改作抽象类,这样我们在写派生类时,直接对没有实现的抽象属性、抽象方法进行重写(override)即可。

    四、使用抽象类的好处

    抽象类是特殊的类,只是不能被实例化。除此以外,具有类的其他特性;重要的是抽象类可以包括抽象属性、抽象方法,这是普通类所不能的。

    1. 代码重用,派生类都能用抽象类定义的属性和方法。
    2. 灵活,某个派生类既可以继承该方法也可以派生一个新的。
    3. 抽象类是所有派生类通用方法的最小集合,可以封装某一个派生类的实例用来进行传递。

    五、抽象类总结

    1. 抽象类中的抽象属性和抽象方法必须是公有的,因此必须有public修饰符。
    2. 派生类必须重写(override)抽象类中的所有抽象属性和抽象方法,如果没有全部重写(override),那么派生类必须是抽象类。
    3. 抽象类中可以有非抽象属性和非抽象方法,也可以是私有或者公有,但是如果是私有的话,派生类就不能访问,这样也就无意义了,所以一般情况下都设置为公有。
    4. 有抽象属性或抽象方法的类一定是抽象类,抽象类中的属性或方法不一定都是抽象的。

    六、抽象类与接口的区别

    抽象类和接口都包含可以由派生类继承的成员,它们都不能直接实例化。关于接口的知识,请查看:C#接口(Interface)精讲

    1. 它们的派生类只能继承一个基类(所谓的单继承,多接口继承),即:只能直接继承一个抽象类,但是可以继承任意多个接口。
    2. 抽象类中可以定义成员的具体实现,但是接口却不行。
    3. 抽象类中可以包含字段,构造函数,析构函数,静态成员等,接口中不可以。
    4. 抽象类中的成员可以是私有的(只要它们不是抽象的),受保护的,内部的或者受保护的内部成员,但是接口中的成员必须是公共的(默认就是公共的)。
    展开全文
  • 抽象类、抽象方法、抽象属性

    千次阅读 2016-05-05 16:25:00
    在一个类前面加上“abstract”关键字,此类就成为了抽象类。一个方法类前面加上“abstract”关键字,此方法就成为了抽象方法。 抽象类一般用于表达一种比较抽象的事物,比如前面所说的“水果”,而抽象方法则说明此...

    在一个类前面加上“abstract”关键字,此类就成为了抽象类。一个方法类前面加上“abstract”关键字,此方法就成为了抽象方法。

    抽象类一般用于表达一种比较抽象的事物,比如前面所说的“水果”,而抽象方法则说明此抽象类应该具有的某种性质,比如Fruit 类中有一个抽象方法GrowInArea(),说明水果一定有一个最适合其生长的地区,但不同的水果生长地是不同的。

    abstract class Fruit //抽象类
    {
    public abstract void GrowInArea(); //抽象方法不能有实现代码,在函数名后直接跟一个分号。
    }

    抽象类专用于派生出子类,子类必须实现抽象类所声明的抽象方法,否则,子类仍是抽象类。

    从同一抽象类中继承的子类拥有相同的方法(即抽象类所定义的抽象方法),但这些方法的具体代码每个类都可以不一样。
    class Apple : Fruit //苹果
    {
      public override void GrowInArea()
      {
        Console.WriteLine("南方北方都可以种植我。");
      }
    }
    class Pineapple : Fruit //菠萝
    {
      public override void GrowInArea()
      {
        Console.WriteLine("我喜欢温暖,只能在南方看到我。");
      }
    }
    注意上述代码中的override 关键字,这说明子类重写了基类的抽象方法。抽象类不能创建对象,一般用它来引用子类对象。
    Fruit f;
    f = new Apple();
    f.GrowInArea();
    f = new Pineapple();
    f.GrowInArea();
    运行结果:
    南方北方都可以种植我。
    我喜欢温暖,只能在南方看到我。
    注意同一句代码“f.GrowInArea();”会由于f 所引用的对象不同而输出不同的结果。可以看到,代码运行结果类似于上一节介绍的“虚方法调用”,两者没有本质差别。
    可以按照以下公式编写代码:
    抽象类 抽象类变量名=new 继承自此抽象类的具体子类名();

    一个抽象类中可以包含非抽象的方法和字段。因此:包含抽象方法的类一定是抽象类,但抽象类中的方法不一定是抽象方法。

    除了方法可以是抽象的之外,属性也可以是抽象的,请看以下代码:
    abstract class Parent
    {
      public abstract String Message //抽象属性
      {
        get;
        set;
      }
    }
    class Child : Parent
    {
      private String _msg;
      public override String Message
      {
        get
        {
          return _msg;
        }
        set
        {
          _msg=value;
        }
      }
    }
    使用代码:
    Parent p = new Child();
    p.Message = "Hello";

    展开全文
  • 在Python中定义和使用抽象类及抽象方法

    原文链接:http://www.jb51.net/article/87710.htm

    本文根据自己的理解和思考,对原文略有改动。。。

    Python中我们可以使用abc模块来构建抽象类。在讲抽象类之前,先说下抽象方法的实现。

    抽象方法是基类中定义的方法,但却没有任何实现。在python中实现一个抽象方法的简单的方法是:

    class Sheep(object):
        def __init__(self):
            print '__init__ is called!'
        def get_size(self):
            raise NotImplementedError
    s=Sheep()#生成一个实例。注意实例化时,并没有抛出错误
    s.get_size()#只有调用该方法时才会抛出错误
    任何从Sheep继承下来的子类必须实现(重写)get_size方法,否则就会抛出一个错误。
    但这种实现方法有个缺点:定义的子类只有调用那个方法时才会抛错。
    这里有个简单方法可以在类被实例化时触发它:使用python提供的abc模块。

    import abc
    class Sheep(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def get_size(self):
            return
        
    class sheepson(Sheep):
        def __init__(self):
            print 'sheepson.__init__ is called!'
        
    s1=Sheep()   #报错,不能实例化抽象类
    s2=sheepson()#报错,不能实例化抽象类
    这里实例化Sheep类或实例化任意从其继承的子类(未实现get_size)时候都会抛出异常。
    因此,通过定义抽象类,可以定义子类的共同method(强制其实现)。
    如何使用抽象类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    通过ABCMeta元类来创建一个抽象类, 使用abstractmethod装饰器来表明抽象方法
    注册具体类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    
    class B(object):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    A.register(B)#从抽象类注册一个具体的类
     
    if __name__ == '__main__':
        print issubclass(B, A)    # print True
        print isinstance(B(), A)  # print True
    使用继承抽象类的方法来实现具体类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    
    class B(A):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    class C(A):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    if __name__ == '__main__':
        print issubclass(B, A)    # print True
        print isinstance(B(), A)  # print True
        print issubclass(C, A)    # print True
        print isinstance(C(), A)  # print True
    可以使用继承抽象类的方法来实现具体类,这样可以避免使用register。
    但是副作用是可以通过基类找出所有的具体类。。。。。

    print A.__subclasses__()
    for subclass in A.__subclasses__():
        print subclass.__name__
    使用继承的方式会找出所有的具体类,但如果使用register的方式则不会被找出。。。
    使用__subclasshook__ :
    使用__subclasshook__后只要具体类定义了与抽象类相同的方法就认为是他的子类。

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def say(self):
            return 'say yeah'
        @classmethod
        def __subclasshook__(cls, C):
            if cls is A:
                if any("say" in B.__dict__ for B in C.__mro__):
                    return True
            return NotImplemented
     
    class B(object):
        def say(self):
            return 'hello'
     
    print issubclass(B, A)    # True
    print isinstance(B(), A)  # True
    print B.__dict__      # {'say': <function say at 0x7f...>, ...}
    print A.__subclasshook__(B) # True
    不完整的实现:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
        
    class D(A):#类D继承了类A,重写了save方法,但没有重写load方法,因此,类D仍然是抽象类,不可实例化
        def save(self, output, data):
            return output.write(data)
     
    if __name__ == '__main__':
        print issubclass(D, A)    # print True
        print isinstance(D(), A)  # raise TypeError
    构建不完整的具体类,实际上仍然是抽象类,仍然不可实例化。。。
    具体类中使用抽象基类:

    import abc 
    from cStringIO import StringIO
    class A(object):#包含抽象方法的类称为抽象类,抽象类不可实例化
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def retrieve_values(self, input):
            print 'base class reading data'
            return input.read()
    
    class B(A):
        def retrieve_values(self, input):
            base_data = super(B, self).retrieve_values(input)
            print 'subclass sorting data'
            response = sorted(base_data.splitlines())
            return response
    
    input = StringIO("""line one
    line two
    line three
    """)
    reader = B()
    print reader.retrieve_values(input)
    运行结果:
    base class reading data
    subclass sorting data
    ['line one', 'line three', 'line two']
    可以使用super来重用抽象基类中的罗辑, 但会迫使子类提供覆盖方法。
    抽象属性:

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractproperty
        def value(self):
            return 'should never get here.'
     
    class B(A):
        @property
        def value(self):
            return 'concrete property.'
        
    try:
        a = A()#Can't instantiate abstract class A with abstract methods value
        print 'A.value', a.value
    except TypeError, err:
        print type(err)
        print err
        print str(err)
        print 'TypeError: ', str(err)
     
    b = B()
    print 'B.value:', b.value
    运行结果:
    <type 'exceptions.TypeError'>
    Can't instantiate abstract class A with abstract methods value
    Can't instantiate abstract class A with abstract methods value
    TypeError:  Can't instantiate abstract class A with abstract methods value
    B.value: concrete property.
    定义抽象的读写属性:

    import abc  
    class A(object):  
        __metaclass__ = abc.ABCMeta  
        def get_value(self):  
            return 'Should never see this.'  
        def set_value(self, value):  
            return  
        value = abc.abstractproperty(get_value, set_value)#value是 抽象的读写属性。 
       
    class B(A):  
        @abc.abstractproperty  
        def value(self):#重写value方法,但依然是抽象属性。
            return 'read-only'  
    
    class C(A):  
        _value = 'default value' #类的属性,所有实例可以共享  
        def get_value(self):  
            return self._value  
        def set_value(self, value):  
            self._value = value  
        #定义具体类的property时必须与抽象类的abstract property相同。如果只覆盖其中一个将不会工作。。  
        value = property(get_value,set_value)#此时的value是 具体的读写属性。
    
    try:  
        a = A()  
        print a.value  
    except Exception, err:  
        print str(err)  
    
    try:  
        b = B()  
        print b.value  
    except Exception, err:  
        print str(err)  
       
    c = C()  
    print C._value #通过类名 访问类的属性  
    print c.value #访问实例c自己的_value属性,但此时,实例c自己没有_value属性,因此实际访问的是类的 _value属性  
    c.value = 'hello' #为实例c添加一个_value属性,赋初值为'hello'  
    print c.value #访问实例c自己的_value属性  
    print C._value #访问类的_value属性  

    运行结果:
    Can't instantiate abstract class A with abstract methods value
    Can't instantiate abstract class B with abstract methods value
    default value
    default value
    hello
    default value
    注意:定义具体类的property时必须与抽象的abstract property相同。如果只覆盖其中一个将不会工作。
    使用装饰器语法来实现读写的抽象属性, 读和写的方法名应该相同。

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractproperty
        def value(self):
            return 'should never see this.'
        @value.setter
        def value(self, _value):
            return
     
    class B(A):
        _value = 'default'
        @property
        def value(self):
            return self._value
        @value.setter
        def value(self, _value):
            self._value = _value
     
    b = B()
    print b.value    #尝试访问实例b的_value属性,但b自己没有该属性,因此访问的是类的_value属性。
    b.value = 'hello'#为实例b添加_value属性,初始值为'hello'
    print b.value    #访问实例b自己的_value属性
    运行结果:
    default
    hello

    (完)


    展开全文
  • spring针对抽象类注入属性

    千次阅读 2020-04-26 00:11:08
    一直以为抽象类既然不能被实例化,那么自然的,也就不能被spring管理,既然不能被spring管理,自然也就不能使用@Autowired或者@Resource来注入属性了,但是其实是可以的,这样子,当我们有公用的代码的时候就不需要...
  • Java抽象类 详解

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象类的基本概念普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...
  • 接口可以继承接口。 抽象类并不能继承接口,但可以实现接口。 抽象类可以继承具体类...抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方.
  • 抽象类专用于派生出子类,子类必须实现抽象类所声明的抽象方法,否则,子类仍是抽象类。 包含抽象方法的类一定是抽象类,但抽象类中的方法不一定是抽象方法。 抽象类中可以没有抽象方法,但有抽象方法的一定是抽象类...
  • ② 成员 : 抽象类中既可以定义正常属性和方法 , 又可以定义抽象的属性和方法 ; ③ 继承 : 抽象类可以继承抽象类 , 抽象类也可以继承正常类 , 正常类可以继承抽象类 ; ④ 重写 : 抽象类中可以使用抽象方法重写正常...
  • spring中注入抽象类中的接口属性

    万次阅读 2014-04-11 11:06:25
    spring注入问题,spring不能直接注入抽象类 中的属性,只能通过其子类完全注入
  • 如题: 比如 abstract classA{ int a; int b; } class B extends A{ int c; int d; } class C extends A{ int e; int f;... 在B和C的映射文件里,继承的A的属性该如何映射
  • spring对抽象类属性的自动注入

    万次阅读 2013-05-06 11:21:04
    在使用spring的时候,有时由于设计的需要,需要使用抽象类(比如模板方法模式),但在抽象类中实现方法是需要依赖其他的接口或类的方法,这时就需要对依赖的接口或类进行注入,需要注意以下内容: 在抽象类中需要...
  • C#源代码—演示抽象类与抽象属性的使用,命名空间的使用
  • 抽象类中的属性初始化方式

    千次阅读 2014-10-18 15:05:24
    抽象类中的属性初始化方式 一、声明同时直接初始化 int c=5; 二、在构造函数中初始化 Test(){ c=5 } 注:其他方式会导致程序编译错误,如:Syntax error on token "c", VariableDeclaratorId ...
  • 抽象类是否可以没有方法和属性

    千次阅读 2019-05-07 23:31:32
    抽象类专用于派生出子类,子类必须实现抽象类所声明的抽象方法,否则,子类仍是抽象类。 包含抽象方法的类一定是抽象类,但抽象类中的方法不一定是抽象方法。 抽象类中可以没有抽象方法,但有抽象方法的一定是抽象...
  • 抽象类

    千次阅读 2019-01-29 16:30:36
    抽象类的概念 Java中允许在类中只声明方法而不提供方法的实现。这种只有声明而没有方法体的方法成为抽象方法,而包含一个或者多个抽象方法的类称为抽象类。 抽象方法是通过指定abstract关键字来创建。抽象方法没有...
  • java-抽象类和继承抽象类

    万次阅读 2018-02-09 16:17:15
    抽象类和继承抽象类 抽象类不能直接实例化,需要创建一个指向自己的对象引用(其子类)来实例化 代码: public class Main { public static void main(String[] args) { /* People people = new People(); *...
  • dephi中关于属性,方法的简单的描述。 静态方法,抽象方法等的区别是什么。个人整理,通俗易懂!
  • 创建抽象类Person,具有name属性,包含一个参数——姓名的构造方法,具备显示类信息的抽象方法display()。 创建Person的子类Student,属性包括姓名、年级、专业。重写父类的抽象方法。注意在类的继承中不能继承父类...
  • 本文实例讲述了php抽象方法和抽象类。...抽象类中可以有不是抽象的方法和成员属性。 但只要有一个抽象方法,这个类就必须定义为抽象类抽象类怎么用呢?最重要的一点是抽象类,不能产生实例对象!
  • typescript静态属性,静态方法(static) es5中的静态属性、静态方法 function Person(){ this.run1=function(){ } } Person.name='哈哈哈'; // 静态属性 Person.run2=function(){ alert('静态方法') } var p....
  • 抽象类、接口

    千次阅读 2019-05-07 20:19:15
    4、抽象类必须被继承,如果子类不是抽象类必须覆写抽象类的全部抽象方法。 定义格式; abstract class 抽象类名称{ 属性; 访问权限 返回值类型 方法名(参数) [return 返回值]; } 访问权限 abstract 返回值类型 ...
  • 答案是肯定的,可以。 抽象类中可以没有抽象方法,但有抽象方法的一定是抽象类。所以,java中 抽象类里面可以没有抽象方法。注意即使是没有抽象方法和属性抽象类,也不能被实例化。 ...
  • 新手小白学JAVA 抽象类

    万次阅读 多人点赞 2021-05-11 11:01:52
    3 抽象类 3.1 抽象类 Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法. Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类 如果一个类含有抽象方法...
  • 抽象类和非抽象类

    千次阅读 2011-10-29 19:08:32
    虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。允许(但不要求)抽象类包含抽象成员。抽象类不能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 515,897
精华内容 206,358
关键字:

抽象类的属性