精华内容
下载资源
问答
  • Mybatis与hibernate-自己的理解 Hibernate做了写优化,比如一二三级缓存,把数据存放在缓存里面,这里是通过OID去区分是否为同一个对象,存放在内存。 今天同事问了我下:Hibernate中get/load区别以及为什么能...

    Mybatis与hibernate-自己的理解
    Hibernate做了写优化,比如一二三级缓存,把数据存放在缓存里面,这里是通过OID去区分是否为同一个对象,存放在内存。

    今天同事问了我下:Hibernate中get/load区别以及为什么不能final修饰?
    因为load得到的是代理类型对象,final是不能被继承的
    get直接得到了一个持久化类型对象,它就是立即查询操作
    load它得到的是持久化类开的代理类型对象(子类对象)。它采用了一种延迟策略来查询数据。
    4.get方法在查询时,如果不存在返回null
    load方法在查询时,如果 不存在,会产生异常

    自己的话来说hibernate的一二级缓存的理解,一级缓存就是session,比如get,load,query之类的操作就会把数据存在session里面,后面调用close就会关闭,而二级缓存就是sessionfactory

    展开全文
  • 深入理解Java中的不可变对象

    千次阅读 2020-03-20 10:49:23
    二哥,你能给我说说为什么 String 是 immutable 类(可变对象)吗?我想研究它,想知道为什么它就可变了,这种强烈愿望就像想研究浩瀚星空一样。但无奈自身功力有限,始终觉得雾里看花终隔一层。二哥你...

    二哥,你能给我说说为什么 String 是 immutable 类(不可变对象)吗?我想研究它,想知道为什么它就不可变了,这种强烈的愿望就像想研究浩瀚的星空一样。但无奈自身功力有限,始终觉得雾里看花终隔一层。二哥你的文章总是充满趣味性,我想一定能够说明白,我也一定能够看明白,能在接下来写一写吗?

    收到读者小 R 的私信后,我就总感觉自己有一种义不容辞的责任,非要把 immutable 类说明白,否则我就怎么地——你说了算!

    01、什么是不可变类

    一个类的对象在通过构造方法创建后如果状态不会再被改变,那么它就是一个不可变(immutable)类。它的所有成员变量的赋值仅在构造方法中完成,不会提供任何 setter 方法供外部类去修改。

    还记得《神雕侠侣》中小龙女的古墓吗?随着那一声巨响,仅有的通道就被无情地关闭了。别较真那个密道,我这么说只是为了打开你的想象力,让你对不可变类有一个更直观的印象。

    自从有了多线程,生产力就被无限地放大了,所有的程序员都爱它,因为强大的硬件能力被充分地利用了。但与此同时,所有的程序员都对它心生忌惮,因为一不小心,多线程就会把对象的状态变得混乱不堪。

    为了保护状态的原子性、可见性、有序性,我们程序员可以说是竭尽所能。其中,synchronized(同步)关键字是最简单最入门的一种解决方案。

    假如说类是不可变的,那么对象的状态就也是不可变的。这样的话,每次修改对象的状态,就会产生一个新的对象供不同的线程使用,我们程序员就不必再担心并发问题了。

    02、常见的不可变类

    提到不可变类,几乎所有的程序员第一个想到的,就是 String 类。那为什么 String 类要被设计成不可变的呢?

    1)常量池的需要

    字符串常量池是 Java 堆内存中一个特殊的存储区域,当创建一个 String 对象时,假如此字符串在常量池中不存在,那么就创建一个;假如已经存,就不会再创建了,而是直接引用已经存在的对象。这样做能够减少 JVM 的内存开销,提高效率。

    2)hashCode 的需要

    因为字符串是不可变的,所以在它创建的时候,其 hashCode 就被缓存了,因此非常适合作为哈希值(比如说作为 HashMap 的键),多次调用只返回同一个值,来提高效率。

    3)线程安全

    就像之前说的那样,如果对象的状态是可变的,那么在多线程环境下,就很容易造成不可预期的结果。而 String 是不可变的,就可以在多个线程之间共享,不需要同步处理。

    因此,当我们调用 String 类的任何方法(比如说 trim()substring()toLowerCase())时,总会返回一个新的对象,而不影响之前的值。

    String cmower = "沉默王二,一枚有趣的程序员";
    cmower.substring(0,4);
    System.out.println(cmower);// 沉默王二,一枚有趣的程序员
    

    虽然调用 substring() 方法对 cmower 进行了截取,但 cmower 的值没有改变。

    除了 String 类,包装器类 Integer、Long 等也是不可变类。

    03、自定义不可变类

    看懂一个不可变类也许容易,但要创建一个自定义的不可变类恐怕就有点难了。但知难而进是我们作为一名优秀的程序员不可或缺的品质,正因为不容易,我们才能真正地掌握它。

    接下来,就请和我一起,来自定义一个不可变类吧。一个不可变诶,必须要满足以下 4 个条件:

    1)确保类是 final 的,不允许被其他类继承。

    2)确保所有的成员变量(字段)是 final 的,这样的话,它们就只能在构造方法中初始化值,并且不会在随后被修改。

    3)不要提供任何 setter 方法。

    4)如果要修改类的状态,必须返回一个新的对象。

    按照以上条件,我们来自定义一个简单的不可变类 Writer。

    public final class Writer {
        private final String name;
        private final int age;
    
        public Writer(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    
        public String getName() {
            return name;
        }
    }
    

    Writer 类是 final 的,name 和 age 也是 final 的,没有 setter 方法。

    OK,据说这个作者分享了很多博客,广受读者的喜爱,因此某某出版社找他写了一本书(Book)。Book 类是这样定义的:

    public class Book {
        private String name;
        private int price;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
    

    2 个字段,分别是 name 和 price,以及 getter 和 setter,重写后的 toString() 方法。然后,在 Writer 类中追加一个可变对象字段 book。

    public final class Writer {
        private final String name;
        private final int age;
        private final Book book;
    
        public Writer(String name, int age, Book book) {
            this.name = name;
            this.age = age;
            this.book = book;
        }
    
        public int getAge() {
            return age;
        }
    
        public String getName() {
            return name;
        }
    
        public Book getBook() {
            return book;
        }
    }
    

    并在构造方法中追加了 Book 参数,以及 Book 的 getter 方法。

    完成以上工作后,我们来新建一个测试类,看看 Writer 类的状态是否真的不可变。

    public class WriterDemo {
        public static void main(String[] args) {
            Book book = new Book();
            book.setName("Web全栈开发进阶之路");
            book.setPrice(79);
    
            Writer writer = new Writer("沉默王二",18, book);
            System.out.println("定价:" + writer.getBook());
            writer.getBook().setPrice(59);
            System.out.println("促销价:" + writer.getBook());
        }
    }
    

    程序输出的结果如下所示:

    定价:Book{name='Web全栈开发进阶之路', price=79}
    促销价:Book{name='Web全栈开发进阶之路', price=59}
    

    糟糕,Writer 类的不可变性被破坏了,价格发生了变化。为了解决这个问题,我们需要为不可变类的定义规则追加一条内容:

    如果一个不可变类中包含了可变类的对象,那么就需要确保返回的是可变对象的副本。也就是说,Writer 类中的 getBook() 方法应该修改为:

    public Book getBook() {
        Book clone = new Book();
        clone.setPrice(this.book.getPrice());
        clone.setName(this.book.getName());
        return clone;
    }
    

    这样的话,构造方法初始化后的 Book 对象就不会再被修改了。此时,运行 WriterDemo,就会发现价格不再发生变化了。

    定价:Book{name='Web全栈开发进阶之路', price=79}
    促销价:Book{name='Web全栈开发进阶之路', price=79}
    

    04、总结

    不可变类有很多优点,就像之前提到的 String 类那样,尤其是在多线程环境下,它非常的安全。尽管每次修改都会创建一个新的对象,增加了内存的消耗,但这个缺点相比它带来的优点,显然是微不足道的——无非就是捡了西瓜,丢了芝麻。

    最后,一定会有不少读者想要问我怎么学习 Java 的,那我干脆就把我看过的优质书籍贡献出来:

    1)入门版:《Head First Java》、《Java 核心技术卷》

    2)进阶版:《Java编程思想》、《Effective Java》、《Java网络编程》、《代码整洁之道》

    3)大牛版:《Java并发编程》、《深入理解Java虚拟机》、《Java性能权威指南》、《重构》、《算法》

    就先介绍这么多,希望对那些不知道看什么书的同学有所帮助。

    对了,我介绍的这些书籍,已经顺便帮你整理好了,你可以在我的原创微信公众号『沉默王二』回复『书籍』获取哦

    有收获?希望老铁们来个三连击,给更多的同学看到这篇文章

    1、老铁们,关注我的原创微信公众号「沉默王二」,专注于有趣有益的程序人生,保证你看完有所收获,不信你打我。

    2、给二哥点个赞呗,可以让更多的人看到这篇文章,顺便激励下我,嘻嘻。

    作者info
    作者:沉默王二,CSDN 2019年度博客之星,《Web全栈开发进阶之路》作者
    原创公众号:『沉默王二』,已写了 250 多篇文章,专注于有趣的 Java 技术和有益的程序人生,期待你的关注。
    转载说明:务必注明来源(注明:来源于公众号:沉默王二, 作者:沉默王二)

    展开全文
  • 对于面向对象的理解

    2018-06-17 21:15:57
    按照惯例,先做一个简单介绍,现在开始学习 Thinging in Java 4 ,一边看,一边记录,我都不想给自己设定时间安排了,毕竟...其实并不理解。没关系,我们可以假装理解了。那我就来结合书中观点说一下面向对象的...

    按照惯例,先做一个简单的介绍,现在开始学习 Thinging in Java 4 ,一边看,一边记录,我都不想给自己设定时间安排了,毕竟很少实现过。所以就这样吧!不定期的更新,我都会放到专栏中的。

    所以我可能会有很多表述和书中是一样的,外加一些自己的理解吧。

    我们常说的一句话是“一切皆对象”这话也就说说吧,理解吗?其实并不理解。没关系,我们可以假装理解了。那我就来结合书中的观点说一下面向对象的概念吧!若是你没有一点面向对象的概念,那你不用看了,去玩吧!

    首先问一下自己编程是什么呢 ?数据结构 + 算法 = 编程 ,算法说的简单一点就是事情的解决步骤。编程语言(C,C++,Java,Python…)只是一种工具,我们学习Java无非就是为了编程,所以我们对于Java中的数据结构的理解就显得尤其重要了。数据结构又是什么呢?就是在研究数据以及数据之间的关系和操作。在Java中数据就体现为对象。所以我们要学习的也就是对象以及对象之间的关系和对象相关的操作

    前面说到Java中一切皆是对象,那我们怎么去操作这些对象呢?这些对象又放在哪里的呢?在Java中我们通过引用的方式来操作对象,打个比方来说,我们的引用就相当于遥控器,而电视机就是对象,我们对电视机(对象)的操作(加减声音,换台)都是通过操作遥控器(引用)实现的。举个具体的例子:

    String s = ‘learn Java’;

    这里的s就是一个引用,引用的数据也就是learn Java,这里涉及一个Java中的知识点,字符串这个对象可以用引号直接为其赋值。我们需要用到什么对象都由我们自己创建,那么一般的对象我们是怎么创建的呢?使用关键字 new 即可创建一个对象。
    例如:String s = new String("learn java"); 这就是创建一个名为learn java字符串的对象并且用s引用它。那我辛辛苦苦创建的对象都放在哪里了呢?不得不多,这里就涉及计算机硬件方面的知识了,不懂就去补吧。我们创建的对象的引用,还有一些基本数据类型的变量会存放在栈中,而创建的对象会放在堆内存中(目前是只可意会不可言传的阶段)有必要说一下,有些对象是可以脱离程序存在的,在程序没有运行的时候也可以存在,比方说流对象和持久化对象。在流对象中,对象转化成字节流,通常被发送给另一台机器。在”持久化对象中“对象被存放于磁盘上因此,即使程序结束,它也可以保存自己的状态。

    总会存在特例,Java中的数据类型可以分为基本数据类型和引用数据类型,对于基本数据类型一种有8种,分别是 byte short int long float double char(2个字节 16 bit)boolean ,为什么会出现这些基本数据类型,原来是因为它们使用太频繁,我们说过,对象是存放在堆中的,而对于这种小型的频繁使用的数据放在堆中加大了对象创建和使用的时间,所以就单独列出来,用于提高Java的效率。

    对于基本数据类型在JDK5中提供了自动包装功能,就是说本来是基本数据类型的自动转化为包装类。int i = 2; <==> Integer j = new Integer(i); 每一种基本数据类型所占用的存储空间都是固定的。这也是Java可移植性性的保证!

    另外Java中提供了两个高精度的类BigInteger 和 BigDecimal ,它们就是用于支持任意精度的整数和任意精度的定点数。

    所有的对象都是由我们自己创建,那我们创建的对象都是什么类型的呢?除了一些JDK内置的类型,我们可以使用关键字class 来自定义对象的类型。也就是我们常说的类。在类中我们可以定义对象的属性和方法,每创建一个对象都拥有自己的副本。属性也叫成员变量,在类中的成员变量都有自己的初始化值,但是局部变量若是不赋初值的话就会报错,类的另一个组成就是方法了,也叫函数,可以理解为对象的功能,我们定义方法的目的就在于和对象进行对话或“交互”。我们调用方法的行为通常被称为发送消息给对象。
    例如:a.f(); 可以理解为消息是 f() ,a 是对象。

    面向对象的程序设计通常简单地归纳为“向对象发送消息”。

    展开全文
  • 在 ES5 中,有的人可能对原型,原型对象,及其原型链不是很清楚,经过我的总结 今天就来说说对这些的深入认识,...构造函数有它自己的属性及其方法,其中包括自己定义的属性和方法外,还有两个特殊属性(prototype、...

    在 ES5 中,有的人可能对原型,原型对象,及其原型链不是很清楚,经过我的总结 今天就来说说对这些的深入认识,如果有不妥之处 还请多多指出

    首先,再说原型与原型对象之前,当然有必要清楚构造函数,实例,原型与原型对象之间的关系。其实他们的关系也很简单。

    构造函数,实例,原型与原型对象之间的关系:

    构造函数有它自己的属性及其方法,其中包括自己定义的属性和方法外,还有两个特殊属性(prototype、constructor);而每个他的实例都会拥有它的所有属性和方法(包括prototype、constructor)constructor则是指向每个实例的构造函数,而prototype 原型 则是一个地址指向原型对象,这个原型对象创建了实例后,只会取得constructor属性,其他的都是从Object继承而来;在Firefox 、 chrome在对象上都支持一个属性"proto";这个原型对象的属性和方法是所有该类实例共享的任何该类实例够可以访问该原型对象的属性和方法(后面会介绍访问原型对象属性和方法的三个方式)
      注释
      图解
      如上图,p1 ,p2的的实例都有Person的属性和方法,并且prototype都指向原型对象,p1\p2共享prototype原型对象的属性和方法,各自的constructor都指向Peson,这便是构造函数、实例、原型(对象)三者的关系。

    现在我来说一说访问原型对象属性和方法的三个方式:

    1.通过Person.prototype 属性

    console.log(Person.prototype.name);//输出----->person

    2.通过 属性屏蔽 delete (屏蔽构造函数属性或者方法)

    p1.sayName();   //输出----->构造函数对象

    delete p1.name;

    console.log(p1.name); //输出----->原型属性

    delete p1.sayName;

    p1.sayName(); //输出 —>原型对象方法

    3.通过Object.getPrototypeOf(p1)

    console.log(Object.getPrototypeOf(p1).name);//输出----->原型属性

    上面我们需要注意就是当实例调用属性或者方法时,有一个”属性搜索机制“,所谓”属性搜索机制“就是当实例访问属性或者方法时首先会现在自身的实例中搜索,看是否有对应属性,有,则返回;如果没有那么它会通过prototype 到原型对象中寻找对应的属性和方法;

    原型链:

    其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。我们知道,每个构造函数都有一个原型对象,每个原型对象都有一个指向构造函数的指针,而实例又包涵一个指向原型对象的内部指针。

    如果我们让原型对象(A.prototype) = 另一个类型的实例(new B()),那么,该原型对象(A.prototype)就有一个指向另一个原型对象(B.prototype)的指针,相应的,另一个原型对象(B.prototype)也包含指向另一个构造函数(B)的指针。 ------------->如果另一个的原型(B.prototype)又是另一个类型(C)的实例,上诉关系依然成立,就构成了实例与原型的链条,这就是原型链。

    实现原型链的基本方法:

    function Person () {
        this.name = "person";
    }
     
    Person.prototype.getPersonName = function () {
        return this.name;
    };
     
    function Student () {
        this.studentname = "student";
    }
     
    // 继承了Person
    Student.prototype = new Person();
    Student.prototype.getStudentName = function () {
        return this.name;
    };
     
    var stu = new Student();
    console.log(stu.getPersonName());           //person
    
    

    如上就是通过将 Student()的prototype = new Person() 即子类的原型对象等于父类的实例,从而Student.prototype有了Person的所有属性和方法,实现了继承。通过实现原型链,再结合 “属性搜索机制“,则

    stu.getPersonName()
    

    会经过三个阶段:1.搜索实例 2.搜索Student.prototype 3.搜索Person.prototype;如果再没就会到Object 对象的prototype对象上寻找。因为所有的function和对象等引用类型都继承Object;这也就说明了为什么不是通过Object直接实例的对象(自定义类型)会有valueof(),toString()等方法。

    图解
    需要注意的是,子类有时需要重写父类的方法或者新增心得方法,这些都要 替换了原型之后(也就是实现继承之后)。-----------stu 指向Student的原型,Student的原型又指向了Person的原型。从而实现了stu 继承Student Student继承Person

    function Person () {
        this.name = "person";
    }
     
    Person.prototype.getPersonName = function () {
        return this.name;
    };
     
    function Student () {
        this.studentname = "student";
    }
     
    // 继承了Person
    Student.prototype = new Person();
       // 新增方法
    Student.prototype.getStudentName = function () {
        return this.name;
    };
       // 重写父类方法
    Student.prototype.getPersonName = function () {
        return false;
    };
     
    var stu = new Student();
    console.log(stu.getPersonName());           //false
    

    还有一点需要注意的是:在通过原型链实现继承时,不能用对象字面量创建原型方法,因为这样会重写原型链。 刚刚把Person的实例赋值给原型,紧接着使用字面量导致出错。------->因为现在的原型包含的是一个Object的实例,不是Person的实例,原型链被切断。

    function Person () {
        this.name = "person";
    }
     
    Person.prototype.getPersonName = function () {
        return this.name;
    };
     
    function Student () {
        this.studentname = "student";
    }
     
    // 继承了Person
    Student.prototype = new Person();
    // 使用字面量添加新方法,会导致Student.prototype = new Person(); 无效
    Student.prototype = {
        getStudentName :function  () {
            return this.name;
        },
        otherMethod :function  () {
            return false;
        }
     
    };
     
    var stu = new Student();
    console.log(stu.getPersonName());           //stu.getPersonName is not a function
    

    会报错 stu.getPersonName is not a function 因为此时Student和Person已经没有关系了。

    所以理想的继承方式是”寄生组合式继承“,所谓寄生组合式继承通过借用构造函数来继承属性(父类构造函数里的属性+方法),通过原型链的形式继承方法(父类原型里的方法)。

    // 寄生组合式继承(理想的继承方式)
    function inherPrototype (Subobject,Superobject) {
        var prototype = Superobject.prototype;
        prototype.constructor = Subobject;
        Subobject.prototype = prototype;
    }
     
     
    function Person (name) {
        this.name = name,
        this.hand = ["right-hand","left-hand"],
        this.say = function () {
            alert("hi");
        }
     
    }
    Person.prototype.sayName = function () {
        alert(this.name);
    }
     
    function Student (name,age) {
        Person.call(this,name);
        this.age = age;
    }
    // 实现继承
    inherPrototype(Student,Person);
    Student.prototype.sayAge = function () {
        alert(this.age);
    }
     
    var stu1 = new Student("jack",20);
     
     
    // 继承了属性(构造函数里的属性+方法)
    console.log(stu1.hand[0]);                  //----------->输出right-hand
    stu1.say();                         //输出 hi
    //  继承了原型里的方法
    stu1.sayName();                     //输出 jack       
    

    要实现继承无非就是拥有父类对象的方法和属性,即拥有一个父类的”模板副本“,inherPrototype()方法做了如下三件事:1.创建父类的原型(prototype)副本,赋值给prototype 2.为创建的prototype副本添加constructor属性 ,弥补因为原型赋值而导致失去默认的constructor属性3.把这个副本赋值给子类原型。这样便实现了继承。

    实战是解决问题的最佳途径,也是遇到问题的唯一途径,大家多多亲自制作才能更快更好的成长,另外多去借鉴别人的经验也是进步的捷径,希望能够给大家提供一点思路。

    展开全文
  • 在 ES5 中,有的人可能对原型,原型对象,及其原型链不是很清楚,今天我就说说对这些的深入认识下。(如果有什么懂得欢迎留言探讨,当然如果有...构造函数有它自己的属性及其方法,其中包括自己定义的属性和方法外...
  • 理解js中this对象

    千次阅读 2016-04-04 09:45:22
    关于this对象,一直不是很好理解,我也经常被困惑,因为this对象经常会因为代码书写方式不同而导致似乎自己认知中this对象被改变了,但实际上this还是那个this。一句话:“this 对象是函数在运行时基于函数...
  • 最近用到了Vue+elementUI,原先觉得是坑多,后来发现是自己理解不到位。elementUI为很多控件都提供了事件(方法) 现在我们就说说这些方法 例一:如下面这段代码中,select控件里面我绑定了一个change事件,该...
  • 其实博主之前面试也有被问到这个问题,当时我用自己的语言组织回答的,我觉得当时回答的不够严谨。现在我查阅了相关资料做了以下的总结。 《深入理解Java虚拟机》第二版 周志明著 Page386页有相关定义。周志明也是...
  • 关于这个问题很多人面试时候都遇见过,我看了网上很多论坛对于这个问题都是统一。有人说创建了一个对象,有人说创建了五个对象,也有人说创建了两个对象。 先说说创建一个吧。当初面试时候我跟面试...
  • 大家好,我是杨数Tos,这是《从零基础到大神》系列课程的第...我所讲的只是基于自己的理解,简单说说什么是类与对象。一、什么是对象?前面的文章讲过面向过程编程,面向对象编程,那什么是对象呢?记得我之前学编程...
  • 实例通过设置自己的<code>__proto__指向承构造函数的<code>prototype来实现这种继承)。 小结 虽然对熟悉的人来说还有点绕,但JS正是通过<code>__proto__和<code>prototype的合作实现了原型链,...
  • 前言这篇博客主要来说说类与对象在JVM中是如何存储,由于JVM是个非常庞大课题,所以我会把他分成很多章节来细细阐述,具体数量还没有决定,当然这重要,重点在于是否可以在文章中学到东西,是否对JVM可以有...
  •  首先,来说说什么是野指针,所谓野指针就是一个指向未申请访问受限内存区域或者已经删除了的对象的指针。 什么意思呢?就是本来一个指针指向一个对象、一块内存,但是由于程序(函数)运行结束对象(栈内存)被...
  • 说说 Javascript Date

    2020-12-09 15:13:55
    <div><p>基础 <code>Date()</code> 就说了~ :) 如何获得某个月天数? 知道大家遇到过这个问题吗?我想如果你们写过日期组件一定有这个问题,我当时解决方案是这样: <p><strong...
  • virtual dom的理解

    2018-04-19 21:12:07
    本文主要是自己对...先的说说virtual dom 是什么,virtual dom就是原生dom在内存中的js对象映射,但不是完全复制,它比真实dom节点在属性上简化了,也就是说是更加轻量级,相当于是数据和原生dom...
  • JS原型理解

    2016-06-28 18:16:32
    说实话,一开始我对prototype和property是分,我说是单词分清,知道他们意思,在强制自己记忆了一遍之后,我是这么记忆,type(类型),跟“原型”差不多,所以prototype就是原型了,property就是...
  • 记录下自己的学习过程,谈谈自己的理解,欢迎指正和交流。 最近在看设计模式,先说说享元模式吧,在我看来享元模式本质就是将大量的相似的对象的公共的不会变化的部分抽象出来,作为静态变量,作为全局唯一的对象,...
  • 设计模式六大原则之一:赖倒置原则:高层模块应该依赖低层模块,二者都应该依赖其抽象。 往往在指导项目设计中,经常在高层模块...希望有经验的除了回答问题外,可以借此话题,说说自己的理解,也枉我花出去的C币。
  • iOS委托的理解

    2013-04-13 23:49:38
    今天晚上才终于弄明白了协议,委托。 实际上协议和委托是分。有协议就必须有委托。自己写好了协议(相当于接口),委托谁去实现呢。所以就必须有一个类去实现他。 那么这个类就成为了 委托对象...我说说
  • 这篇博客主要来说说类与对象在JVM中是如何存储,由于JVM是个非常庞大课题,所以我会把他分成很多章节来细细阐述,具体数量还没有决定,当然这重要,重点在于是否可以在文章中学到东西,是否对JVM可以有一些...
  • 1.先说说感触 Java最初的兴起,很大一部分是因为它是面向对象的语言。面向对象最大的特点便是“万事万物皆对象”,而... 那么可以看出,程序员每天最繁重的体力劳动便是用文字表达自己的想法。这是什么行业,就...
  • 这两个概念是同时存在可能抛开一个去谈论另外一个,或者说这两个概念结合在一起才会发挥作用,甚至原型存在是因为有原型链存在,在原型链上原型只能称之为对象。 原型链 先来说说原型链是个什么东东,...
  • Java你可能知道事系列1

    千次阅读 2016-03-06 00:39:15
    概述本类文章会段更新分析学习到经典面试题目,在此记录下来便于自己理解。如果有不对地方还请各位观众拍砖。 今天主要分享一下常用字符串几个题目,相信学习java小伙伴们对String类是再熟悉不过了,...
  • 说说你对面向对象编程的理解”、“你是怎么理解面向对象编程?”、“关于面向对象,谈一谈你看法” 等等。对于面向对象编程,好像自己知道是这么回事,却知道怎么表达出来!如果只说面向对象的概念又感觉没...
  • 最近看了不少书籍和视频等相关资料,决定自己边学习边写一下个人对设计模式的理解,如果有不对请大家多多指正。 今天先说说我个人觉得最简单设计模式 -- [空对象模式] 空对象模式可以减少客户端对对象判断...
  • 练习题|面向对象编程

    2018-06-13 15:42:00
    1、面向对象三大特性,各有什么用处,说说的理解。 继承、封装、多态 继承解决代码重用问题节省代码;多态,增加了程序灵活性、增加了程序可扩展性。就是考虑对象的类型可直接去使用它、一个统一接口用户...
  • 说说个人理解, javasocket是通过套接字进行通信,用输入/输出流实现传输功能——这里套接字仅仅是传输了一个字符串(“getAllPros”),而是整个流传输都是套接字,也就是write那部分内容;所以你可以用...
  • 面向对象三大特性,各有什么用处,说说的理解 # 封装:封装在于明确区分内外,使得类实现者可以修改封装内东西而影响外部调用者代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 156
精华内容 62
关键字:

对象不理解自己的说说