精华内容
下载资源
问答
  • 什么是面向对象 面向对象是一种软件开发方法。...OOP面向对象编程,面向对象编程一种编码范式或编码风格,以类或者对象作为组织代码的基本原则,并将封装、抽象、继承、多态作为软件设计与实现的基本...

    什么是面向对象

    面向对象是一种软件开发方法。对象对象包括三部分:面向对象分析(OOA)、面向对象设计(OOD)、面向对象编程(OOP). OOA、OOD、OOP三个连在一起正好是面向对象软件开发的三个阶段。

    什么是OOA、OOD、OOP

    OOP

    OOP是面向对象编程,面向对象编程是一种编码范式或编码风格,以类或者对象作为组织代码的基本原则,并将封装、抽象、继承、多态作为软件设计与实现的基本原则和基石。

    OOA与OOD

    OOA是面向对象分析,OOD是面向对象设计。

    分析与设计的最终的产物是类的设计,包括程序被拆解为那些类,每个类有那些属性方法,类与类之间如何交互等等。它们比其它分析和设计更加具体、更加落地、更加贴近编码,跟能够顺利地过度到面向对象编程环节。这也是面向对象分析和设计,与其它分析和设计最大的不同点。

    简单点来讲,面向对象分析就是搞清除要做什么,面向对象设计就是要搞清楚怎么做,面向对象编程就是将分析和设计的结果翻译成代码的过程。

    什么是面向对象编程语言(OOPL)

    OOPL是面向对象编程语言。到底什么是面向对象编程语言呢?

    面向对象编程的两个重要、基础的概念是类和对象。面向对象编程语言是支持类或对象的语法,并有现成的语法机制,能方便地实现面向对象编程四大特性(封装、抽象、继承、多态)编程语言。

    OOP与OOPL的关系

    面向对象编程一般使用面向对象编程语言来进行,但是,不用面向对象编程语言,我们照样可以进行面向对象编程。反过来讲,即使我们使用面向对象编程语言,写出来的代码也不一定是面向对象编程风格的,也有可能是面向过程编程成风格的。

     

    展开全文
  • 上面的语法中的"对象",实例对象,可以this,Class.clss或者其他共享对象.所以代码块锁定的等价于对象锁定.我们甚至还可以假设一下.把上面代码的"对象"做成变量: public void func1(Object lo...

    锁定代码块等价于锁定对象

    首选看一下锁定代码块的语法?

        synchronized (对象)
        {
            // 代码块
        }
    

    上面的语法中的"对象",指的是实例对象,可以是this,Class.clss或者其他共享对象.所以代码块锁定的等价于对象锁定.我们甚至还可以假设一下.把上面代码的"对象"做成变量:

        public void func1(Object lock) { // 这个方法没有锁定,锁定的是里面的代码块
    
            synchronized (lock) {
    
                System.out.println("方法开始");
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("方法结束");
            }
        }
    

    那如果我们锁住的不是lock对象,而是func1里面的代码,那无论传入的lock对象是什么,这段代码都不能并发执行了.这显然是不可能的.我们看看输出也再次证明了这个结论:

    方法开始
    方法开始
    方法结束
    方法结束
    

    锁定非静态方法等价于锁定对象

    先抛出原因:

    对象的非静态 synchronized 方法被调用的时候,会先将对象锁定,类似自动调用synchronized(this).

    验证:

    假如我们一个进程先调用对象的非静态 synchronized 方法,然后另一个进程调用 synchronized(this).
    如果第一个进程没有为对象加锁,第二个进程就能调用成功,然后两者是并行的,结论不成立
    反之,第二个进程无法获得对象锁,两个进程就必须串行,结论成立

    1. 先定义共享对象
    class TestSyn {
    
        public synchronized void func1() { // 这个方法没有锁定,锁定的是里面的代码块
    
    
            System.out.println("我是方法10");
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("我是方法11");
        }
    
        public void func2() {
    
            synchronized (this)
            {
                System.out.println("我是方法20");
    
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
                System.out.println("我是方法21");
            }
        }
    }
    

    2.然后定义两个线程分别调用共享对象的不同方法

    public class Singleton {
        public static void main(String[] args) throws InterruptedException {
            TestSyn testSyn = new TestSyn();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testSyn.func1();
                }
            }).start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testSyn.func2();
                }
            }).start();
        }
    }
    

    3.查看输出

    我是方法10
    我是方法11
    我是方法20
    我是方法21
    

    最后得出结论

    程序串行执行,所以第二个人线程调用方法fun2的时候没有得到this的锁.说明this已经被锁定.

    引申: 同一个对象的两个同步非静态方法可以并发执行吗?

    答案:不行,因为两者都要获得this锁,属于竞争关系

    证明:

    1. 先定义同步对象
    class TestSyn {
    
        public synchronized void func1() { // 这个方法没有锁定,锁定的是里面的代码块
    
    
            System.out.println("我是方法10");
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("我是方法11");
        }
    
        public synchronized void func2() {
    
            System.out.println("我是方法20");
    
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            System.out.println("我是方法21");
        }
    }
    
    1. 然后定义两个线程分别调用这两个方法
    public class Singleton {
        public static void main(String[] args) throws InterruptedException {
            TestSyn testSyn = new TestSyn();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testSyn.func1();
                }
            }).start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testSyn.func2();
                }
            }).start();
        }
    }
    
    1. 查看输出是串行执行.
    我是方法10
    我是方法11
    我是方法20
    我是方法21
    
    展开全文
  • 构造方法用于给对象的数据进行初始化,,究竟如何进行初始化的,对象的数据是什么?感觉书里这样讲很抽象,能否写代码举个例子
  •  对象对某一类事物进行抽象,抽象出这一类事物共同的特征以及行为(也就是属性和方法),那些拥有这一共同属性和方法的事物就是对象 二、分析  面向对象和基于对象的区别:引用一个例子,比如建造...

     

    一、问题

      javascript是面向对象的,还是面向过程的?基于对象是什么意思?

       对象: 指的是对某一类事物进行抽象,抽象出这一类事物共同的特征以及行为(也就是属性和方法),那些拥有这一共同属性和方法的事物就是对象

     

    二、分析

      面向对象和基于对象的区别:引用一个例子,比如建造房子

    • 面向对象:是先设计好图纸,然后按照这个图纸的设计去建造房子
    • 基于对象:是先建造一个房子,然后根据房子的样子,再去建造房子

      也就是说: 

    • 面向对象:是先有一个抽象的对象描述(类), 然后根据这个描述去构建新的对象(实例化对象)
    • 基于对象: 是先有一个具体的对象,然后根据这个具体的对象,再去创建新的对象(实例化对象)

     

    面向对象的三大基本特征:封装,继承,多态。

    基于对象:也使用了对象,但是无法利用现有的对象的模板产生新的对象类型,继而产生新的对象,基于对象是没有继承的特点。

    多态体现的就是继承,没有了继承就无从谈论多态。多态一般体现在抽象类上。JavaScript语言就是基于对象的,它封装了一些好的对象,调用对象的方法,设置对象的属性,但是却无法让开发者派生出新的类。只能使用现有对象的方法和属性。

     

    三、javascript中对象的体现和使用

      我们通过多种方式来实现点击按钮,更改某个div的属性样式

    <!DOCTYPE html>
    <html lang="en">
        <head>
            <meta charset="UTF-8">
            <title>Title</title>
            <style>
                div: {
                    width: 300px;
                    height: 300px;
                    background-color: red;
                }
            </style>
        </head>
        <body>
            <input type="button" value="点击变化" id="btn" />
            <div id="div"></div>
            
            <script>
                //点击按钮修改div的样式
                //面向过程和面向对象实现方式
            </script>
        </body>
    </html>

      面向过程的实现方式:知道需求,理清思路过程,然后按照这个过程从头到尾写

    //点击按钮,改变div的样式--面向过程实现
    document.getElementById("btn").οnclick=function() {
        document.getElementById("div").style.backgroundColor="yellow"
    }

      面向对象思想的实现方式(初级): 

      按钮是一个对象;div是个对象;颜色是一个属性

    //点击按钮,改变div的样式--面向对象(初级)
    //ChangeStyle是构造函数
    function ChangeStyle(btnId,divId,color){
        this.btnObj=document.getElementById("btnId");
        this.divObj=document.getElementById("divId");
        this.color = color;
    }
    //数据共享的方式来改变样式
    ChangeStyle.prototype.init = function() {
        console.log(this)    // 此this就是实例对象--即当前对象     
        var that = this;    // 此处必须转存this,因为在function中this表示该点击事件的对象   
        this.btnObj.οnclick=function() {
            that.divObj.style.backgroundColor=that.color;
        }
    }
    //实例化对象
    var test = new ChangeStyle("btn", "div", "yellow");
    test.init();//即打印当前的test实例对象

      面向对象实现(高级):

    //点击按钮,改变div的样式--面向对象(高级)
    //ChangeStyle是构造函数
    function ChangeStyle(btnObj,divObj,json){
        this.btnObj=btnObj;
        this.divObj=divObj;
        this.json = json;
    }
    ChangeStyle.prototype.init = function() {
        //点击按钮改变div样式  
        var that = this;    // 此处必须转存this,因为在function中this表示该点击事件的对象   
        this.btnObj.οnclick=function() {
            for(var key in that.json){
                that.divObj.style[key]=that.json[key];
            }
        }
    }
    //实例化对象
    var btnObj=document.getElementById("btnId");
    var divObj=document.getElementById("divId");
    var json = {"width": "500px","height": "500px","backgroundColor": "green","opacity": "0.1",}
    var test = new ChangeStyle(btnObj, divObj, json);
    test.init();//调用方法

      上面的代码更加具有共用性:只要使用最后的两行代码,可以通过任一对象的点击事件,操作任意对象的样式

      这就是面向对象的魅力所在!

     

     

    四、结束

     

     

      

    转载于:https://www.cnblogs.com/nangezi/p/10170281.html

    展开全文
  • 在下面代码中,this哪些 ``` package cn.itcast.player; import java.awt.*; import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event....
  • 依赖管理,是指什么地方以什么形式引入外部代码。 1 1.1.1. 理解模块化和依赖管理: 1 1.2. 依赖管理,有三个层面。 单一职责原则,协议对象引用,依赖逻辑关系 2 2. 五大数据解耦 视图、数据模型、网络...

    Atitit  依赖管理之道

    1. 概念 依赖管理,是指在什么地方以什么形式引入外部代码。 1

    1.1.1. 理解模块化和依赖管理: 1

    1.2. 依赖管理,有三个层面。 单一职责原则,协议对象引用,依赖逻辑关系 2

    2. 五大数据解耦 视图、数据模型、网络请求、本地存储、页面跳转五块代码 2

    3. Maven 2

    4. Maven最佳实践:管理依赖 1 3

    4.1. 最简单的依赖 2 4

    4.2. 依赖归类 2 4

    4.3. 依赖范围(scope) 3 4

    4.4. 分类器(classifer 5 4

    4.5. 依赖管理(dependencyManagement 6 4

    5. 与其他工具的区别 4

    5.1. RubygemNodenpmPythonpipiOSCocoaPods都类似,只是配置文件语法和坐标命名规则有些差异。 4

    5.2. App store 4

    6. 依赖管理工具,设计 4

    7. 组合层次 funjobj,pkg,namespae,modu 5

    8. 参考资料 5

     

    1. 概念 依赖管理,是指在什么地方以什么形式引入外部代码。

     

    依赖管理为什么重要呢? 因为,依赖在哪里,处理代码就会那里,而bug也就会出现在那里。 于是,反过来,为了让bug集中,就需要让处理代码集中,也就需要管理好代码的依赖关系。

    1.1.1. 理解模块化和依赖管理:

    · 应用一般都会依赖外部库(jQuery和AngularJs),这些库应该使用包管理器处理和更新,而不是手动下载。

    · 应用本身也可以分解成为多个相互交互的小部分,学习封装代码的技能,把代码视作自成一体的组件,学习如何设计优秀的接口,如何安排接口;学习如何隐藏数据,只开放用户需要的部分。

    · 如何解析依赖,避免手动维护一组有序的script标签。

     

    1.1. 依赖管理,有三个层面。 单一职责原则,协议对象引用,依赖逻辑关系

    1、相同的代码,只出现在一个地方,也叫单一职责原则。

    2、通过引用协议对象,让依赖关系中的组件更容易更换。

    3、从逻辑上安排依赖关系,让依赖关系更容易被人理解。

    单一职责原则,是最基本的原则。它是代码模块化,设计模式的根本。

    协议对象引用,使得功能变更时,只需要在一个统一的地方做最少的修改。

    依赖逻辑关系,则主要是为了更方便人脑去理解代码之间的关系。

     

    2. 五大数据解耦 视图、数据模型、网络请求、本地存储、页面跳转五块代码

     

    3. Maven

    Atitit maven使用总结attilax总结.docx

    atitit 项目管理  package 模块管理 maven attilax总结.docx

     

    Maven诞生于2004年(来源维基),查询了下,应该是各语言的依赖管理工具中早的。Ruby的gem也是2004年出现的,但gem离完备的依赖管理工具还差些,直到Ruby的bundler出现。Python的pip出现的更晚。

    Maven的习惯是通过 groupID(一般是组织的域名倒写,遵循Java package的命名习惯)+ artifactId(库本身的名称) + version(版本)来定义坐标,通过xml来做配置文件,提供了中心仓库(repo.maven.org)以及本地工具(mvn)。

    依赖定义:  <dependency>  <groupId>com.google.guava</groupId>  <artifactId>guava</artifactId>  <version>18.0</version>  </dependency>  repo定义:  <repository>  <id>repo.default</id>  <name>Internal Release Repository</name>  <url>http://repo.xxxxxx.com/nexus/content/repositories/releases</url>  <releases>  <enabled>true</enabled>  <updatePolicy>interval:60</updatePolicy>  <checksumPolicy>warn</checksumPolicy>  </releases>  <snapshots>  <enabled>false</enabled>  <updatePolicy>always</updatePolicy>  <checksumPolicy>warn</checksumPolicy>  </snapshots>  </repository> 

    同时,为了避免依赖冲突的问题,Maven的依赖配置提供了exclude配置机制,用于阻断部分库的传递依赖。

     

     

    4. Maven最佳实践:管理依赖 1

    Maven最佳实践:管理依赖 1

    4.1. 最简单的依赖 2

    4.2. 依赖归类 2

    4.3. 依赖范围(scope) 3

    4.4. 分类器(classifer 5

    4.5. 依赖管理(dependencyManagement 6

    5. 与其他工具的区别

    5.1. RubygemNodenpmPythonpipiOSCocoaPods都类似,只是配置文件语法和坐标命名规则有些差异。

    5.2. App store

    6. 依赖管理工具,设计

    1.要有一种依赖库的命名规则,或者叫坐标(Coordinates)的定义规则,可以通过坐标准确找到依赖的库。

    2.要有对应的配置文件规则,来描述和定义依赖。

    3.要有中心仓库保存这些依赖库,以及依赖库的元数据(metadata),供使用方拉取。

    4.还需要一个本地工具去解析这个配置文件,实现依赖的拉取。

    以上其实就是各依赖管理工具的核心要素。

     

    7. 组合层次 funjobj,pkg,namespae,modu

    function用于组合代码块逻辑,有了object用于组合一组方法,有了packagenamespace用于组合一组相关对象,但其实还需要有更高一个层次的组合定义 —– module,或者叫子项目

     

    8. 参考资料

    漫谈依赖管理工具:从Maven,GradleGo_TechWeb.mhtml

    漫谈依赖管理工具:从Maven,GradleGo_TechWeb.mhtml

    Maven最佳实践:管理依赖 - 飞龙在天001 - 博客园.mhtml

    展开全文
  • 什么是面向对象

    2019-10-01 01:21:41
    面向对象:面向对象是指一种程序设计范型,同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性 面向过程的...
  • 01什么是面向对象

    2021-05-07 20:50:47
    java的核心思想就是OOP(面向对象编程)(OO是指面向对象) (Object-Oriented Programming ) 面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据 从认识论角度考虑是先有对象后有类。对象,...
  • 面向对象是什么

    2017-09-21 15:10:23
    而面向对象指将主动思维理解为被动思维。不用在意过程,只需要结果正确就行。意在写出一个通用的代码,屏蔽差异。 在前面我的博客中,介绍了新《三国》第86集的某个剧情:司马懿在孟达的城池外抓获一个正要给...
  • 什么String不可变对象

    千次阅读 2017-11-07 20:49:35
    不可变对象是指在创建后后其外部可见状态无法更改的对象。Java 类库中的 String 、 Integer 和 BigDecimal 类就是不变对象的示例 ― 它们表示在对象的生命期内无法更改的单个值。看下面代码:String s = "ABC"; s....
  • 构造函数的实例的原型就是构造函数的原型对象 ...什么是原型,什么是原型对象什么是构造函数,下面我们通过代码解释 function foo(name,age){ this.name = name this.age = age console.log(this.name)
  • IOC (Inversion of Control)即控制反转(把对象的控制权从程序代码本身转移外部的容器中),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理。为什么有IOC? 为了解决对象...
  •  编程即写程序or代码,具体是指程序猿用特定的语法+数据结构+算法编写代码,目的是用来告诉计算机如何执行任务。  如果把编程的过程比喻为练习武功,那么编程范式指的就是武林中的各种流派,而在编程的世界里最...
  • 类似“不可持续的内存分配率”和“你需要维持低的内存分配率”这样的短语看...这是全部的内容——没那么神秘,仅仅是指 Java 代码在一定时期内内存分配的大小。  不过只知道这一点没有太大的意义。如果你能忍受,我将
  • 理解什么是的面向对象设计

    千次阅读 2017-03-31 22:46:20
    现在最流行的设计模式就是面向对象,那么什么是面向对象呢?   首先我们来看下官方的定义。在维基百科上说: >  面向对象程序设计(英语:Object-oriented programming,缩写:OOP)种具有...
  • 什么是⾯向对象编程,特点 什么是⾯向过程编程? 捕捉⽼⿏ 买⽼⿏笼 放诱饵 等⽼⿏进⼊笼⼦ 把笼⼦关起来 什么是⾯向对象编程 捕捉老鼠 我买只猫,猫有抓⽼⿏的⽅法,对象本身具有的⽅法 ...对象
  • thisJavascript语言的一个关键字。  它代表函数运行时,自动生成的一个内部对象,只能在函数内部使用。...但是有一个总的原则,那就是this,调用函数的那个对象。  下面分四种情况,详细
  • 封装:封装是指对象信息状态通过访问权限修饰符隐藏在对象内部,不允许外部程序直接访问,如果外部程序要访问对象内部,可以调用内部提供的get或set方法。 继承:子类继承了父类所有的成员方法和属性,并且可以...
  • 面向过程很好理解,程序员接到需求,会把它拆成一个一个的命令,然后串起来交给计算机去执行。举个例子,产品经理说要把大象装进冰箱里。程序员列了几个步骤: 上面每一个步骤,程序员都会用一个「函数」来...
  • 一、这个对象指是什么 (个人理解,) 这个对象指的不是C#中的实例,这个对象是个抽象的,在我的理解中,面向对象这个对象是我们需要实现的东西,简单说就比如我现在需要编写一段游戏代码,就拿目前最火的LOL来...
  • 尺度不变性是指什么不变 在最近的几篇文章中,包括“ Getters / Setters。 邪恶。 期。” , “对象应该是不可变的”和“依赖注入容器是代码污染者” ,我普遍将所有可变对象标记为“ setter”(以set开头的对象...
  • ok,,find()取到span之后,另外执行的,用原来的jquery对象,如果find()抓到span后,加上.each(function()的,把span作为this. 完整代码如下: <!DOCTYPEhtml> <html> <h...
  • 解释: 作用域Scope代码中的变量(variable),函数(function)和对象(object)在运行时(runtime)的可访问性(accessibility)。换句话讲,作用域Scope决定了在你的代码中的特定区域内,变量和其他资源是否可见。   ...
  • this的就是对象本身

    2012-10-19 10:33:00
    package abcdefg; public class Test { ... public static void main(String[] ... //类中的this是什么:该类产生对象后,对象调用带有this代码,那么this的就是该对象 Person p = new Person(); //...
  • 所谓的同步的并不是所有的线程...如果要使用同步代码块必须设置一个要锁定的对象,所以一般可以锁定当前对象。 并且synchronized 同步的代码块,在同一时刻只允许一个线程进入代码块处理 这种方式在方法中拦...
  • 关键代码是指一个小代码段,在代码能够执行前,它必须独占对某些共享资源的访问权。这是让若干行代码能够“以原子操作方式”来使用资源的一种方法。 用法 VOID InitializeCriticalSection(PCRITICAL_SECTION ...
  • 请说出面向对象的设计原则,并分别简述它们的含义。 参考答案 单一职责原则 一个类只负责一个功能领域中的相应职责。或者说,一个类,应该只有一个引起它变化的原因。 开闭原则 一个软件实体应当对扩展开放,对修改...
  • 闭包是指在创建时封装周围状态的函数。即使闭包所在的环境不存在了,闭包中封装的状态依然存在。 匿名函数就是没有名称的函数。匿名函数可以赋值给变量,还能像其他任何PHP对象那样传递。不过匿名函数仍是函数,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,632
精华内容 1,052
关键字:

对象代码是指什么