精华内容
下载资源
问答
  • 抽象类没抽象方法的例子

    千次阅读 2014-04-30 17:17:38
    都知道抽象类可以没有抽象方法,这时的抽象类和普通类的最大差别就是不能实例.一直没找到在什么环境下用到这种特殊的抽象类.最近看了jdk的I/O包后,发现里面有个很好的例子,就是FilterReader类.以下是FilterReader的...

     都知道抽象类可以没有抽象方法,这时的抽象类和普通类的最大差别就是不能实例化.一直没找到在什么环境下用到这种特殊的抽象类.最近看了jdk的I/O包后,发现里面有个很好的例子,就是FilterReader类.以下是FilterReader的代码:

    public   abstract   class  FilterReader  extends  Reader  {

        
    /**
         * The underlying character-input stream.
         
    */

        
    protected Reader in;

        
    /**
         * Create a new filtered reader.
         *
         * 
    @param in  a Reader object providing the underlying stream.
         * 
    @throws NullPointerException if <code>in</code> is <code>null</code>
         
    */

        
    protected FilterReader(Reader in) {
        
    super(in);
        
    this.in = in;
        }


        
    /**
         * Read a single character.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public int read() throws IOException {
        
    return in.read();
        }


        
    /**
         * Read characters into a portion of an array.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public int read(char cbuf[], int off, int len) throws IOException {
        
    return in.read(cbuf, off, len);
        }


        
    /**
         * Skip characters.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public long skip(long n) throws IOException {
        
    return in.skip(n);
        }


        
    /**
         * Tell whether this stream is ready to be read.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public boolean ready() throws IOException {
        
    return in.ready();
        }


        
    /**
         * Tell whether this stream supports the mark() operation.
         
    */

        
    public boolean markSupported() {
        
    return in.markSupported();
        }


        
    /**
         * Mark the present position in the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void mark(int readAheadLimit) throws IOException {
        in.mark(readAheadLimit);
        }


        
    /**
         * Reset the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void reset() throws IOException {
        in.reset();
        }


        
    /**
         * Close the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void close() throws IOException {
        in.close();
        }


    }

    可以看到FilterReader就是一个没有抽象方法的抽象类,里面的每个方法都是调用构造函数传入的Reader对象的方法.这种抽象类你不能实例化它,因为实例化它没意义,它还没实现任何Filter的功能.在extends具体子类时实现Filter功能,实例化相应的子类才有实际意义.

    我们可以写FilterReader的一个具体子类如下:

    /**
     * FilterReader是一个抽象类,不能实例化该类,FilterReader类的每个方法都是实现的,
     * 里面调用的都是FilterReader(Reader in)的传入参数in的方法.    
     
    */

    public   class  UppercaseConvertor  extends  FilterReader {
        
    // 构造方法由FilterReader的protected上升到public的
        public UppercaseConvertor(Reader in) {
            
    super(in);
        }

        
        @Override
        
    public int read() throws IOException{
            
    int c = super.read();
            
    return (-1==c?c:Character.toUpperCase((char)c));
        }

        
        @Override
        
    public int read(char[] buf,int offset, int count) throws IOException{
            
    int nread = super.read(buf, offset, count);
            
    int last = offset + nread;
            
    for(int i=0;i<last;i++)
                buf[i] 
    = Character.toUpperCase(buf[i]);
            
    return nread;
        }


        
    public static void main(String[] args) throws IOException {
            UppercaseConvertor uc 
    = new UppercaseConvertor(new FileReader("d:\log.txt"));
            BufferedReader br 
    = new BufferedReader(uc);
            String r;
            
    while(null!=(r=br.readLine())){
                System.out.println(r);
            }

        }

    }

     

    展开全文
  • 抽象类里没抽象方法的例子

    千次阅读 2007-08-30 22:15:00
    都知道抽象类可以没有抽象方法,这时的抽象类和普通类的最大差别就是不能实例.一直没找到在什么环境下用到这种特殊的抽象类.最近看了jdk的I/O包后,发现里面有个很好的例子,就是FilterReader类.以下是FilterReader的...

     都知道抽象类可以没有抽象方法,这时的抽象类和普通类的最大差别就是不能实例化.一直没找到在什么环境下用到这种特殊的抽象类.最近看了jdk的I/O包后,发现里面有个很好的例子,就是FilterReader类.以下是FilterReader的代码:

     

    public   abstract   class  FilterReader  extends  Reader  {

        
    /**
         * The underlying character-input stream.
         
    */

        
    protected Reader in;

        
    /**
         * Create a new filtered reader.
         *
         * 
    @param in  a Reader object providing the underlying stream.
         * 
    @throws NullPointerException if <code>in</code> is <code>null</code>
         
    */

        
    protected FilterReader(Reader in) {
        
    super(in);
        
    this.in = in;
        }


        
    /**
         * Read a single character.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public int read() throws IOException {
        
    return in.read();
        }


        
    /**
         * Read characters into a portion of an array.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public int read(char cbuf[], int off, int len) throws IOException {
        
    return in.read(cbuf, off, len);
        }


        
    /**
         * Skip characters.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public long skip(long n) throws IOException {
        
    return in.skip(n);
        }


        
    /**
         * Tell whether this stream is ready to be read.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public boolean ready() throws IOException {
        
    return in.ready();
        }


        
    /**
         * Tell whether this stream supports the mark() operation.
         
    */

        
    public boolean markSupported() {
        
    return in.markSupported();
        }


        
    /**
         * Mark the present position in the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void mark(int readAheadLimit) throws IOException {
        in.mark(readAheadLimit);
        }


        
    /**
         * Reset the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void reset() throws IOException {
        in.reset();
        }


        
    /**
         * Close the stream.
         *
         * 
    @exception  IOException  If an I/O error occurs
         
    */

        
    public void close() throws IOException {
        in.close();
        }


    }

    可以看到FilterReader就是一个没有抽象方法的抽象类,里面的每个方法都是转调用构造函数传入Reader对象的方法.这种抽象类你不能实例化它,因为实例化它没意义,它还没实现任何Filter的功能.在extends字的具体子类实现了Filter功能,实例化相应的子类才有实际意义.

    我们可以写FilterReader的一个具体子类如下:

     

    /**
     * FilterReader是一个抽象类,不能实例化该类,FilterReader类的每个方法都是实现的,
     * 里面调用的都是FilterReader(Reader in)的传入参数in的方法.    
     
    */

    public   class  UppercaseConvertor  extends  FilterReader {
        
    // 构造方法由FilterReader的protected上升到public的
        public UppercaseConvertor(Reader in) {
            
    super(in);
        }

        
        @Override
        
    public int read() throws IOException{
            
    int c = super.read();
            
    return (-1==c?c:Character.toUpperCase((char)c));
        }

        
        @Override
        
    public int read(char[] buf,int offset, int count) throws IOException{
            
    int nread = super.read(buf, offset, count);
            
    int last = offset + nread;
            
    for(int i=0;i<last;i++)
                buf[i] 
    = Character.toUpperCase(buf[i]);
            
    return nread;
        }


        
    public static void main(String[] args) throws IOException {
            UppercaseConvertor uc 
    = new UppercaseConvertor(new FileReader("d:/log.txt"));
            BufferedReader br 
    = new BufferedReader(uc);
            String r;
            
    while(null!=(r=br.readLine())){
                System.out.println(r);
            }

        }

    }

    这里的FilterReader其实起了一种强制子类类型化(FilterReader)的作用.

    展开全文
  • 5.1 抽象化

    千次阅读 2016-04-14 19:30:07
    5.1 抽象R是一个好东西的主要原因是它是一门语言.而语言的魅力便是抽象.在R语言中,函数便是实现抽象的方式.假如我们想要把1到3的整数重复两次.这是一个简单的命令: c(1:3, 1:3) 现在假如想要重复这些数字六次或者六...

    5.1 抽象化

    R是一个好东西的主要原因是它是一门语言.而语言的魅力便是抽象.在R语言中,函数便是实现抽象的方式.假如我们想要把1到3的整数重复两次.这是一个简单的命令:

    c(1:3, 1:3)
    

    现在假如想要重复这些数字六次或者六十次.用函数来抽象这个操作就变得有意义了.事实上,这种抽象已经有前人做了:

    rep(1:3, 6)  
    

    rep()可以完成我们上面的任务和其他一些相似的任务.

    我们在做一个新的任务.我们有两个向量;我们想生成一个新的向量,首先将第一个向量重复到第二个向量的长度,然后第二个向量重复到第一个向量的长度.一个向量被重复到的长度如果小于它本身的长度意味着只需要这个向量的前边的那一部分.使用rep()函数可以轻松地将其抽象到一个函数中:

    repeat.xy <- function(x, y)
    {
     c(rep(x, length=length(y)), rep(y, length=length(x)))
    }
    

    repeat.xy()现在就可以在R中被使用了.

    repeat.xy(1:4, 6:16)  
    

    这种很轻易地写出一个函数好像就意味着我们能够很自然地从仅仅使用R升级到用R编程.

    除了可以抽象操作,函数还凝结着智慧.π大约是 3.1415926535897932384626433832795028841971693993751058209749445
    923078便是智慧.

    函数:

    circle.area <- function(r) pi * r ^ 2 
    

    智慧与抽象兼而有之–它可以帮你算出任何你想知道的园的面积(约等于).

    这里并不是一个纯粹讨论R语言结构的地方,而是一个评论我们上边讲的两个函数细节的地方.repeat.xy()的主体被一对大括号包围着而circle.area()没有.函数的主体应该是一个简单地表达式.大括号将主体内的表达式转换成一个单独的(组合)表达式.当函数的主体只有一条命令的时候,大括号是可选的.大括号也被应用在循环,分支和判断的结构中.

    理想的情况是每个函数通过让人容易理解的输入输出完成一个被明确定义的任务.初学者通常都是用一个函数来完成所有的事情.一个普遍来讲总是更好的方法是:写很多的小巧的函数,然后有一个更大的函数调用这些小的函数来完成所有事情.一步步将任务拆分可以让我们清楚地知道什么是真正应该去做的.而且当程序出现bug时可以让我们的调试变得更简单.使用小函数普及程度更高.

    R语言抽象的一个瑰宝是函数入参的默认值.比如,sd()中的入参na.rm的默认值是FALSE.如果你的需求正好是FALSE,你在调用sd()的时候便不需要修改na.rm的值.如果你希望丢掉缺失值,你在调用sd()的时候加入参数na.rm=TRUE.假如你编写了自己的函数而仅仅只是改变函数默认入参,那么你可能就不会感激函数提供给你的抽象性了.

    函数最总返回一个结果给你,而函数的返回值几乎证明着自己的存在.函数中最后的一条语句被定义为返回值.然而很多函数并没有服从这样的机制,但是return()会强制返回你想返回的.

    函数的其他一些影响是它会有一个或者多个负作用.一个负作用便是除了会返回结果外,还会改变代码系统.R的哲学是将这些负作用集中在少数几个我们明确知道的并且希望对系统造成影响的函数中(比如print(),plot(),rm()).
    这里写图片描述
    R函数处理的事物是对象.R有丰富的对象类型.表 5.1展示了一些重要的对象类型.

    你也许会注意到每个原子类型都有一个可能存在的值–NA(Not Available),这被称作缺失值,一些初次接触R的使用者花费了大量的时间努力去避免NAs.对于0的首次出现,他们或许也会这样做.然而NA是一个对你非常有价值的好东西.当你的数据中存在缺失值的时候你通常是不会高兴的,但是生活有NA总比没有好.

    R的设计理想是nothing is important.我们再读一次”nothing” is important.向量的长度可以为0.这是另外一个愚蠢的设计但是被证明是难以置信地有用–这么说来并不是愚蠢的设计啦.我们并不经常去处理一个不存在的事物,所以一些情况下,这是个问题–我们将会在轮回8,轮回8.1.15看到示例.

    对象的大多数价值在于处理它们的属性.很多属性改变着R和使用者对它们的认知.通常大多数情况下,对象的一个属性都会有自己的名字.决定着对象的方向的属性是类别.表5.2列举了少许非常重要的由属性决定的对象.

    初学者的一个普遍问题是把数据框和矩阵混为一谈.它们看起来好像一样.但是它们确实是不一样的.在轮回8.2.37将会为你展示它们为什么不同.

    “vector”在R中有很多含义:
    1. 一个原子对象(和列表相反),这或许是最普遍的用法.
    2. 一个没有属性的对象(除了可能名称).这是被is.vector()和as.vector()影响的定义.
    3. 一个可以有任意长度的对象(包括列表).

    很明显第一个定义和第三个定义看起来是矛盾的,它们的到底属于哪一个只有通过代码的上下文才能够清楚.当我们讨论向量跟矩阵的区别时,第二个定义就派上用场了.

    单词”list”在R中有一个专业的含义–一个可以包含不同类型,包括自己本身的长度可伸缩的对象.有时这个单词也会被用到非专业的地方,比如在”search list”或者”argument list”.

    并不是所有的函数都被平等地被制造出来.它们可以被随意地分为三种类型.

    下边是一个无名函数:

    apply(x, 2, function(z) mean(z[z > 0])) 
    

    这个函数充当了apply()的第三个参数,它是如此短暂以至于我们都没必要给它命名.

    这些函数仅仅在一个特定的场合被使用,这些就是你的一次性函数.

    然而对于一些对你来说确实珍贵的函数.本来它们就是一次性的而你却重写它们让它们变得更加抽象.诚然,你可能非常希望一个文件或者R包能够引入你的珍贵有用的函数.

    从无名函数的例子中我们可以看到,一个函数也可以是另外一个函数的入参.在R中,函数和向量或者矩阵一样都是对象.你可以把函数想象成数据.

    一个全新级别的抽象是一个函数的返回值是另外一个函数. 经验分布函数就是一个例子:

    > mycumfun <- ecdf(rnorm(10))
    > mycumfun(0)
    [1] 0.4   
    

    只要你写了一个函数返回另一个函数的这种代码,你就可以直接去下一个轮回了.

    在第二轮回(12页)我们短暂地分析了do.call().一些人对这个函数甚是迷惑.这是没有必要且不幸的–实际上它是一个非常简单但又非常强大的函数.一般情况下我们都是通过函数的的函数名外和一个”入参列表”来调用这个函数,这样很简单:

    sample(x=10, size=5)  
    

    do.call()函数允许你以一个真正的列表来提供函数的入参:

    do.call("sample", list(x=10, size=5))
    

    有时在调用一个函数时能看到具体的执行情况是非常有用的.函数被调用的时候会建立一个环境,当这个被调用的函数再去调用其他函数时,系统也会为这些其他函数建立自己的环境.因此内存里会有一个环境栈随程序的运行而伸缩.

    让我们定义一些函数吧:

    ftop <- function(x)
    {
    # time 1
    x1 <- f1(x)
    # time 5
    ans.top <- f2(x1)
    # time 9
    ans.top
    }
    
    f1 <- function(x)
    {
    # time 2
    ans1 <- f1.1(x)
    # time 4
    ans1
    }
    
    f2 <- function(x)
    {
    # time 6
    ans2 <- f2.1(x)
    # time 8
    ans2
    }
    

    然后我们进行调用:

    # time 0
    ftop(myx)
    # time 10  
    

    图 5.1向我们展示了这次调用随着时间栈中的环境怎么变化的.注意在ftop(),f1(),f2()的环境中都有一个x.x在ftop()中被称作myx(或者可能是x的副本),在f1()也是这样.但是f2()中的x就有些不同了.

    当我们调试代码的时候,我们将会研究这个栈特定时刻的情况.比如,如果一个代码当一个bug出现在f2.1,我们就要查找在time 7附近的栈的情形.
    这里写图片描述

    R语言有丰富的对象类型.这是R优点的一部分.这些对象的一些是语言本身的元素–函数调用,表达式等等.这提供了一种非常强大的抽象形式–在语言上计算.虽然几乎所有的新人对语言的元素混淆看起来是十分的令人费解的,然而很多人对这种观点十分迟钝.

    展开全文
  • C# 典型的抽象例子

    千次阅读 2019-02-17 23:32:18
    //抽象:摘要,提炼、非具体化 //抽象类只能对方法、属性、索引器进行抽象抽象类和抽象类的成员前必须有关键字abstract修饰。 //抽象成员必须被子类覆写(重写),使用关键字override实现。  
    using System;
    namespace Test
    {
        public abstract class Person
        {
            public abstract void Show();
            public abstract string Name { get;set;}
            public abstract string this[int n] { get;set;}
           private  int a;
        }
        public class Employee : Person
        {
            private string pname;
            private string[] friends = new string[100];
            public override void Show()
            {
                Console.WriteLine("姓名:{0}", this.pname);
            }
            public override string Name
            {
                get { return this.pname; }
                set { this.pname = value; }
            }
            public override string this[int n]
            {
                get { return this.friends[n]; }
                set { this.friends[n] = value; }
            }
        }
        class Program
        {
            static void Main(string[] args)
            {
             //   Person p = new Employee();/*抽象类对象引用子类实例*/
                Employee p = new Employee();
                p.Name = "曹操";
                p.Show();
                Console.ReadLine();
                }
        }
    }
    
    //抽象:摘要,提炼、非具体化
    //抽象类只能对方法、属性、索引器进行抽象,抽象类和抽象类的成员前必须有关键字abstract修饰。
    //抽象成员必须被子类覆写(重写),使用关键字override实现。

     

    展开全文
  • 《剑指offer》刷题笔记(举例让抽象具体化):包含min函数的栈 转载请注明作者和出处:http://blog.csdn.net/u011475210 代码地址:https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台:...
  • java 抽象什么不能被实例

    千次阅读 2019-08-29 09:30:16
    转载:java 抽象什么不能被实例? 我把CSDN论坛里面的一个帖子内容list到下面,自己看着理解,东家一言,西家一语,杂合起来,基本上也就理解了java中的抽象什么不能被实例了。 因篇幅有限,只能罗列...
  • 《剑指offer》刷题笔记(举例让抽象具体化):栈的压入、弹出序列 转载请注明作者和出处:http://blog.csdn.net/u011475210 代码地址:https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台:...
  • Java的抽象类实例

    万次阅读 2018-03-19 14:35:37
    即如果一个类含有抽象方法,则称这个类为抽象类。 抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法,所以一般不能用抽象类创建对象。 // 抽象类 public abstract class ClassName { /...
  • JAVA抽象类与接口详解 例子很好

    万次阅读 2012-10-11 11:39:32
    在Java语言中, abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性...
  • 抽象类和接口的区别,例子经典

    千次阅读 2011-09-03 01:52:28
    abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。 abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似...
  • 例子说明 Spring提供了很好的架构和很方便的工具,在作为工具使用的同时,也应注意正确使用spring的架构,虽然不是强制的,但是这是spring的精髓。用spring,也要用spring的框架。例如在某次的code review中,看到...
  • 抽象工厂模式:我们现在要对mysql/oracle数据库中的User表进行操作,User表定义如下:public class User { private int uid; private String uname; public int getUid() { return uid; } public void set...
  • Java中什么要使用抽象

    千次阅读 2016-07-14 16:33:59
    抽象类 抽象类与接口紧密...2)抽象类当中可以存在非抽象的方法,可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3)抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量
  • Java 抽象

    千次阅读 多人点赞 2019-01-28 09:16:52
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。 抽象类除了不能实例对象之外,...
  • java提高篇(四)-----抽象类与接口

    万次阅读 多人点赞 2013-10-18 21:04:13
    接口和内部类我们提供了一种将接口与实现分离的更加结构的方法。  抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持...
  • 用 abstract 修饰的类定义,我们称之为抽象类,抽象类不能被实例。 用 abstract 修饰的方法,我们称之为抽象方法,抽象方法不能有方法体。 面向对象中,所有的对象都是某一个类的实例,但是并不是每个类都可以...
  • 今天的文章通过 Istio 开源项目展示如何 Kubernetes 管理的微服务提供可见性,弹性,安全性和控制。 服务是现代软件体系结构的核心。比起复杂庞大的整体,部署一系列模块的小型(微型)服务能够使开发人员灵活...
  • 抽象工厂

    万次阅读 多人点赞 2018-09-09 18:30:12
    定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类 创建型 :创建型 适用场景: 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节 强调一系列相关的产品对象...
  • Java 剖析抽象

    千次阅读 2018-07-25 19:57:54
    抽象类只是在普通类的基础上扩充了一些抽象方法... 由于抽象方法没有具体的方法实现,所以其抽象类是不能直接实例的,使用抽象类的唯一途径是使用它的实现子类。  抽象类使用原则: 所有抽象类必须有其实现...
  • 抽象工厂设计模式

    千次阅读 2019-09-12 15:29:45
    但是在现实生活中,一个工厂只创建单个产品这样的例子很少,因为现在的工厂都多元了,一个工厂创建一系列的产品,如果我们要设计这样的系统时,工厂方法模式显然在这里不适用,然后抽象工厂模式却可以很好地解决一...
  • 以生产鼠标例, 有一个抽象的鼠标工厂,工厂有两个实现,一个是戴尔鼠标工厂,一个是联想鼠标工厂,具体抽象工厂子类,负责决定生产那种鼠标,将类的实例延迟到了子类 抽象的鼠标工厂类 abstract class ...
  • 不依赖于具体抽象是毫无意义的

    千次阅读 2007-06-25 22:22:00
    OO的精髓在于抽象,抽象可以使调用具体实现的高层不关心具体实现的细节,这样做的好处是降低系统的偶合性,增加系统的灵活性.比如这种情况:图1 不成熟的Button和Lamp模型public class OnButton{ private Lamp itsLamp;...
  • Java:接口和抽象类,傻傻分不清楚?

    千次阅读 多人点赞 2019-04-26 07:28:15
    再来聊聊接口和抽象类。
  • 文章目录抽象方法和抽象抽象方法抽象抽象类的概念以及使用什么需要抽象类接口接口的概念接口的使用接口与抽象类的区别使用一个人的例子更直观的了解下接口:内部类内部类的概念内部类的作用内部类的分类成员...
  • 抽象类和接口的区别以及抽象类和接口的使用场景

    千次阅读 多人点赞 2019-05-30 18:15:44
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法:使用...
  • 面向对象——比抽象类更抽象

    千次阅读 热门讨论 2014-11-07 23:54:49
    架起机房收费系统的三层结构后,开始加抽象工厂,反射的配置文件,也用到了泛型来解耦。就发现重构的目的是:一步步的抽象,一步步的解耦。其中加了IDAL层,用来灵活的处理BLL层和DAL层之间直接的依赖关系。 重构中...
  • Java 的抽象特性:抽象类与接口深度解析

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

    万次阅读 多人点赞 2015-04-11 08:26:32
    本文属于23种设计模式系列。 继续前面简单工厂模式和工厂方法模式的例子,以汽车配件制造介绍抽象工厂模式。
  • 当程序员具备了抽象思维

    万次阅读 2021-03-22 14:32:46
    硕大而抽象,且非常美丽。 作者:张建飞 若想捉大鱼,就得潜入深渊。深渊里的鱼更有力,也更纯净。硕大而抽象,且非常美丽。——大卫·林奇 前言 抽象思维是我们工程师最重要的思维能力。因为软件技术 ...
  • 果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。  抽象类除了不能实例对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类 一样。由于抽象类不能实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,654
精华内容 91,861
关键字:

化抽象为具体例子