精华内容
下载资源
问答
  • python 如何定义抽象类和抽象方法

    千次阅读 2020-01-10 13:00:05
    文章目录(一)python 如何定义抽象类和抽象方法(二)python中的多态(三)类的组合 (一)python 如何定义抽象类和抽象方法 在python中类 通过继承metaclass = ABCmeta类来创建抽象类,抽象类是包含抽象方法的类,...

    (一)python 如何定义抽象类和抽象方法

    在python中类 通过继承metaclass = ABCmeta类来创建抽象类,抽象类是包含抽象方法的类,其中ABCmeta类(Metaclass for defining abstact baseclasses,抽象基类的元类)是所有抽象类的基类。

    定义了抽象类后,在要实现抽象方法的前一行使用@abc.abstractmethod来定义抽象方法。抽象方法不包含任何可实现的代码,只能在子类中实现抽象函数的代码。

    抽象类的特点:

    1. 抽象类不能被实例化
    2. 继承抽象类的类必须实现所有的抽象方法后,才能被实例化
    3. 抽象类中有抽象方法和正常方法
    4. 抽象类中可以添加成员属性

    注意:

    1. 抽象类中的抽象方法,在子类中必须实现该方法

    2. 抽象类不能被实例化

    3. 创建抽象方法前,必须先创建抽象类

    4. 需要导入abc(abstractclass)类

    5. python是动态语言(在程序运行时检查类型,对比:java是静态语言,在程序运行前检查类型)。动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用 ;

      也就是说,例如:传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法,且参数正确即可

    #coding:utf-8
    from abc import ABCMeta, abstractmethod
    
    class Person(object):
        __meta_class__ = ABCMeta
    
        def __init__(self, **kwargs):
            self.age = kwargs.get("age")
            self.name = kwargs.get("name")
    
        def hello(self):
            print "hello, my name is {}, and my age is {}".format(self.name, self.age)
    
        @abstractmethod
        def say(self):
            pass
    
    
    class Student(Person):
        def __init__(self, **kwargs):
            super(Student, self).__init__(**kwargs)
            self.school = kwargs.get("school")
    
        def say(self):
            print "my school is ", self.school
    
    stu = Student(name="wangming", age=19, school="Henan Politecnic University")
    stu.hello()
    stu.say()
    

    运行结果:

    hello, my name is wangming, and my age is 19
    my school is  Henan Politecnic University
    

    (二)python中的多态

    1. 子类可以继承父类的方法或者属性

    2. 子类也可以重写父类的方法或者属性,子类在重写父类的方法时可以改变函数的参数和方法体以及输出内容

    3. 对象在调用某个方法时,总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止

    4. 由于Python是动态语言,所以,传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法即可

    类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 Person 派生出 Student和Teacher ,并都写了一个 whoAmI() 方法:

    class Person(object):
        def init(self, name, gender):
            self.name = name
            self.gender = gender
    
        def whoAmI(self):
            return 'I am a Person, my name is %s' % self.name
    
    class Student(Person):
        def init(self, name, gender, score):
            super(Student, self).init(name, gender)
            self.score = score
    
        def whoAmI(self):
            return 'I am a Student, my name is %s' % self.name
    
    class Teacher(Person):
        def init(self, name, gender, course):
            super(Teacher, self).init(name, gender)#继承父类的初始化函数__init__()
            #Person.init(self, name, gender) #效果同上
            
            self.course = course
    
        def whoAmI(self):
            return 'I am a Teacher, my name is %s' % self.name
    
    #在一个函数中,如果我们接收一个变量 x,则无论该 x 是 Person、Student还是 Teacher,都可以正确打印出结果:
    
    def who_am_i(x):
        print x.whoAmI()
    
    p = Person('Tim', 'Male')
    s = Student('Bob', 'Male', 88)
    t = Teacher('Alice', 'Female', 'English')
    
    who_am_i(p)
    who_am_i(s)
    who_am_i(t)
    
    

    运行结果:

    I am a Person, my name is Tim
    I am a Student, my name is Bob
    I am a Teacher, my name is Alice
    这种行为称为多态。

    也就是说,方法调用将作用在 x 的实际类型上。s 是Student类型,它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法,但调用 s.whoAmI()总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止

    由于Python是动态语言,所以,传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法即可:

    class Book(object):
    def whoAmI(self):
    return ‘I am a book’
    这是动态语言和静态语言(例如Java)最大的差别之一。动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用。

    (三)类的组合

    '''
    1.class类的组合使用
    2.手机、邮箱、QQ等是可以变化的(定义在一起),姓名不可变(单独定义)。
    3.在另一个类中引用
    '''
     
     
    class Info(object):
        def __init__(self, phone, email, qq):
            self.phone = phone
            self.email = email
            self.qq = qq
     
        def get_phone(self):
            return self.phone
     
        def update_phone(self, newphone):
            self.phone = newphone
            print u"手机号更改已更改"
     
        def get_email(self):
            return self.email
     
    class AddrBook(object):
        '''docstring for AddBook'''
        def __init__(self, name, phone, email, qq):
            self.name = name
            self.info = Info(phone, email, qq)
     
    if __name__ == "__main__":
        Detian = AddrBook('handetian', '18210413001', 'detian@xkops.com', '123456')
        print Detian.info.get_phone()
        Detian.info.update_phone(18210413002)
        print Detian.info.get_phone()
        print Detian.info.get_email()
    
    
    展开全文
  • 定义:在普通类的基础上扩充了一些抽象方法 。 1. 抽象方法:只声明而未实现的方法(没有方法体) 所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义,表示抽象类。 举例:定义一个抽象...

    一、抽象类

    	定义:在普通类的基础上扩充了一些抽象方法 。
    

    1. 抽象方法:只声明而未实现的方法(没有方法体

    • 所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义,表示抽象类。
    • 举例:定义一个抽象类:

    抽象类中没有具体实现,因此抽象类不能直接实例化对象

    abstract class Person{
    	private String name;//姓名属性
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	//{}为方法体,所有抽象方法没有方法体{}
    	public abstract void getPersonInfo();//抽象方法
    }	
    

    2.抽象类的使用原则

    (1)抽象类必须有子类(abstract与final不能同时使用)。
    (2)子类覆写抽象类所有的抽象方法(abstract与private不能同时使用)。
    (3)抽象类实例化对象,必须通过子类向上转型来实例化对象(抽象类无法直接实例化对象)。
    final与abstract不能同时使用
    private与abstract不能同时使用

    //抽象类的标准操作,也是常用操作。
    
    abstract class Person{
    	//姓名属性
    	private String name;
    	//普通方法
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name=name;
    	}
    	//抽象方法
    	public abstract void getPersonInfo();
    }
    
    //子类继承抽象类
    class Student extends Person{
    	public void getPersonInfo(){
    		System.out.println("I am a student");
    	}
    }	
    
    public class Test{
    	public static void main(String[] args){
    		//实例化子类,向上转型
    		Person per = new Student();	
    		//被子类所覆写的方法
    		per.getPersonInfo();
    	}
    }
    
    运行结果:I am a student
    
    abstract class Person{
        private String name ; // 属性
        public String getName(){ // 普通方法
            return this.name;
        }
        public void setName(String name){
            this.name = name ;
        }
        
        public abstract void getPersonInfo() ; //抽象方法
    
        public static Person getInstance() { //取得A类对象
        	//定义抽象类的子类 (内部类)
            class Student extends Person {  
                public void getPersonInfo() {
                    System.out.println("I am a student");
                }
            }
            return new Student();
        }
    }
    
    public class Test{
        public static void main(String[] args) {
            Person per = Person.getInstance();
            per.getPersonInfo() ; //被子类所覆写的方法
        }
    }
    
    运行结果:I am a student
    

    3.抽象类的相关规定

    (1)抽象类也提供构造方法,并且子类也遵循对象实例化流程:先调用父类构造方法,再调用子类构造方法

    abstract class Person{
    	private String name;
    	public String getName(){
    		return name;
    	}
    	
    	//父类构造方法
    	public Person(){
    		System.out.println("1.**************");
    	}
    
    	//抽象方法
    	public abstract void fun();
    }
    
    class Student extends Person{
    	//子类构造方法
    	public Student(){
    		System.out.println("2.##############");
    	}
    
    	public void fun(){
    		System.out.println("子类继承抽象类");
    	}
    }
    public class Test{
    	public static void main(String[] args){
    		new Student();//先调用父类构造方法,再调用子类构造方法
    	}
    }
    
    运行结果:
    1.**************
    2.##############
    
    //面试题
    
    abstract class Person{
    	public Person(){//3.调用父类构造
    		this.print();//4.调用被子类覆写的方法
    	}
    	public abstract void print();//抽象方法
    }
    
    class Student extends Person{
    	private int num = 100;//此句在对象new成功后才会用到,此句告诉构造方法要将num赋值为100
    	public Student(int num){//2.调用子类实例化对象
    		// super();//3.隐含这一句,实际要先调用父类构造。此时还未执行“将num赋值为100”的操作,就去调用父类构造了。num默认为int的默认值0。
    		//num=100;//此句在构造方法中隐式实现。
    		//总的来说,构造方法会隐藏  给变量的赋值操作。 
    		
    		this.num=num;//7.为类中属性初始化
    	}
    	public void print(){//5.此时子类对象的属性还没有被初始化
    		System.out.println(this.num);//6.输出其对应数据类型的默认值,为0
    	}
    }
    
    public class Test{
    	public static void main(String[] args){
    		//先调用父类构造方法,再调用子类构造方法。调用父类构造后,调用打印方法,输出num的值0。调用子类构造,在内存中完成num赋值为30,但并未调用打印方法,因而只有一个值。
    		new Student(30);//1.实例化子类对象
    	}
    }
    //父类中num=0,子类中num=30。但由于子类中没有调用打印方法,所以只有一个父类的num值,为0。
    运行结果:0
    

    (2)抽象类中可以不定义抽象方法,但仍然无法直接实例化对象。
    在这里插入图片描述
    (3)abstract与final、private不能一起用。

    • final声明的类不允许有子类,而abstract抽象类必须有子类。
    • 抽象方法必须要被覆写,因此不能用private封装。
      (4)抽象类也分为内部抽象类和外部抽象类。
    • 内部抽象类(了解)可以使用static定义来描述外部抽象类
      在这里插入图片描述
      如果此时在外部抽象类中使用static就会出现语法错误,但是内部抽象类允许使用static
    //内部抽象类使用static修饰
    
    abstract class A{//此结果出现几率很低
    	public abstract void printA();
    	static abstract class B{
    		public abstract void printB();
    	}
    }
    class x extends A.B{
    	public void printB(){}
    }
    
    注意:对象实例化的核心步骤
      ①类加载
      ②类对象的空间开辟
      ③类对象中的属性初始化(构造方法)
    
    方法可以重写,属性不能重写。
    
    展开全文
  • 在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

    (完)


    展开全文
  • 一、抽象类与抽象方法定义 抽象类:只在普通类的基础上扩充了一些抽象方法 抽象方法:只声明而未实现的实体(即抽象方法没有方法体) 所有的抽象方法抽象方法所在的类都要使用abstract关键字定义,用abstract...

    一、抽象类与抽象方法的定义

    • 抽象类:只在普通类的基础上扩充了一些抽象方法
    • 抽象方法:只声明而未实现的实体(即抽象方法没有方法体)

    所有的抽象方法和抽象方法所在的类都要使用abstract关键字定义,用abstract关键字定义的抽象方法所在的类称为抽象类

    抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象

    举例:创建一个简单的抽象类

    abstract class Person{
    	public String name;//属性
    	public int age;//属性
    			
    	public abstract void eat();//抽象方法
    			
    	public void play(){//普通方法
    		System.out.println(name+"玩");
    	}
    			
    }

    二、抽象类的使用规则

    • 所有的抽象类必须含有子类;
    • final和abstract不能同时使用;
    • 抽象类的自雷必须腹泻抽象类的所有抽象方法(子类不是抽象类);
    • private和abstract不能同时使用;
    • 抽象类实例化对象,必须通过子类向上转型来实例化对象(抽象类无法直接实例化对象)。

    举例:抽象类的使用

    abstract class Person{
        public String name;//属性
         
        public String getName(){//普通方法
             return this.name;
        }
    	
        public void setName(String name){
             this.name = name;
        }
        //{}为方法体,所有抽象方法上不包括方法体
    
    	public void play(){//普通方法
    		System.out.println(name+"玩");
    	}
        public abstract void eat();//抽象方法
    }
    
    //继承抽象类	
    class Student extends Person{
    	public abstract void eat(){
    		System.ouut.println("I am eating food");
    	}
    }
    
    public class Teat{
    	public static void main(String[] args){
    		Person person = new Student;//实例化子类,向上转型
    		person.eat();//被子类覆写的方法
    	}
    }	

     

     三、抽象类的相关规定

    • 抽象类比普通类多了一些抽象方法,所以在抽象类中也允许提供构造方法,并且子类遵循对象的实例化流程(先调用父类的构造方法,再调用子类构造方法)。实例化子类时一定要先调用父类的构造方法;
    • 如果父类没有无参构造,那么子类必须使用super明确指出父类的哪个构造方法;
    • 抽象类中可以不定义任何的构造方法,但该抽象类无法直接创建实例化对象;
    • 抽象类不能用final声明,因为final声明的类不允许有子类,而abstract抽象类必须有子类;
    • 抽象方法不能用private定义,因为抽象方法必须要被覆写;
    • 抽象类也分为内部抽象类和外部抽象类,内部抽象类可以使用static定义来描述外部抽象类。

     

    展开全文
  • 抽象类和抽象方法定义及讲解?

    千次阅读 2019-02-26 17:26:23
    首先说抽象类: (1)抽象类只能作为其他类的基类,它不能直接实例化,对抽象类不能使用new 操作符。 (2)抽象类中可以包含抽象...举例:定义抽象类Base 再说抽象方法: (1)抽象方法必须声明在抽象类中。 ...
  • Runnable类的源码: public abstract void run(); 这里用不用abstract什么区别?
  • (Java)在枚举类中定义抽象方法

    千次阅读 2020-02-19 23:05:19
    枚举类除了可以实现接口外,还可以在枚举类中定义抽象方法,这样每个枚举的对象只要分别实现了此抽象方法即可。 enum Color{ RED{ public String getColor(){//枚举对象实现抽象方法 return "红色"; } }, ...
  • 创建抽象类: package my; abstract class Fruit { public String color; public Fruit(){ color="绿色"; } public abstract void harvest(); } 创建子类: package my; public class Apple ...
  • 在枚举类中定义抽象方法

    千次阅读 2012-10-15 09:28:16
    public String getColor(){//枚举对象实现抽象方法 return "红色"; } }, GREEN{ public String getColor(){//枚举对象实现抽象方法 return "绿色"; } }, BLUE{ public String ...
  • 抽象类必须要有抽象方法吗?

    万次阅读 2019-07-24 19:05:41
    答案是:不必须 这道题考察的是抽象类的知识: 抽象类必须关键字abstract来修饰。 抽象类可以不含有抽象方法 如果一个类包含抽象方法,则该类必须是抽象类 ...
  • 枚举类型的抽象方法定义实现

    千次阅读 2014-09-15 09:20:58
    package ... import org.junit.Test;...public class abstractEnumTest { ... * 枚举中的说抽象方法 则需要在创建对象的时候实现抽象方法定义 */ public abstract String localValue(); }
  • 定义一个抽象类Person,其中一个公共的抽象方法work()。定义Person的子类:Student(学生)、Teacher(教师)。学生的工作是“预习、学习、复习、写作业”;教师的工作是“备课、上课、辅导、批改作业”。编写Test类,...
  • 转自:https://www.cnblogs.com/zksh2016/p/5813857.html1、Java抽象类中不能静态的抽象方法。 抽象类是不能实例化的,即不能被分配内存;而static修饰的方法在类... 定义抽象方法的目的是重写此方法,但如果定...
  • 定义一个类时,常常需要定义一些方法描述类的行为特征,这些方法的实现方式是无法确定的。Java允许在定义方法时不... //定义抽象方法shout//定义抽象类animal abstract class animal { //定义抽象方法shout() abstra
  • 抽象类和抽象方法定义和使用

    千次阅读 2011-01-02 13:24:00
    所以如果定义抽象类首先定义抽象方法。 1、类中至少一个抽象方法 2、抽象方法不允许{ } 3、抽象方法前面必须要加abstract 抽象类的几个特点:  1、不能被实例化,只能被继承...
  • 定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而不需要重复类的共同特性。这样就使得程序概念层次分明,开发更...
  • 抽象类和抽象方法

    千次阅读 2018-08-12 19:46:26
    摘自牛客网总结 含有abstract修饰符的class即为...abstract class类中定义抽象方法必须在具体(Concrete)子类中实现,所以,不能抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法,那么...
  • java接口中抽象方法定义与使用

    千次阅读 2020-11-05 22:58:21
    1、定义一个接口类,在接口类里面定义抽象方法 抽象方法的格式: public abstract 返回值类型 方法名称(参数列表); 注意: 接口当中的抽象方法,修饰符必须是两个固定的关键字,即public abstract;这两个关键字不...
  • 抽象类一定有抽象方法吗?我来说说吧,静态是属于字节码的;一个抽象类可以没有抽象方法,只是为了不让别人来实例化它; 以上两点可以说明,静态方法只要字节码存在就可以运行,所以抽象类中可以静态方法。 我再...
  • #!/usr/bin/env python # coding:UTF-8 ""...@file: 父类指定子类继承后一定要实现的方法.py @time: 2018/10/21 15:24 """ ''' 1、如果子类在继承后一定要实现的方...
  • 吃东西的抽象方法。 一个显示自已信息普通方法。 定义一个子类Bird。重写父类抽象方法(鸟吃虫)。并自己特有的fly()的方法“鸟儿在飞行”,重写show()方法,输出“鸟儿健康快乐” 定义一个子类Fish。重写父类...
  • 下面重点介绍JAVASE 8.0的新特性 接口允许定义抽象方法 import java.lang.reflect.Method; /** * JavaSE 8新特性: 1.接口可以定义抽象方法 但必须使用default或者staic关键字来修饰 */ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 985,941
精华内容 394,376
关键字:

定义抽象方法需有方法的