精华内容
下载资源
问答
  • 同时抽象方法所在的类也要用abstract定义,表示抽象类。 举例:定义一个抽象类抽象类中没有具体实现,因此抽象类不能直接实例化对象 abstract class Person{ private String name;//姓名属性 ...

    一、抽象类

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

    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(){}
    }
    
    注意:对象实例化的核心步骤
      ①类加载
      ②类对象的空间开辟
      ③类对象中的属性初始化(构造方法)
    
    方法可以重写,属性不能重写。
    
    展开全文
  • 一、抽象类与抽象方法定义 抽象类:只在普通类的基础上扩充了一些抽象...抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象 举例:创建一个简单的抽象...

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

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

    所有的抽象方法和抽象方法所在的类都要使用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)抽象类中可以包含抽象成员,但非抽象类中不可以。...(1)抽象方法必须声明在抽象类中。 ...

    首先说抽象类:
    (1)抽象类只能作为其他类的基类,它不能直接实例化,对抽象类不能使用new 操作符。

    (2)抽象类中可以包含抽象成员,但非抽象类中不可以。

    (3)如果一个非抽象类从抽象类中派生,则其必须通过覆盖来实现所有继承而来的抽象成员。
    Java 中声明抽象类时需要使用abstract 关键字,具体语法格式如下:
    举例:定义抽象类Base
    插入图片描述
    再说抽象方法:
    (1)抽象方法必须声明在抽象类中。

    (2)抽象方法声明引入了一个新方法,但不提供该方法的实现,由于抽象方法不提供任何实际实现,因此抽象方法的方法体只包含一个分号。

    (3)声明抽象方法时,不能使用static 和private 修饰符。

    (4)当从抽象类派生一个非抽象类时,需要在非抽象类中重写抽象方法,以提供具体的实现。
    举例:我们先定义一个抽象类包含抽象方法:
    在这里插入图片描述
    再写一个实现类,需要重写上面的play()方法:
    在这里插入图片描述
    就是说abstract可以用于定义抽象类,也可以用于定义抽象方法。抽象类是一种不可以被实例化的类。抽象类中一般含有抽象方法(在声明方法时,加上abstract 关键字),当然也可以有具体实现。继承类只有实现抽象类的所有抽象方法后才能被实例化。
    需要注意的是,抽象类可以有构造方法,也可以包含静态方法(static),访问权限也不受限制。

    展开全文
  • 在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

    (完)


    展开全文
  • Java的抽象类中可以定义final方法吗?不太清楚,请指教谢谢
  • 抽象类一定有抽象方法吗?我来说说吧,静态是属于字节码的;一个抽象类可以没有抽象方法,只是为了不让别人来实例化它; 以上两点可以说明,...总结就是:抽象类中可以定义静态方法,只是抽象类自己不能实例化,所...
  • 首先,抽象类可以有构造器、静态方法抽象类不一定要被其他类继承,可直接不实例化就使用 抽象类可以有构造器、静态方法。...如果想拿抽象类直接使用,类就得定义静态方法 abstract class ...
  • 转自:https://www.cnblogs.com/zksh2016/p/5813857.html1、Java抽象类中不能有静态的抽象方法。 抽象类是不能实例化的,即不能...所以抽象类中不能有静态的抽象方法。 定义抽象方法的目的是重写此方法,但如果定...
  • 抽象类中定义静态方法

    千次阅读 2010-09-08 15:32:00
    一直认为抽象类不能实例化,所以就没有想过用直接调用方法,而是实例化它的子类,用子类调用方法, 没想到啊,在抽象类中定义static方法不就可以了吗,static方法属于类,不需要实例化。using System;using System....
  • python 如何定义抽象类和抽象方法

    千次阅读 2020-01-10 13:00:05
    文章目录(一)python 如何定义抽象类和抽象方法(二)python的多态(三)类的组合 (一)python 如何定义抽象类和抽象方法 在python类 通过继承metaclass = ABCmeta类来创建抽象类抽象类是包含抽象方法的类,...
  • 另外,实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。 还有,接口可以实现多重继承,而一个...
  • (2)特点:抽象成员必须在抽象类中声明,但抽象类不要求必须包含抽象成员,抽象类只能当做基类使用,而不能直接实例化。抽象类的用途提供多个派生类可共享的基类的公共定义。 (3)举例: public abstract class ...
  • 类的继承结构,越往上的类越具有通用性,也就越抽象。当它抽象到一定程度,就变成概念成框架,不能再产生实例化的对象了。例如“交通工具”,就无法用它...与抽象类紧密相连的是抽象方法一它总是用在抽象类或接口
  • 接口可以继承接口。 抽象类并不能继承接口,但可以实现接口。 抽象类可以继承具体类...抽象类在面向对象是被用来描述现实的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方.
  • java中抽象类的子类可以定义抽象类吗?比如我可以在在抽象子类再扩展抽象方法
  • 接口和抽象类中只有方法名,没有定义的,如果你不定义 也就是空方法,接口就是为了弥补java不能多重继承,接口针对的是对象而不是实现。实现的部分可以交由对象去实现。这就是java的多态啊。 ...
  • 抽象类定义

    千次阅读 2017-05-26 15:40:25
    抽象类定义  普通类可以直接产生实例化对象,并且在普通类可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分,抽象方法指的是没有...
  • 抽象类中是否一定要有抽象方法

    千次阅读 2020-06-11 09:20:14
    抽象类可以没有抽象方法,但是如果你...当你要求不能创建某个类的实例,只能通过其他类继承这个类来使用时,就可以定义抽象类抽象类可以没有抽象方法,也可以包含非抽象方法,但有抽象方法的类一定是抽象类。 ...
  • java中抽象类定义和使用

    千次阅读 2016-11-02 16:54:34
    java虽然比较简单,但是细节的知识点还是很多的,现在,介绍...1、抽象类定义的格式修饰符 abstract 类名 { 类体 }2、抽象方法格式:修饰符 abstract 返回值类型 方法名(); 注意:在抽象类方法不一定是抽象方法,含
  • 抽象类和抽象方法定义和使用

    千次阅读 2011-01-02 13:24:00
    <br />抽象类和抽象方法定义和... 1、类至少有一个抽象方法 2、抽象方法不允许有{ } 3、抽象方法前面必须要加abstract 抽象类的几个特点:  1、不能被实例化,只能被继承  
  • C# 允许把类和函数声明为abstract。 抽象类不能实例化,抽象类可以包含普通函数和抽象函数,抽象函数就是只有函数定义没有函数体。... 当一个类出现抽象方法时,这个类也必须定义抽象类。  继承一个抽象类的时候 ,
  • c++抽象类是怎么定义

    千次阅读 2020-11-03 11:27:45
    在c++含有纯虚函数的类是抽象类,纯虚函数是是在函数的原型后添加=0 在面向对象的概念,我们知道所有的对bai象都是通过du类来描绘的,但是反过来却不是这样。zhi并不是所有的类都是用来描绘对象的,如果一个类...
  • 抽象类和抽象方法

    千次阅读 2018-08-12 19:46:26
    摘自牛客网总结 含有abstract修饰符的class即为...abstract class类中定义抽象方法必须在具体(Concrete)子类实现,所以,不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类的所有抽象方法,那么...
  • 定义一个类时,常常需要定义一些方法描述类的行为特征,这些方法的实现方式是无法确定的。Java允许在定义方法时不... //定义抽象方法shout//定义抽象类animal abstract class animal { //定义抽象方法shout() abstra
  • C#抽象类、抽象属性、抽象方法

    千次阅读 2020-06-10 00:51:31
    前言:本博文讲述了C#面向对象抽象类,通过本博文的阅读,读者可以掌握C#抽象类的概念、应用、好处以及一些特性。 文章目录一、抽象类概念二、示例讲解三、抽象类的作用四、使用抽象类的好处五、抽象类总结 一、...
  • 抽象类的用法以及定义

    万次阅读 2016-07-15 15:07:34
    3.抽象类中含有抽象方法时,如果子类继承该抽象类,则必须重写该抽象方法 4.抽象类可以有非抽象方法 5.允许(但不要求)抽象类包含抽象成员。 6.抽象类不能被密封。 7.抽象类含有非抽象方法,而且子类继承该...
  • 然后又一个抽象类实现这个抽象接口 public abstract class ManagerRootImpl implements IManagerRoot{ } 最后再由一个普通的类继承抽象接口的实现类然后再实现一个抽象接口 public class BaseManagerImpl extends...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 836,964
精华内容 334,785
关键字:

抽象类中只能定义抽象方法