精华内容
下载资源
问答
  • 抽象与具体类区别

    千次阅读 2018-07-07 12:28:00
    abstract 抽象是不能被直接实例化的类、用例、信号、其他类元或其他泛化元素,它也可以用来描述没有实现的操作。反义词:具体(concrete)。 见抽象操作(abstract opera
    原文地址为:
    抽象类与具体类区别
    

    abstract

    抽象是不能被直接实例化的类、用例、信号、其他类元或其他泛化元素,它也可以用来描述没有实现的操作。反义词:具体(concrete)

    抽象操作(abstract operation)可泛化元素(generalizable element)

    语义

    抽象类是不可被实例化的类,即它可以没有直接实例,这既可能是因为它的描述是不完整的(如缺少一个或多个操作的方法),也可能是因为即使它的描述是完整的它也不想被实例化。抽象类是为了以后说明。抽象类必须有可能含有实例的后代才能使用,一个抽象的叶类是没用的(它可以作为叶在框架中出现,但是最终它必须被说明)。

    具体类可以没有任何抽象操作(否则,它必为抽象的),但是抽象类可以有具体操作。具体操作是可以被实现一次并在所有子类中不变地使用的操作。在它们的实现中,具体操作可以只使用声明它们的类所知道的特征(属性和操作)。继承的目的之一即将这些操作在抽象的超类中分解以使得它们可以被所有的子类分享。一个具体操作可以是多态的,即后代类中的方法优先于它,但是它也可以不必是多态的,它可以是一个叶操作。一个所有操作都被实现的类可以是抽象的,但是这一点必须被明确声明。一个有着一个或多个未实现操作的类自然是抽象的。

    同样的语义也适用于用例。抽象的用例定义了行为的片断,这个行为自己不能出现,但是它可以通过泛化、包括或扩展关系在具体用例的定义中出现。通过在抽象的用例中分解公用的行为,模型变得更小和易于理解。

    类似的关系也存在于其他的类元和泛化元素中。


    转载请注明本文地址: 抽象类与具体类区别
    展开全文
  • 大家面试的时候肯定被问过java 接口、抽象类、具体类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系

    大家面试的时候肯定被问过java 接口、抽象类、类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。(主要是总结了下网上的资料,不是自己原创的。)总结的不好,请勿喷。^_^

    java 接口:
     使用interface来定义一个接口。接口定义同类的定义类似,也是分为接口的声明和接口体,其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下:

    [修饰符] interface 接口名 [extends 父接口名列表]{

    [public] [static] [final] 常量;
    [public] [abstract] 方法;
    }
    修饰符:可选,用于指定接口的访问权限,可选值为public。如果省略则使用默认的访问权限。
    接口名:必选参数,用于指定接口的名称,接口名必须是合法的Java标识符。一般情况下,要求首字母大写。(个人习惯:在接口类名前先写一个I_后面跟着接口名称)
    extends 父接口名列表:可选参数,用于指定要定义的接口继承于哪个父接口。当使用extends关键字时,父接口名为必选参数。
    方法:接口中的方法只有定义而没有被实现。

    接口中可以定义变量和方法,但是一般人不会在接口中定义变量,因为在接口中定义的变量会被隐式的定义为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误)。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口中所有的方法不能有具体的实现。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口允许任何类去实现它,一个类如果实现一个接口,那么这个类就要把这个借口中的所有方法都实现了。

    所以说java接口中的方法都是极度抽象的类型,它比抽象类更加严格的“抽象”。

    其实java中的接口是为了解决java中单继承而来的,大家都知道,java中一个类只能有继承一个父类,不像C++中可以多继承,一个孩子可以有多个爸爸。java严格按照我们生活中的人与人的关系,一个孩子只能有一个爸爸,但是可以有多个干爹(现在的干爹都不靠谱啊,原因你懂的。),一个孩子可以继承父亲的所有遗产,但是也可以拥有多个干爹的遗产,前提是他的干爹愿意把遗产给他。(这里指的是别的接口中的方法)。

    java 抽象类:
    下面是java抽象类的定义语法。
    public abstract class Demo01 {
    
    	public abstract void addUser();//抽象方法
    	
    }
    java抽象类必须要以abstract  来进行修饰,抽象类可以继承抽象类。一个类中存在一个抽象方法,那么这个类必须要定义成抽象类。java中抽象类的访问控制修饰符默认是public类型的,抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。因为,抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以,锁应该归其子类所有。所以,抽象方法也就不能用synchronized关键字修饰了;native这个东西本身就和abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?  总之:抽象类是提取具体类的公因式。
    java 内部类:
    java内部类一般使用不是很多,但是其实也很好理解。就是一个类中再次定义了一个类。可以理解为在一个大的厂房里面又盖了个小的厂房。大厂房有它自己的构造组成。小厂房也是有小厂房的构造组成的。内部类破坏了良好的代码结构,但是我们平时还是需要用到的,因为内部类可以随意使用外部类的属性和方法。
    下面是内部类访问外部类的示例及内部类的基本格式:
    package test;
    
    public class test {
    	private String name = "小熊猫";
    	
    	
    	class in {
    		private String name = "丢丢";
    		
    		public void sal(){
    			String name = "小熊猫丢丢";
    			
    			System.out.println("局部变量name:"+name);
    			System.out.println("内部类变量name:"+this.name);
    			System.out.println("外部类变量name:"+test.this.name);
    			
    		}
    		
    	}
    	
    	public static class ma {
    		public static void main(String[] args) {
    			test.in in = new test().new in();
    			in.sal();
    			
    		}
    	}
    
    }

    其实java内部类也是一个类,与其他类不同的是内部类是类中类,它的作用范围只能在这个类中。

    java 匿名内部类:
    匿名内部类的定义语法如下:

    new 父类构造器(参数列表)|实现接口()    
        {    
         //匿名内部类的类体部分    
        } 
    虽然看上去很简单,但是还有一些注意事项需要我们注意的:
    1:使用匿名内部类必须实现一个接口或者继承一个类,但是鱼和熊掌不可兼得,至于是继承类还是实现接口需要根据业务要求去走了。
    2:匿名内部类中不可以定义构造函数。
    3:匿名内部类中不可以有任何静态方法和静态成员变量(这个是因为静态方法或者静态成员变量在加载的时候会直接加载,而普通的成员变量或方法需要在类加载的时候才会去       加载)
    4:匿名内部类也是局部内部类,所以局部内部类的限制对匿名内部类同样有效。
    5:匿名内部类不能是抽象的,它必须要实现继承的类或者实现接口中所有的抽象方法。


    关于java类的一些类就先写到这了,下面会陆续写一些关于多线程与高并发的一些文档,如有一些不对的地方欢迎大家指出,大家共同学习共同进步。

    展开全文
  • 抽象接口之间的继承和实现关系  对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的...

    抽象类与接口之间的继承和实现关系

           对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。下面是本文的目录大纲:

      一.抽象类

      二.接口

      三.抽象类和接口的区别

      【关于接口与抽象类的介绍转载自网友海子(个人非常喜欢的一位博主,博客内容十分丰富,想学习更多java知识的同学可以戳下面的链接),在文章后面将结合线程池的设计例子介绍接口与抽象类的关系】

         四.抽象类与接口的继承与实现关系

         请尊重作者劳动成果,转载请标明原文链接:

      http://www.cnblogs.com/dolphin0520/p/3811437.html

    一.抽象类

      在了解抽象类之前,先来了解一下抽象方法。抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为:

    1
    abstract  void  fun();

      抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。

      下面要注意一个问题:在《JAVA编程思想》一书中,将抽象类定义为“包含抽象方法的类”,但是后面发现如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧,因为如果一个抽象类不包含任何抽象方法,为何还要设计为抽象类?所以暂且记住这个概念吧,不必去深究为什么。

    1
    2
    3
    [ public abstract  class  ClassName {
         abstract  void  fun();
    }

      从这里可以看出,抽象类就是为了继承而存在的,如果你定义了一个抽象类,却不去继承它,那么等于白白创建了这个抽象类,因为你不能用它来做任何事情。对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求来进行不同的实现,那么就可以将这个方法声明为abstract方法,此时这个类也就成为abstract类了。

      包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别:

      1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。

      2)抽象类不能用来创建对象;

      3)如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。

      在其他方面,抽象类和普通的类并没有区别。

    二.接口

      接口,英文称作interface,在软件工程中,接口泛指供别人调用的方法或者函数。从这里,我们可以体会到Java语言设计者的初衷,它是对行为的抽象。在Java中,定一个接口的形式如下:

    1
    2
    3
    [ public interface  InterfaceName {
     
    }

      接口中可以含有 变量和方法。但是要注意,接口中的变量会被隐式地指定为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误),并且接口中所有的方法不能有具体的实现,也就是说,接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别,接口是一种极度抽象的类型,它比抽象类更加“抽象”,并且一般情况下不在接口中定义变量。

      要让一个类遵循某组特地的接口需要使用implements关键字,具体格式如下:

    1
    2
    class  ClassName  implements  Interface1,Interface2,[....]{
    }

      可以看出,允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口,就必须实现该接口中的所有方法。对于遵循某个接口的抽象类,可以不实现该接口中的抽象方法。

    三.抽象类和接口的区别

    1.语法层面上的区别

      1)抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;

      2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;

      3)接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;

      4)一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    2.设计层面上的区别

      1)抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

      2)设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

      下面看一个网上流传最广泛的例子:门和警报的例子:门都有open( )和close( )两个动作,此时我们可以定义通过抽象类和接口来定义这个抽象概念:

    1
    2
    3
    4
    abstract  class  Door {
         public  abstract  void  open();
         public  abstract  void  close();
    }

      或者:

    1
    2
    3
    4
    interface  Door {
         public  abstract  void  open();
         public  abstract  void  close();
    }

      但是现在如果我们需要门具有报警alarm( )的功能,那么该如何实现?下面提供两种思路:

      1)将这三个功能都放在抽象类里面,但是这样一来所有继承于这个抽象类的子类都具备了报警功能,但是有的门并不一定具备报警功能;

      2)将这三个功能都放在接口里面,需要用到报警功能的类就需要实现这个接口中的open( )和close( ),也许这个类根本就不具备open( )和close( )这两个功能,比如火灾报警器。

      从这里可以看出, Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为,open()和close()属于门本身固有的行为特性,而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口,包含alarm()行为,Door设计为单独的一个抽象类,包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    interface  Alram {
         void  alarm();
    }
     
    abstract  class  Door {
         void  open();
         void  close();
    }
     
    class  AlarmDoor  extends  Door  implements  Alarm {
         void  oepn() {
           //....
         }
         void  close() {
           //....
         }
         void  alarm() {
           //....
         }
    }

     

    四、抽象类与接口的继承与实现关系

        以线程池的例子来说明接口、抽象类以及类在继承和现实时需要注意的事项

    1.接口继承接口(接口不能实现接口)

    Executor是线程池的顶层接口,只有一个方法

    1
    2
    3
    public  interface  Executor {
         void  execute(Runnable command);
    }

    public interface ExecutorService extends Executor {
          <strong> // <span style="font-family: Verdana, Arial, Helvetica, sans-serif;">ExecutorService 接口继承自接口Executor</span></strong>
        void shutdown();
        boolean isShutdown();
        boolean isTerminated();
        boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;
        <T> Future<T> submit(Callable<T> task);
    }

    2.抽象类实现接口(抽象类不能继承接口)

    <pre name="code" class="java">public abstract class AbstractExecutorService implements ExecutorService {
       <strong> // AbstractExecutorService 实现ExecutorService接口,不需要实现ExecutorService接口的方法,因为接口可以看做一种特殊的抽象类       // 抽象类里边的普通方法必须包含方法体,即必须有{},而抽象方法不能有方法体,必须用abstract声明。</strong>
        protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
        public Future<?> submit(Runnable task) {};
        public <T> Future<T> submit(Runnable task, T result) { };
        public <T> Future<T> submit(Callable<T> task) { };
        private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                                boolean timed, long nanos)
            throws InterruptedException, ExecutionException, TimeoutException {
        };
    }

     3.普通类继承抽象类或实现接口 
     

        普通类继承抽象类:必须实现抽象类的所有抽象方法和该抽象类父类的所有方法

        普通类实现接口:必须实现接口及其父接口的全部方法

            public interface A{
    		void a();
    	}
    	
    	public interface B extends A{
    		void b();
    	}
    	
    	public abstract class C implements B{
    		void c(){};
    		abstract void c1();
    	}
    	
    	
    	class D extends C{
    
    		@Override
    		public void b() {
    			// TODO Auto-generated method stub
    			
    		}
    
    		@Override
    		public void a() {
    			// TODO Auto-generated method stub
    			
    		}
    
    		@Override
    		void c1() {
    			// TODO Auto-generated method stub
    			
    		}
    		
    	}
    	
    	class E implements B{
    
    		@Override
    		public void a() {
    			// TODO Auto-generated method stub
    			
    		}
    
    		@Override
    		public void b() {
    			// TODO Auto-generated method stub
    			
    		}
    		
    	}



    展开全文
  • 所谓"抽象""具体

    千次阅读 2017-10-14 23:52:35
    抽象

    看了一篇电影评析,想谈一下”抽象”

    马克思指出:抽象与具体的辩证法应是”具体-抽象-具体”的方法,是从具体上升到抽象与从抽象上升到具体的内在统一。

    在高中数学课上,我也在数列章节中熟练的运用了假设,验证的方法,在导数中用抽象来求瞬时速度。

    然而,当在生活实践中时,抽象却感觉是如此的难。

    突然觉得,抽象和具体是一种极高的个人能力,它影响你的幸福感,你的人生高度,工作前景,生活品质等。当我们始终着眼于当前的琐碎事情时,其实已经故步自封,坐井观天了。因为你只是完成了这件琐事,没有去升华它。

    • 比如我要开发一个小系统,如果仅仅是为了完成领导布置的所谓功能,其实不是什么难事,难就难在你从领导的角度思考这个系统为什么要有这个功能;用户使用会有什么反馈;与这个系统对接的是哪些系统;对接遇到哪些问题;这个系统在行业内有什么口碑;目前各大公司开发进度如何。
      一旦你用这种思想去考虑了,那么才算真正的了解你做的东西。我想这也是为什么好的销售员的待遇那么高的原因吧,因为他们会站在高处去俯视产品,这种俯视,即为抽象。

    c++中有一种抽象数据类型(ADT, Abstract data type),它就是通过类来表示更通用的类型。

    举个例子:
    写一个具体类:

    typedef unsigned long Item;
    class Stack
    {
    private:
        enum {MAX=10;};
        Item item[MAX];
        int top;
    public:
        Stack();
        bool isEmpty() const;
        bool isFull() cosnt;
        bool push(const Item& item);
        bool pop(Item& item);
    };
    • 这是一个栈的实现,c++用栈管理自动变量的,从业务上讲,栈实现的功能如下:
      (1)创建空栈
      (2)添加数据到栈,即压入栈
      (3)栈顶删除数据,即弹出栈
      (4)查看是否填满/为空
      分析这种业务需求比单纯的关注技术实现要有意义的多。

    当然,实际上栈同时又是一种容器,继续抽象分析上层业务,其实list,vector等都属于一种容器,只是功能稍有差别而已。

    所以关系就是:容器->栈/列表/map->各自类实现

    这种既有的概念仅仅是举个示例而已。

    总结:

    • 1.一个人应该抽象出上层业务逻辑,而不应该仅仅抱着技术细节不放,不然会让思维受到禁锢,无法上升一个层面,容易坐井观天。
    • 2.其实知识最初是没有边界的,由于社会的具体分工才会有专业出现,如果你不能做到将学到的东西融会贯通,那么就属于片面的,断层的,缺少骨骼的。
    • 3.一个人的格局决定了你的抽象能力,科比能带湖人队多次问鼎,退役后在商界当然也能如此。
    展开全文
  • 抽象类和接口的关系对比

    千次阅读 2007-04-06 11:42:00
    抽象抽象类主要用来定义一些抽象的属性和方法,留待子类根据自己...如果需要实现多个类的抽象方法,必须使用接口子类与抽象类是is关系接口接口主要用来定义一些抽象的属性和方法,留待实现类根据自己的情况实现这些属
  • 面向对象——抽象与抽象方法

    千次阅读 2020-04-13 09:26:04
    如果一个类不与具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符可...
  • 1.具体产品在应用层的代码隔离,无需关系创建的细节 2.将一个系列的产品统一到一起创建 缺点: 1.规定了所有可能被创建的产品集合,产品族中扩展新的产品困难; 2.增加了系统的抽象性和理解难度 2、使用场景 1....
  • java抽象类和继承关系

    千次阅读 2013-07-02 23:59:12
    有时候,我们可能想要构造一个很抽象的父类对象,它可能仅仅代表一个分类或抽象概念,它的实例没有任何意义,因此不希望它能被实例化。例如:有一个父类“ 水果(Fruit)”,它有几个子类“苹果(Apple)”、“橘子...
  • Java基础——抽象类和接口的关系

    千次阅读 2015-02-22 23:09:36
    在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是并不是所有的类都能用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就应该被定义为抽象类。 抽象类 概述  比如,...
  • 具象读作jù xiàng,形容词,具体的,不抽象的 具有实象存在,与抽象相对 具象化是什么意思,就是把抽象的东西 表现得很具体 简单地说 就是把看不见的、不容易理解的,变得看得见、容易理解.====================...
  • 首先抽象类归根结底还是属于类,对于抽象方法,是只能存在于抽象类中的,我们无法再一个非抽象的类中声明一个抽象方法,其次抽象方法只需要声明,并不需要事先。当我们要写一个抽象类的时候只需要在类的前面声明为...
  • 用这种结构关系来描述现实世界的一般化的抽象关系。 整体部分结构关系称为组装结构关系,是“has a”关系。 上层类表示整体,下层类表示部分,成员。 例如飞机和发动机都是类,发动机是飞机的一部
  • Java笔试面试-抽象接口

    万次阅读 多人点赞 2019-09-15 22:29:50
      在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字 ...
  • C++虚函数JAVA中抽象函数比较 1:java中没有虚函数的概念,但是有抽象函数的概念,用abstract关键字表示,java中抽象函数必须在抽象类中,而且抽象 函数不能有函数体,抽象类不能被实例化,只能由其子类实现...
  • 2、抽象类中的抽象方法不能使用override virtual等具有具体实现的关键字。 3、抽象类中的抽象方法,子类继承后,必须override重载。 4、抽象类不能直接进行实例化。 5、抽象普通类之间继承满足多态的
  • UML逻辑视图-类图详解 提示: ...文章目录UML逻辑视图-类图详解类抽象类接口多重性继承关系泛化关系关联关系-**单向关联**关联关系-双向(标准)的关联关联关系-聚合关联关系-组合依赖关系实例-图书...
  • java提高篇(四)-----抽象接口

    万次阅读 多人点赞 2013-10-18 21:04:13
     抽象接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。  一、抽象类  我们都...
  • 抽象类(Abstract Class)抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。...
  • 接口与抽象类,区别以及使用场景

    万次阅读 多人点赞 2017-01-06 11:42:11
    顺便做个记录 接口和抽象类应该是Java语法中最常见的两个概念 关于两者,网上也是一搜一吨的...4,抽象类的成员可以具有具体实现 接口不行 5,抽象的子类可以选择性实现其基类的抽象方法 接口的子类必须实现 6,接
  • 抽象接口

    千次阅读 2016-06-07 18:00:39
    Java接口(interface)和Java抽象类(abstract class)代表的就是抽象类型,就是我们需要提出的抽象层的具体表现。OOP面向对象的编程,如果要提高程序的复用率,增加程序 的可维护性,可扩展性,就必须是面向接口的编程...
  • 一、接口、抽象类、继承、实现定义接口 接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找不到更好的词来表示,但是我们要明确一点就是,接口本身就不是类,从我们不能实例化一个接口就可以看出。如new...
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...
  • java抽象类和接口和继承之间关系

    千次阅读 2008-10-27 22:05:00
    有时候,我们可能想要构造一个很抽象的父类对象,它可能仅仅代表一个分类或抽象概念,它的实例没有任何意义,因此不希望它能被实例化。例如:有一个父类“ 水果(Fruit)”,它有几个子类“苹果(Apple)”、“橘子...
  • Java中抽象方法的重写

    千次阅读 2020-11-10 22:29:33
    抽象类:抽象的、模糊的、不具体的类 在Java的普通类中是不允许多继承的,原因是会出现调用 不明确的问题; 总结:父类中的功能是不能删除的,但其形式是不需要的(没有存在的意义),此时就可以将父类中功能的 具体...
  • 数据库实体联系模型与关系模型

    千次阅读 2020-03-02 19:11:33
    数据库设计是指根据用户的需求,在某一具体的数据库管理系统上,设计数据库的结构和建立数据库的过程。...因此,规划数据构成及数据间关系,并应用某一具体的数据库管理系统如MySQL构建数据库的过程就是...
  • Java抽象

    千次阅读 多人点赞 2018-06-04 15:49:24
    百度给出的解释是:从具体事物抽出、概括出它们共同的方面、本质属性与关系等,而将个别的、非本质的方面、属性与关系舍弃,这种思维过程,称为抽象。这句话概括了抽象的概念,而在Java中,你可以只给出方法的定义不...
  • Java 的抽象特性:抽象接口深度解析

    千次阅读 热门讨论 2016-10-27 11:56:48
    对于面向对象编程来说,抽象是它的四大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:...接口和抽象类为我们提供了一种将接口实现分离的更加结构化的方法。总的来说,抽象类是一种模板,而接口是一种契约。
  • linux kernel的函数与抽象

    千次阅读 2013-06-20 13:16:49
    硬件抽象层是位于操作系统内核硬件电路之间的接口层,其目的在于将硬件抽象化。它隐藏了特定平台的硬件接口细节,为操作系统提供虚拟硬件平台,使其具有硬件无关性,可在多种平台上进行移植。内核提供了简单
  • Java提高篇 —— 抽象接口

    千次阅读 2018-08-14 14:30:13
     抽象接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。   二、抽象类    ...
  • 对象的关系

    千次阅读 2018-09-03 11:34:58
    简单记录一下类对象的关系,问题不难,但觉得还是写出来,会帮助自己记忆更牢固,而且万一以后有需要,可以及时回顾。 参考文献: 类对象的区别 Java类和对象 详解(一) Java类和对象 详解(二) 声明对象、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 422,543
精华内容 169,017
关键字:

具体与抽象的关系