精华内容
下载资源
问答
  • 1、回顾 面向对象 – 注重的是结果,强调的是具备功能的...函数:对功能的封装面向对象是基于面向过程的。 思想特点: 设计对象,使用对象,维护对象间的关系。 类: 属性 -- 成员变量 行为 -- 成员方...

    1、回顾
    面向对象 – 注重的是结果,强调的是具备功能的对象。
    面向过程 – 强调的是函数,注重的实现的过程。
    函数:对功能的封装。
    面向对象是基于面向过程的。

        思想特点:
                
                设计对象,使用对象,维护对象间的关系。
                
        类:
                属性 -- 成员变量
                行为 -- 成员方法
        
        类中的成员:
                成员变量 -- 字段(Field)、属性、域
                成员方法 -- 函数(Method)
                构造方法 -- 构造器(Constructor)
                        为对象的数据进行初始化
                        
                        格式:
                                名称和类名完全相同
                                没有返回值,没有void
        
        封装:将具体的实现细节和属性隐藏,提供公共的访问方式。
        
                private String name;
                
                public void setName(String name) {
                        this.name = name; // 当前对象的引用
                }
                
                public String getName() {
                        return name; // 先局部 -- 成员
                }
                
        匿名对象:
                作为参数传递,或者对象的方法仅调用一次。
    

    2、构造方法
    注意:
    如果没有显式声明,系统会默认提供一个无参构造。
    如果显式声明,系统将不再提供默认的无参构造。这时如果还想使用无参的,就必须手动给出。
    建议大家都手动声明无参的。

        构造方法中传递参数,可以为成员变量赋值。
    

    3、静态关键字static
    修饰成员方法和成员变量,特点:
    被类的所有对象共享。
    随着类的加载而加载,优先于对象存在的。
    调用:类名直接调用 – 类名.

        注意事项:
                静态方法中没有this关键字。
                
                静态方法只能访问静态的成员方法或者成员变量。
                
        关于静态成员变量和非静态的成员变量的名词解释:
                实例变量(对象变量):
                        非静态的成员变量。
                类变量:
                        静态的成员变量。
    

    4、制作API
    把说明书的文字写在文档注释。
    制作命令:
    javadoc -d 目录 -author -version 类名.java

        Math类:
                public static double random() -- [0.0, 1.0)随机数 -- 左闭右开(包左不包右)
    
    展开全文
  • 关于面向对象

    2019-08-10 12:49:00
    面向对象的三大特征: 封装 ; 继承 ; 多肽 封装 : 讲一个事物的属性和功能集中定义在一个对象  事物的属性 , 会成为对象的属性  事物的功能 , 会成为对象的方法 创建自定义对象的三种方法  1、使用对象...

    面向对象oop:是一种编程思想,在程序中用对象来描述现实中一个具体的事物

    对象:封装了一个事物的属性和功能的程序结构

    面向对象的三大特征:  封装 ; 继承 ; 多肽

    封装讲一个事物的属性和功能集中定义在一个对象

      事物的属性 , 会成为对象的属性

      事物的功能 , 会成为对象的方法

    创建自定义对象的三种方法

      1、使用对象的直接量

        var   对象名  =  {

          属性名 : 属性值,

          …… : ……,

          方法名 : function(){

          },

          …… : ……,

        }

      其中有一个关键字this,用来引用正在调用函数对象的关键词

      例如对象自己的方法,要访问自己的属性,就必须用this.属性名!!!!

     

      2、使用new方法创建(创建的时候暂时不知道对象的内容)

        var   对象名  =  new  Object()    创建一个空对象

        向空对象中添加属性和方法,添加的方式与第一种创建方式一至

        new方法四个步骤

          1.创建新的空对象

          2.用new创建对象时,会自动设置子对象的_proto_来继承构造函数的prototype属性

          3.用新对象去调用构造函数

          4.将新对象的地址保存在变量

     

      3、构造函数    也称constructor构造器

        专门用来描述一类对象统一结构的函数   即共有的属性和方法

        当反复创建多个相同结构的对象时,定义统一的构造函数,再反复构造函数的使用

        构造函数的定义

          3.1 类型名首字母大写

          function   类型名 (属性参数列表){

            this.属性名 = 属性参数值;

            ……;

            this.方法名  =  function (){

            ……this.属性名……

            }

          }

          3.2 用new调用构造函数,传入具体对象的属性值(创建并装饰新对象)

          var  obj  = new  类型名(属性值列表)

          创建一个指定类型的对象;用new调用指定类型

     

    继承   

        父对象的成员,子对象不可重复创建,可直接使用  

        这样不仅可以节省内存,还可以减少代码量让代码重复使用

        用处:只要一类子对象,都需要相同的属性和功能时,就将相同的属相和功能仅在父对象里定义一次

        js中的继承都是继承的原型对象

        原型对象: 专门集中存储一类子对象相同属性和功能的父对象,同一类子对象所共有的属相和方法

        而每一次创建一个构造函数,都会自动赠送一个原型对象

        修改原型对象时,不会去修改原型对象的属性值,而是在子对象中添加一个新的属性

        自有属性  :    直接保存在对象本地的属性

        共有属性  :    保存在原型对象中,被所有子对象共享的

               使用的方法都是 :    创建的类型名 :  属性/方法

        function  CheckProperty(Obj.pname){

          if(){

          }else{

          }

        }

     

        原型对象的验证:

          1.console.log(Object.prototype.toString.call(obl));

          2.Array.is(Obj)

            console.log(

              Array.isArray(obj)

             )

     

        删除属性    

            可使用关键字delete删除对象的属性,但此操作存在危险性,使用时须三思

        原型链

            原型本身也是个对象,因此原型对象也有原型,对象就有_proto_,有多继父元素逐渐继承

        原型链保存着 : 所有对象的方法和属性

        作用域链保存着 :  所有的变量

        作用域链的作用 : 控制变量的使用顺序,优先使用活动对象AO的局部变量,局部中没有找到才去延作用域链向父级查找

        原型链的作用 : 控制对象访问成员的使用顺序,优先使用自己的,自己没有才向父级查找

     

        原型链的顶端 :  Object ,prototype;

        作用域的顶端  :  window

        

      简述:

          所有不需要对象,访问的变量都保存在作用域链中

          所有需要对象,访问的变量都保存在 原型链中

     

    多肽

        定义: 同一个事物,在不同的情况下表现出不同的状态

        重写 override :

            如果子对象觉得父对象的成员不好用,便自己定义一个重名的成员来使用

        两个对象之间的继承关系

            child __proto __ = father,

        继承   

            Object.setPrototypeOf(child,father)

        批量设置继承关系

            构造函数 . Prototype  =  father,

    转载于:https://www.cnblogs.com/jiapei/p/11331218.html

    展开全文
  • 关于面向对象的概括

    2020-12-06 23:13:31
    关于面向对象的概括 面向对象包括很多方面,抽象类,接口,封装,构造器,继承,多态,,等等 抽象类概述: 抽象类用来描述一种类型应该具备的基本特征与功能, 具体如何去完成这些行为由子类通过方法重写来完成。 ...

    关于面向对象的概括

    面向对象包括很多方面,抽象类,接口,封装,构造器,继承,多态,,等等

    抽象类概述:

    抽象类用来描述一种类型应该具备的基本特征与功能, 具体如何去完成这些行为由子类通过方法重写来完成。

    如:犬科均会吼叫,但属于犬科的狼与狗其吼叫内容不同。所以犬科规定了有吼叫功能,但并不明确吼叫的细节。吼叫的细节应该由狼与狗这样的犬科子类重写吼叫的方法具体实现。

    • 即抽象方法指只有功能声明,没有功能主体实现的方法。
    • 具有抽象方法的类一定为抽象类。
    • 那么犬科就可以定义为抽象类,吼叫方法为抽象方法,没有方法体。

    抽象类特点:

    (1)抽象类和抽象方法必须用abstract关键字修饰

    • abstract class 类名()
    • public abstract void 方法名();

    (2)抽象类不一定有抽象方法,有抽象方法的一定是抽象类或者接口

    (3)抽象类不能实例化

    按照多态的方式,由具体的子类实例化,其实这也是多态的一种,抽象类多态

    (4)抽象类子类

    抽象类和接口的区别:

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

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

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

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

    5、abstract 修饰范围

    类和方法。不能修饰常量、变量。被修饰的类不能被继承,被修饰的方法不能重写。

    接口

    从继承链的中间插入一个类,让它的子类具备某些功能而不影响它们的父类。例如 A -> B -> C -> D -> E,A 是祖先类,如果需要为C、D、E类添加某些通用的功能,最简单的方法是让C类再继承另外一个类。但是问题来了,Java 是一种单继承的语言,不能再让C继承另外一个父类了,只到移动到继承链的最顶端,让A再继承一个父类。这样一来,对C、D、E类的修改,影响到了整个继承链,不具备可插入性的设计。

    接口是可插入性的保证。在一个继承链中的任何一个类都可以实现一个接口,这个接口会影响到此类的所有子类,但不会影响到此类的任何父类。此类将不得不实现这个接口所规定的方法,而子类可以从此类自动继承这些方法,这时候,这些子类具有了可插入性。

    我们关心的不是哪一个具体的类,而是这个类是否实现了我们需要的接口。

    接口提供了关联以及方法调用上的可插入性,软件系统的规模越大,生命周期越长,接口使得软件系统的灵活性和可扩展性,可插入性方面得到保证。

    接口在面向对象的 Java 程序设计中占有举足轻重的地位。事实上在设计阶段最重要的任务之一就是设计出各部分的接口,然后通过接口的组合,形成程序的基本框架结构。

    所以简单总结其用途为:实现类的多继承,以解决Java只能单继承,不支持多继承的问题。

    接口实战:(前面的 pubilc abstract 可以省掉)

    package myproject03.com.atguishanggu.domain;
    
    public interface  Equipment {
    
        public abstract String getDescription();
    }
    

    构造器

    构造器的作用
    1.创建对象
    2.初始化对象信息
    说明:
    1.如果没有显式定义类的构造器,系统默认提供一个空参的构造器
    2.定义构造器的格式:权限修饰符 类名 (形参列表){}
    3.一个类中定义多个构造器,彼此构成重载
    4.一旦我们显示的定义了构造器之后,系统就不再提供默认的构造器
    5.一个类中至少有一个构造器

    构造器实战:

    package oop.demo10;
    
    public class TriAngle {
      private   int base;
      private int height;
    
      public TriAngle(){  //无参构造器
    
      }
      public TriAngle(int a,int b){   //有参构造器
          base=a;
          height=b;
      }
    
        public void setBase(int a){
          base=a;
        }
    
        public int getBase() {
            return base;
        }
    
        public void setHeight(int b) {
            height = b;
        }
    
        public int getHeight() {
            return height;
        }
    
    }
    

    继承

    继承是值子类继承父类的所有特性与方法的办法。通常代表词是extend

    多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只需要继承那个类即可。

    多个类可以称为子类,单独这个类称为父类或者超类,基类等。

    子类可以直接访问父类中的非私有的属性和行为。

    通过extends关键字让类与类之间产生继承关系。

    例如: class B extedns A { }

    继承相关应用:

    package myproject03.com.atguishanggu.domain;
    
    import jdk.net.SocketFlow;
    import myproject03.com.atguishanggu.service.Status;
    
    public class Programmer extends Employees {
    
        private int memberId;//开发团队id
        private Status status;
        private double  salary;
    
    }
    
    展开全文
  • 关于面向对象的总结

    2015-08-30 16:31:04
    在使用java面向对象语言开发程序的时候,对java语言本身的语法的了解非常重要,但是面向对象的思维更重要!面向对象这个概念天生就有封装,继承,多态三大特性。为什么要使用面向对象来设计程序,来设计项目,那要从...

    在使用java面向对象语言开发程序的时候,对java语言本身的语法的了解非常重要,但是面向对象的思维更重要!

    面向对象进行设计的好处

    面向对象这个概念天生就有封装,继承,多态三大特性。为什么要使用面向对象来设计程序,来设计项目,那要从这个三个特性带来的软件工程的优势来推演和论证。

    1. 封装
      一个功能复杂的软件,定会涉及很多的对象,每个对象要保持自身的本分的功能,功能不多不少,对得起这个对象的名字,对得起这个对象的当初的设计初衷。在软件中,这个对象不是孤立存在的,定要和其他对象进行协作一起完成一个功能模块。那么封装就把这个对象应该完成的功能封装起来,那么其他对象使用它的时候,就不用关心细节,这就是对象之间的低耦合,对象的高内聚,这样的好处就是对象的里面的实现逻辑修改,对调用方是透明的,自然可维护性就提高了。
      总结:对象—对象之间的低耦合,对象的高内聚—-降低维护成本
    2. 继承
      在一个功能复杂的软件中,定会设计到许多的对象,有些对象之间具有极高的相似性,而且他们的功能相同的部分也是进行聚合到更高的层次,这就是需要进行设计一个基类,来管理他们功能相同的部分,这是向上考虑,可以减少代码,而且代码的框架就会更加清晰,一定程度上便于维护,但是更重要的向下,可以继承这个类,实现各种各样的更加独具特性的功能,这就是继承,每个子类拥有相同的功能,但是也同时拥有和其他类不一样的功能,比如,策略模式,大概就是这样子的。
      总结:对象—-子对象,抽象类—–扩展性——-降低扩展的成本。
    3. 多态
      多态的用途之一就是可以在运行期绑定特定的对象,让这个对象它的任务或者功能。这样就让程序更加灵活。
      总结:多态—-编码灵活。

    如何进行面向对象的设计

    1. 需求的理解
      对象,可实可虚,一般情况下,没有一个程序对象是能够完全描述一个现实中的对象的,不过,即便这样,我们是可以扩展的,当我们需要某个属性的时候。
      所以,程序中的对象,是一种对现实对象的抽象,这种抽象是现实中对象属性和行为的一部分,是不完全的,但是不会和现实中的对象是相对的,不会是相反的,如果相反,那么你对对象的抽象是有问题的。
      因此,我们要理解需求,然后从需求中,把现实中的对象抽象成我们程序中的对象,这样就完成了对象的抽象。
    2. 抽象的理解
      前面说了,对象可实可虚,这就暗示了我们可以把一切都当做对象来理解,只要一个对象满足我们赋予给他的属性和行为,那么这就是一个对象,因此,不要被现实的对象才能在程序中抽象为一个对象的思维的限制。
      所以,面向对象——一切皆对象。
    展开全文
  • 一、封装:把实现一个功能的代码放在一个函数中封装起来,以后再想实现这个功能的时候,我们不需要重新的编写代码了,只需要执行对应的函数即可,我们把这种机制就称之为"函数的封装" -->低耦合高内聚:减少页面中...
  • 一切事物皆为对象,对象是一个自包含的实体,用一组可识别的特性和行为的标识英文叫“Object-Oriented programming” 面向对象的三大特性:继承,多态,封装什么是类? 类就是具有相同的属性和功能的对象的抽象的...
  • 关于面向对象三大特性的相关预习: 前言 java是一门面向对象的程序技术,我们想要学好java,首先应该清楚什么是面向对象将其与面向过程区分,并掌握面向对象的三大特性。 以下是我在预习结束后对面向对象与面向...
  • java关于面向对象的三大特性 面向对象的三大特征: 1,封装性 我们在设计程序的时候,主要最多的时间花在类的设计上,将相应的功能都体现在类的方法中,体现了封装性,封装也称为隐藏。在 Java中,设计了4种不同的...
  • 关于面向对象和面向过程理解 面向过程思想 把问题分成多个步骤,一步一步去实现,而具体每一步都需要自己实现(调用函数),这些步骤相互协调完成任务。面向过程强调了每个功能的步骤过程。 面向对象思想...
  • 面向对象编程思想需要我们掌握关于继承、封装、多态 1、封装:把实现一个功能的代码放在一个函数中封装起来,以后再想实现这个功能的时候,我们不需要重新编写代码了,只需要执行对应函数即可,我们把这种...
  • 关于面向对象思想

    2017-08-08 15:08:35
    面向对象是一种思想,是基于面向过程而言,就是说面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体细节;这种思想是将数据作为第一位,而方法或者说是算法作为其次,这是对数据一种...
  • 一.类 java的类就是用代码的形式来表示现实中的事物 例如:手机 ...1.方法是对功能的封装,类是对方法和属性的封装 2.封装的好处: 1.1提高了代码的复用性 1.2隐藏内部细节,对提供公共的访问方式
  • 面向对象特点 注重对象与职责,不同对象,不同职责; 应对复杂项目开发,提供固定模版; 基于面向过程; 封装:根据功能将属性和方法封装到一个抽象类中; 继承:实现代码复用,相同代码不需多次编写; 多态:...
  • 同时列表的功能有我们自由决定,如何俩狗实现高度的自由,这就是这篇文章要解释 的,关于面向对象的特性封装,通过封装可以达到自已的控制类的特性,你就是真正的主宰,看如下代码演示:封装的...
  • 本篇文章只是非常简单的一个案例,会把代码使用面向对象的思想封装 案例需求 案例初始代码 package main import "fmt" func main() { // 声明一个变量,保存用户输入的值 key := "" // 声明一个变量是否退出...
  • 但是(这里本人要苦大仇深、痛心疾首地说),“而Ajax的出现使得复杂脚本成为必需的组成部分,这就对 JavaScript 程序设计提出了新的要求,很多Ajax应用开始利用JavaScript面向对象的性质进行开发,使逻辑更加清晰。...
  • 从面向机器,到面向过程、结构化代码,再到面向对象,在实现功能的基础上,人们希望提高代码拓展性、可维护性,把一些复杂底层操作封装起来,提供接口或自动实现;用更抽象思维来处理需求 simula:面向对象...
  • 面向对象编程概念和原理 1、面向对象编程是什么 它是用抽象方式创建基于现实...3、面向对象编程优势(继承、多态、封装) 继承:获取父类全部(数据和功能),实现是复制。多态:根据实现方法对象,相...
  • 摘要:这篇Java开发技术栏目下“Java面向对象之成员隐藏与属性...分享给大家供大家参考,具体如下:关于这个功能的优点我现在体会还不深,只是从书本中找到了面向对象编程一个原则――尽量让数据私有。如果需...
  • 面向对象的特点: 1.封装:对于相同功能的代码,放在一个函数中,以后再用到此功能,只需要调用即可,无需再重写;避免大量冗余代码; 专业话说:低耦合,高内聚; 2.继承:子类继承父类原有的属性和...
  • 面向对象就是把功能相近的函数与和这些函数相关的变量封装在一起,叫做类。 有人会说有的类里没有函数,只有属性,这怎么讲?其实获取对象的属性本来就是一个“函数”,只是这个函数和一般的函数长得不太一样而已...
  • 关于js中面向对象的理解 面向对象编程(oop) 它是一种编程思想 (object-oriented programming ), 我们的编程或者学习其实是按照类、实例来完成的学习类的继承、封装、多态 封装 把实现一个功能的代码封装到一个函数...
  • 封装封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法, 如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个 类没有提供给外界访问的方法,那么这个类也没有什么意义了。...
  • 什么是面向对象?不了解原理但是会使用其功能如:现实中不了解电视对象内部工作原理但是你通过表面按钮却可以使用其功能。那什么又是对象?对象可以比喻为一个黑匣子,不用了解内部结构,但是知道其表面各种...
  • Java作为一门面向对象的编程语言,自然拥有面向对象的三大特性:  一. 封装性。封装性是一种信息的安全隐藏技术,它将对象的全部属性和方法紧密结合在一起,尽可能隐藏程序的实现相关功能的具体过程及思路,仅对外...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 427
精华内容 170
关键字:

关于面向对象的封装功能