精华内容
下载资源
问答
  • 面向对象概念和基本特征

    千次阅读 2018-07-23 16:24:51
    所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。 OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的...

    1 ,什么是面向对象?

    正如每个人心中都有一个哈姆雷特一样,每个人都有对面向对象的不一样的理解

    所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的主流。面向对象的概念和应用已经超越了程序设计和软件开发,扩展到很宽的范围。如数据库系统、交互式界面、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

    OO方法(Object-Oriented Method,面向对象方法)面向对象的方法是一种把面向对象的实现应用于软件开发过程中,指导开发活动的系统方法,简称OO(Object-Oriented)方法,Object Oriented是建立在“对象”概念基础上的方法学。对象是由数据和容许的操作组成的封装体,与客观实体有直接对应关系,一个对象类定义了具有相识性质的一组对象。而每继承性是具有层次关系的类的属性和操作进行共享的一种方式。所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    (我会在介绍完js中对象的特征后面继续介绍面向对象方法,转的一句话说明什么事面向对象方法,让你对面向对象有一个更深入的了解!)

    2 ,JS中的面向对象的基本特征

    面向对象的三个基本特征是:封装、继承、多态。在js中面向对象只有封装和继承,没有多态。

    封装:通过将一个方法或者属性声明为私用的,可以让对象的实现细节对其他对象保密以降低对象之间的耦合程度,可以保持数据的完整性并对其修改方式加以约束这样可以使代码更可靠,更易于调试。封装是面向对象的设计的基石。

    JavaScript是一门面向对象的语言,可它并不具备将成员声明为公共或私用的任何内部机制,所以我们只能自己想办法实现这种特性。下面还是通过一台完整的代码去分析,介绍什么是私有属性和方法,什么是特权属性和方法,什么是公有属性和方法,什么是公有静态属性和方法。

    私有静态属性和方法: 函数有作用域,在函数内用var 关键字声明的变量在外部无法访问,私有属性和方法本质就是你希望在对象外部无法访问的变量。

    特权属性和方法:创建属性和方法时使用的this关键字,因为这些方法定义在构造器的作用域中,所以它们可以访问到私有属性和方法;只有那些需要直接访问私有成员的方法才应该被设计为特权方法。

    公有属性和方法:直接书写在原型prototype上的属性和方法,不可以访问构造器内的私有成员,可以访问特权成员,子类会继承所有的公有方法。

    公有静态属性和方法:最好理解的方式就是把它想象成一个命名空间,实际上相当于把构造器作为命名空间使用。

     /* -- 封装 -- */
        var _packaging =function(){
           //私有属性和方法
          var name ='Darren';
           var method1 =function(){
              //...
           }
           //特权属性和方法
           this.title ='JavaScript Design Patterns' ;
          this.getName =function(){
             return name;
          }
       }
       //公有静态属性和方法
       _packaging._name ='Darren code';
       _packaging.alertName =function(){
          alert(_packaging._name);
       }
       //公有属性和方法
       _packaging.prototype = {
          init:function(){
             //...
          }
       }

    继承:继承是指这样一种能力:他可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    通过继承创建的新类称为 “子类” 或 “派生类”。

    被继承的类称为“基类”、“父类”  或者  “超类”。

    ① 构造函数绑定

    这一种方法最简单,使用call 或者 apply 方法,将父对象的构造函数绑定在子对象上,既在子对象构造元素中加一行代码:

    父类构造函数名.apply(this, arguments);

    Person.prototype.getName = function(){
        returnthis.name;
    }
    function Programmer(name,sex) {
        Person.call(this,name);  //在这里添加
        this.sex = sex;
    }

    ② 原型式继承 让子类的prototype对象指向父类的实例,相当于完全删除了prototype对象的原来的值,但是我们需要在原型继承js语句后面加上段代码 : 子类. prototype.constructor = 子类  ,不然子类的原型对象的构造函数属性就会指向所继承的父类prototype上的constructor(直接继承父类的原型的时候),继承父类的实例的时候回丢失constructor属性,继承完成之后当前这个子类的实例也都可以继承父类的prototype上的方法

       //直接继承父类原型
        function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name) {
     		this.name = name;
     	}
     	Son.prototype = Parent.prototype;
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor指向Parent
     	var s = new Son();
     	s.sayHello()//hello
    // 原型式继承改进 
     	function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name, age) {
     		this.name = name;
     		this.age = age;
     	}
     	Son.prototype.sayHi = function() {
     		console.log("hi");
     	}
     	Son.prototype = new Parent(); //原型继承改进继承父类的实例
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor会丢失
     	var s = new Son();
     	var p = new Parent();
     	s.sayHello()//hello
     	console.log(Son.prototype)
     	p.sayHi()// Uncaught TypeError: p.sayHi is not a function,父类的实例不可以调用子类的方法了

    js中对象的组成

        方法——函数:过程、动态的
        属性——变量:状态、静态的

    下面列举一些别人描述面向对象的思想

    1 ,把一组数据结构和处理它们的方法组成对象(object),把相同的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization) / 泛化 (generalization),通过多态(polymorphism)实现基于对象类型的动态分派(dynamic dispatch)。

    2,一种尽量降低后续扩展代码引入 side-effect 可能的代码组织手段

    3,封装:把属性值、红蓝条、攻击、走位、放技能、清兵、游走等行为都塞在一个英雄里。

    ,继承:攻击+10 的装备可以升级到攻击+20,以后还可能升级到攻击+30 并带有吸血效果。不管升级成什么,都携带着攻击+10 这部分属性。

    多态:一个团队需要一个辅助,我们只需要一个辅助英雄,并不关心来的是哪个辅助英雄,能加血就行。

    具备这三种特性的编程思想,叫做面向对象。
     

    展开全文
  • 面向对象基本概念

    万次阅读 多人点赞 2019-02-06 21:56:15
    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体...对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。 面向对象编程(OOP:object-orie...

    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。

    面向对象编程(OOP: object-oriented programming)

    面向对象

     

    面向对象与面向过程的区别

    项目名称面向对象程序设计面向过程程序设计(也叫结构化编程)
    定义面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”,其基本思想是一切皆对象,是一种“自下而上”的设计语言,先设计组件,再完成拼装。面向过程是“自上而下”的设计语言,先定好框架,再增砖添瓦。通俗点,就是先定好main()函数,然后再逐步实现mian()函数中所要用到的其他方法。
    特点封装、继承、多态算法+数据结构
    优势适用于大型复杂系统,方便复用、适用于简单系统,容易理解
    劣势比较抽象、性能比面向过程低难以应对复杂系统,难以复用,不易维护、不易扩展
    对比易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统 更加灵活、更加易于维护 性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发,性能是最重要的因素。 
    设计语言Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等C、Fortran
    使用场景

    30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700

    类与对象的主要区别

    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。 

    :类是一个模板,它描述一类对象的行为和状态。

    1、面向对象三大主要特征(理解)

    ①封装

    两层含义:一层含义是把对象的属性和行为看成一个密不可分的整体,将这两者“封装”在一个不可分割的独立单元(即对象)中;另一层含义指“信息隐藏”,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户知道或使用,但不允许更改,而另一些属性或行为,则不允许外界知晓,或只允许使用对象的功能,而尽可能隐藏对象的功能实现细节。

    封装的优点

    • 良好的封装能够减少耦合,符合程序设计追求“高内聚,低耦合”。

    • 类内部的结构可以自由修改。

    • 可以对成员变量进行更精确的控制。

    • 隐藏信息实现细节。

    实现Java封装的步骤

    1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:

    public class Person { 
        private String name; 
        private int age; 
    }

    这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。

    2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:

    public class Person{ 
        private String name;
        private int age; ​ 
        private boolean alive;
    
        public int getAge(){
            return age; 
        } 
    
        public void setAge(int age){ 
            this.age = age; 
        } ​
    
        public String getName(){ 
            return name; 
        } ​
     
        public void setName(String name){ 
            this.name = name; 
        }
    
        public boolean isAlive() {
    		return alive;
    	}
    
    	public void setAlive(boolean alive) {
    		this.alive = alive;
    	}
    
    }

    采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

    封装同时可以提高代码的安全性,例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值,但当我们用private修饰该属性后就不能这样对其做任意的修改了,而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为:

    public void setAge(int age){
        if(age > 120)
            System.out.println("Age setting error");
        else
            this.age = age;
    }

     封装的使用细节:

    1. 一般使用private访问权限
    2. 提供相应的get、set方法来访问相关属性,这些方法通常是public修饰的。以提供对属性的赋值与读取操作。(注意!boolean变量的get方法是is开头。)
    3. 一些只用于本类的辅助性方法,可以使用private修饰,希望其他类调用的方法用public修饰。

    this与super关键字:

    1、this关键字代表当前对象

    2、super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。  

     this与super对比

    • this.属性 操作当前对象的属性
    • this.方法 调用当前对象的方法 
    • 引用构造函数:调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。
    • 普通的直接引用:与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。
    • 子类中的成员变量或方法与父类中的成员变量或方法名同名时,表示调用父类的成员
    • 引用构造函数:调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。默认在构造函数第一条语句是“super();”,无论写与否。
    • super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
    • this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
    • 调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用 super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。
    • super() 和 this() 类似,区别是,super() 从子类中调用父类的构造方法,this() 在同一类内调用其它方法。
    • super() 和 this() 均需放在构造方法内第一行。
    • 尽管可以用this调用一个构造器,但却不能调用两个。
    • this 和 super 不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有 super 语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
    • this() 和 super() 都指的是对象,所以,均不可以在 static 环境中使用。包括:static 变量,static 方法,static 语句块。
    • 从本质上讲,this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

    ②继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    类的继承格式:

    class 父类 { }

    class 子类 extends 父类 { }

    继承的类型:需要注意的是 Java 不支持多继承,但支持多重继承。

     继承的好处:

    (1)提高类代码的复用性

    (2)提高了代码的维护性

    (3)使得类和类产生了关系,是多态的前提(它也是继承的一个弊端,类的耦合性提高了)

    继承的特性

    • 子类拥有父类非 private 的属性、方法。

    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

    • 子类可以用自己的方式实现父类的方法,即重写父类方法。

    • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

    • 继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

    • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

     final关键字:

    表示最终的意思,可以修饰类、成员变量、成员方法

    • 修饰类:类不可以被继承
    • 修饰成员变量:变量为常量,值不可以改变
    • 修饰成员方法:方法不能被重写
    • final还可以修饰局部变量:①修饰基本数据类型,值不能改变;②修饰引用数据类型,地址值不能改变

     static关键字(静态):

    static表示静态的意思,既可以修饰成员变量,又可以修饰成员方法,还有一种特殊用法修饰类

    (1)、修饰成员变量表示静态变量:static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。

    (2)、修饰成员方法:static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

    (3)static代码块:static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。

    特点:
        1)随着类的加载而加载
        2)优先于对象存在
        3)被所有的对象所共享
            该特点是我们使用static的条件

    注意事项:
        1)在静态方法中,不能出现this/super
        2)静态方法只能访问静态成员;非静态方法既可以访问静态成员,也可以访问非静态成员
        3)工具类里面的成员一般来说是静态成员(目的:节约内存空间)

    静态变量和成员变量的区别
    1)所属不同
          静态变量属于类,也称为类变量
          成员变量属于对象,也称为实例变量
    2)内存中位置不同
          静态变量存在方法区
          成员变量存在堆中
    3)出现的时间不同
          静态变量随着类的加载而加载,随着类的消亡而消亡
          成员变量随着对象的创建而创建,随着对象的消失而消失
    4)调用方式不同
          静态变量通过类名调用,也可以通过对象名调用(不建议)
          成员变量只能通过对象名调用
    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据

    成员变量与局部变量的区别
    1)在类中的位置不同
           成员变量:在类中方法外面
           局部变量:在方法或者代码块中,或者方法的声明上(即在参数列表中)
    2)在内存中的位置不同,可以看看Java程序内存的简单分析
           成员变量:在堆中(方法区中的静态区)
           局部变量:在栈中
    3)生命周期不同
          成员变量:随着对象的创建而存在,随着对象的消失而消失
          局部变量:随着方法的调用或者代码块的执行而存在,随着方法的调用完毕或者代码块的执行完毕而消失
    4)初始值
          成员变量:有默认初始值
          局部变量:没有默认初始值,使用之前需要赋值,否则编译器会报错(The local variable xxx may not have been initialized)

    package se01.day02;
    
    //子父类静态代码块、构造代码块、构造方法
    class Fu{
    	String name;
    	int age;
    	
    	{
    		System.out.println("构造代码块Fu");
    	}
    	
    	static{
    		System.out.println("静态代码块Fu");
    	}
    	
    	public Fu() {
    		System.out.println("无参构造方法Fu");
    	}
    
    	public Fu(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Fu");
    	}
    
    }
    public class Zi extends Fu{
    	int id;
    	{
    		System.out.println("构造代码块Zi");
    	}
    	static{
    		System.out.println("静态代码块Zi");
    	}
    	public Zi() {
    		System.out.println("无参构造方法Zi");
    	}
    
    	public Zi(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Zi");
    	}
    	public static void main(String[] args) {
    		new Zi("小明",13);
    	}
    }
    
    ==========================执行结果为====================================
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    无参构造方法Fu
    构造代码块Zi
    有参构造Zi

    static特殊用法(static修饰类):  如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。(在内部类中详细讲解)

    Question:在什么情况下需对属性和方法加上static关键字?

    在编写的代码中,static定义的属性出现几率不是特别高,一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性,而大部分情况下依然都使用非static属性。

    产生实例化对象是因为在堆内存中可以保存属性信息,所以如果一个类中没有属性产生,就自然也没有必要去开辟堆内存保存属性内容了,所以这个时候就可以考虑类中的方法全部使用static声明。

    NOTICE:在JDK1.7之前,Java一直存在一个Bug,可以先执行静态代码块来代替主方法。按照标准来说,所有的程序应该都是从主方法开始执行,但是下例却先执行静态代码块

    	public static void main(String[] args) {
    		System.out.println("你好,世界");
    	}
    	
    	static{
    		System.out.println("Hello World");
    	}
    
    ===========输出结果为==============
    Hello World
    你好,世界

    ③多态

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态的体现

    Java语言中含有方法重载与对象多态两种形式的多态:

    方法重载:在一个类中,允许多个方法使用同一个名字,但方法的参数不同,完成的功能也不同。

    对象多态:子类对象可以与父类对象进行转换,而且根据其使用的子类不同完成的功能也不同(重写父类的方法)。

    面试题:什么是多态?实现多态的方法有哪些?

    多态是面向对象的最后一个主要特征,它本身主要分为两个方面:
           ·方法的多态性:重载与覆写
                |-重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能。
                |-覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
           ·对象的多态:父子类对象的转换。
                |-向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
                |-向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类)父类实例,强制。

    多态的优点

    • 1. 消除类型之间的耦合关系
    • 2. 可替换性
    • 3. 可扩充性
    • 4. 接口性
    • 5. 灵活性
    • 6. 简化性

    多态存在的三个必要条件

    • 继承
    • 重写
    • 父类引用指向子类对象

    比如:Parent p = new Child();

    多态的访问方式:
    (1)成员变量
        编译看左边,运行看左边
    (2)成员方法
        编译看左边,运行看右边
    (3)静态方法
        编译看左边,运行看左边

    多态的实现方式

    方式一:重载与重写:

    这个内容已经详细讲过,就不再阐述,详细请见上文。

    方式二:抽象类和抽象方法

    在Java中,一个没有方法体的方法称为抽象方法。而一个类中如果有抽象方法,那么这个类就称之为抽象类。

    格式:
        抽象类:abstract class 类名{}
        抽象方法:修饰符 abstract 返回值类型 方法名(参数列表){方法体;}

    特点:
        1)抽象类不一定有抽象方法,但是有抽象方法的类一定是抽象类
        2)抽象类不可以实例化(不能用new关键字创建抽象类实例)
        3)抽象类的子类,可以是抽象类,也可以是具体类。如果子类是具体类,需要重写抽象类里面所有抽象方法

    组成:
        1)成员变量
            可以是变量,可以是常量
        2)构造方法
            有构造方法
            抽象类不可以实例化,存在构造方法,有什么用?
            子类会调用父类的构造方法,对属性进行初始化赋值
        3)成员方法
            可以是抽象方法,也可以是具体方法

    抽象(abstract)不能与那些关键字共存?
    1).private :因为一个abstract方法需要被重写,所以不能修饰为private;
    2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的,所以不能同final共存;
    3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间,所以不能同static共存;(abstract是没有实现  的,不能产生对象,而是static是属于类的,类本身是已经存在的对象)
    4).synchronized: 是同步的,然而同步需要具体的操作才能同步,但, abstract是只有声明没有实现的(即,使用synchronized关键字的是需要有具体的实现同步的操作的,但是使用abstract是只有声明而没有实现的,这样就产生了冲突)
    5).native:他们本身的定义就是冲突的,native声明的方法是移交本地操作系统实现的,而abstract是移交子类对象实现的,同时修饰的话,导致不知道谁实现声明的方法

    方式三:接口

    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。实际上是一个规范,它会要求你做什么,但不会要求你去怎么做。接口里面定义的是额外功能,但是不给出具体的实现。

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。

    接口与类相似点:

    • 一个接口可以有多个方法。
    • 接口文件保存在 .java 结尾的文件中,文件名使用接口名。
    • 接口的字节码文件保存在 .class 结尾的文件中。
    • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

    接口与类的区别:

    • 接口不能用于实例化对象。
    • 接口没有构造方法。
    • 接口中所有的方法必须是抽象方法。
    • 接口不能包含成员变量,除了 static 和 final 变量。
    • 接口不是被类继承了,而是要被类实现。
    • 接口支持多继承。

    接口特性:

    • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
    • 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
    • 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

    抽象类和接口的区别:

    • 1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
    • 2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
    • 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
    • 4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    接口的多继承

    接口和接口继承关系,可以单继承,多继承,多级继承

    标记接口

    标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

    Java中的标记接口有:

    1. java.io.Serializable这个接口是用来标记类是否支持序列化的,所谓的序列化就是将对象的各种信息转换成可以存储或者传输的一种形式。如果一个类没有实现该接口,却被拿去序列化的了,那么虚拟机就会抛出不支持序列化的异常
    2. Cloneable接口在深度拷贝的时候经常被用到,在调用java.lang.Object类中clone方法的过程中,如果对象没有实现Cloneable接口,那么虚拟机就会抛出一个CloneNotSupportedException异常。
    3. java.util.RandomAccess这个接口的作用是判断集合是否能快速访问,也就是通过索引下标能否快速的移动到对应的元素上。我们在使用某个集合类中,集合中的元素可以通过索引index下标快速的访问到,那么在该类的定义处,一般会有一个RandomAccess接口的实现标签。

      比如:java.util.ArrayList<E>有这个接口,java.util.LinkedList<E>就没有

      1 public class ArrayList<E> extends AbstractList<E>
      2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
      3 {
      4 //...
      5 }
      1 public class LinkedList<E>
      2     extends AbstractSequentialList<E>
      3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
      4 {
      5     ...
      6 }

    2、数组的使用以及初始化操作

    数组是用来存储多个相同数据类型值的容器。

    数组初始化
    1)动态初始化
        只指定数组的长度,由系统分配默认值
        格式:
        数据类型[] 数组名 = new 数据类型[长度];     或者      数据类型 数组名[] = new 数据类型[长度]
        默认值:
        byte、short、int、long,默认0
        float、double,默认0.0
        boolean,默认false
        char,默认'\u0000'
        String,默认null(所有引用数据类型默认都是null)
    2)静态初始化
        指定数组里面每个元素的初始值,不指定数组的长度
        格式:
            数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};
        简写:
            数据类型[] 数组名 = {元素1,元素2...};

    简单实例:

    public static void main(String[] args) {
    		  double[] myList = {1.9, 2.9, 3.4, 3.5};
    		  
    	      // 打印所有数组元素
    	      for (int i = 0; i < myList.length; i++) {
    	         System.out.print(myList[i] + " ");
    	      }
    	      System.out.println("\n=================");
    	      for (double d : myList) {
    			System.out.print(d + " ");
    		}
    	      System.out.println("\n=================");
    	      // 计算所有元素的总和
    	      double total = 0;
    	      for (int i = 0; i < myList.length; i++) {
    	         total += myList[i];
    	      }
    	      System.out.println("Total is " + total);
    	      // 查找最大元素
    	      double max = myList[0];
    	      for (int i = 1; i < myList.length; i++) {
    	         if (myList[i] > max) max = myList[i];
    	      }
    	      System.out.println("Max is " + max);
    	}
    
    
    运行结果:
    1.9 2.9 3.4 3.5 
    =================
    1.9 2.9 3.4 3.5 
    =================
    Total is 11.7
    Max is 3.5
    

     冒泡排序(相邻的元素进行比较,大值往后排):

    	public static void bubbleSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = 0; j < arr.length-1-i; j++) {
    				if(arr[j]>arr[j+1]){
    					temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    	}

     选择排序(前面元素与后面的元素诸葛逐个进行比较,小值往前排):

    	public static void selectSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = i+1; j < arr.length; j++) {
    				if(arr[i]>arr[j]){
    					temp = arr[i];
    					arr[i] = arr[j];
    					arr[j] = temp;
    				}
    			}
    		}
    		System.out.println(Arrays.toString(arr));
    	}

     多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

    String str[][] = new String[3][4];

    多维数组初始化的方式与一维数组初始化方式类似,也分动态和静态两种方式。

    不规则数组

    “ 不规则 ” 数组 , 即数组的每一行有不同的长度。典型的案例是杨辉三角

    //不规则数组,杨辉三角
    public class LotteryArray {
    	public static void main(String[] args) {
    		final int NMAX = 10; //最大行数
    		int[][] odds = new int[NMAX][];
    		for (int n = 0; n < NMAX; n++)
    			odds[n] = new int[n + 1]; //初始化,开辟空间
    		for (int n = 0; n < odds.length; n++) {
    			for (int k = 0; k < odds[n].length; k++) {
    				/*
    				 * int lotteryOdds = 1;
    				 * for (int i = 1; i <= k; i++) 
                                     *     lotteryOdds = lotteryOdds * (n - i + 1) / i;
    				 * odds[n][k] = lotteryOdds;
    				 */
    				// 第一个和最有一个都是1,其余的都是它的上一个和它的上一个的前一个的和
    				if (k == 0 || k == odds[n].length - 1) {
    					odds[n][k] = 1;
    				} else {
    					odds[n][k] = odds[n - 1][k - 1] + odds[n - 1][k];
    				}
    
    			}
    		}
    		for (int[] row : odds) {
    			for (int odd : row)
    				System.out.printf("%4d", odd);
    			System.out.println();
    		}
    
    	}
    }
    
    
    =======================结果显示============================
       1
       1   1
       1   2   1
       1   3   3   1
       1   4   6   4   1
       1   5  10  10   5   1
       1   6  15  20  15   6   1
       1   7  21  35  35  21   7   1
       1   8  28  56  70  56  28   8   1
       1   9  36  84 126 126  84  36   9   1

    数组工具类Arrays

    修饰符和类型方法和描述
    static <T> List<T>

    asList(T... a)

    返回由指定数组支持的固定大小的列表。

    static int

    binarySearch(byte[] a, byte key)

    使用二进制搜索算法在指定的字节数组中搜索指定的值。

    static int

    binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

    使用二进制搜索算法搜索指定值的指定字节数组的范围。

    char[]、double[]、float[]、int[]、long[]、Object[]、short[]...同样适用

    static boolean[]

    copyOf(boolean[] original, int newLength)

    使用false复制指定的数组,截断或填充(如果需要),以使副本具有指定的长度。

    static byte[]

    copyOf(byte[] original, int newLength)

    使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度。

    char[]、double[]、float[]、int[]、long[]...同样适用

    static char[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    static double[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    boolean[]、char[]、float[]、int[]、long[]同样

    static booleanequals(boolean[] a, boolean[] a2)

    如果两个指定的布尔数组彼此相等,则 返回true。

    byte[]、char[]、double[]...同样适用

    static voidfill(boolean[] a, boolean val)

    将指定的布尔值分配给指定的布尔数组的每个元素。

    byte[]、char[]、double[]...同样适用

    static voidparallelSort(byte[] a)

    将指定的数组按升序排序。java8新特性,并行排序。

    static voidsort(float[] a)

    将指定的数组按升序排序。串行排序。

    static voidsort(float[] a, int fromIndex, int toIndex)

    按升序对数组的指定范围进行排序。

    int[]、short[]、long[]、double[]...同样适用

    static StringtoString(boolean[] a)

    返回指定数组内容的字符串表示形式。

    3、java基本数据类型和引用传递区别

    简概: ①形参为基本数据类型形参改变,实参不会发生改变
     ②形参为引用数据类型形参改变,实参也会跟着改变(有特例)

    详述:https://blog.csdn.net/sugar_no1/article/details/86506510

     

    展开全文
  • 面向对象程序设计概念

    千次阅读 2019-09-26 17:03:28
      面向对象程序设计(object-oriented programming,OOP)是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格,它是一类程序设计语言的基础。 面向对象设计范型的主要特征是:  程序=对象+...

    一. 程序设计范型

      面向对象程序设计(object-oriented programming,OOP)是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格,它是一类程序设计语言的基础。
    面向对象设计范型的主要特征是:

     程序=对象+消息

      面向对象程序的基本元素是对象。面向对象程序的主要结构特点是:一、程序一般由类的定义和类的使用两部分组成;二、程序中的一切操作都是向对象发送消息来实现的,对象收到消息后,启动有关方法完成相应的操作。
      需要说明的是,某一种程序设计语言不一定与一种程序设计范型相对应。实际上具有两种或多种范型特征的程序设计语言,即混合型语言。例如,C++就不是纯粹的面向对象程序设计范型的语言,而是具有面向过程程序设计范型和面向对象设计范型的混合性设计语言。

    二. 面向对象程序设计的基本概念

    1. 对象
     现实中的对象,具有以下特征:

    1. 每个对象必须有一个名字以区别其他对象;
    2. 用属性来描述对象的耨些特征;
    3. 有一组操作,每一组操作决定对象的一种行为;
    4. 对象的行为可以分为两类:一类作用于自身的行为,另一类作用与其他对象的行为。

    2. 类
      类是一组具有相同属性和行为的对象的抽象。类与对象之间的关系是抽象与具体的关系。类是对多个对象进行综合抽象的结果。

    3. 消息与方法
      面向对象程序设计中,对象之间也需要联系,称为对象的交互。面向对象程序设计技术必须提供一种机制允许一个对象与另一个对象的交互。这种机制称为消息传递。
      对象所能实现的行为(操作),在程序设计方法中称为方法。它们是通过调用相应的函数来实现的,在C++语言中方法是通过成员函数来实现的。方法包括界面和方法体两部分。方法的界面给出了方法名和调用协议(相对于C++中的成员函数的函数名和参数表);方法体则是实现某种操作的一系列计算步骤,也就是一段程序(相对于C++中成员函数的函数体)。

    三. 面向对象程序设计的基本特征

    1. 抽象
      抽象是通过特定的实例(对象)抽取共同性质后形成概念的过程。面向对象程序设计中的抽象包括两个方面:数据抽象和代码抽象(或称为行为抽象)。前者描述某类对象的属性或状态,也就是此类对象区别于彼类对象的特征物理量:后者描述了某类对象的共同行为特征或具有的共同功能。对于一组具有相同属性和行为的对象,可以抽象成一种类型,在C++中,这种类型就称为类(class),类是对象的抽象,而对象是类的实例。
      抽象在系统分析、系统设计以及程序设计的发展中一直起着重要的作用。在面向对象程序设计方法中,对一个具体问题的抽象分析的结果,是通过类来描述和实现的。

    2. 封装
      在现实世界中,所谓封装就是把某个事物包围起来,使外界不知道该事物的具体内容。在面向对象程序设计中,封装是指把数据和实现操作的代码集中起来放在对象内部,并尽可能隐蔽对象的内部细节。对象好像是一个不透明的黑盒子.表示对象属性的数据和实现各个操作的代码都被封装在黑盒子里,从外面是看不见的,更不能从外面直接访问或修改这些数据及代码。使用一个对象的时候,只需知道它向外界提供的接口而无需知道它的数据结构细节和实现操作的算法。
      C++对象中的函数名就是对象的对外接口,外界可以通过函数名来调用这些函数来实现某些行为(功能)。封装的好处是可以将对象的使用者与设计者分开,大大降低了人们操作对象的复杂度。使用者不必知道对象行为实现的细节,只需要使用设计者提供的接口的功能即可自由地操作对象。封装的结果实际上隐藏了复杂性,并提供了代码重用性,从而减轻了开发软件系统的难度。
      封装是面向对象程序设计方法的一个重要特性,封装具有两方面的含义:一是将有的数据和操作代码封装在一个对象中,各个对象相对独立、互不干扰;二是将对象中某此据与操作代码对外隐蔽,即隐蔽其内部细节,只留下少量接口,以便与外界联系,接收外界消息,这种对外界隐蔽的做法称为信息隐蔽。信息隐蔽有利于数据安全,防止无关人员访和修改数据。

    3. 继承
      继承是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B,就把这个A称为“B的子类别”,而把B称为“A的父类别”也可以称“B是A的超类”。在令子类别继承父类别的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类别的原有属性和方法,使其获得与父类别不同的功能。另外,为子类别追加新的属性和方法也是常见的做法。 从继承源上分,继承又分为单继承和多继承。

    4. 多态
      面向对象系统的多态性是指不同的对象收到相同的消息时执行不同的操作。
      C++语言支持两种多态性即编译时的多 态性和运行时的多态性。 编译时的多态性是通过函数重载(包括运算符重载)来实现的,运行时的多态性是通过虚函数来实现的。
      多态性增强了软件的灵活性和重用性,为软件的开发与维护提供了极大的便利。尤其是采用了虚函数和动态联编机制后,允许用户以更为明确、易懂的方式建立通用的软件。

    展开全文
  • 数据挖掘中的概念描述

    千次阅读 2015-09-02 17:31:00
    从数据分析角度出发,数据...描述型数据挖掘又称为概念描述概念描述是数据挖掘的一个重要部分。概念描述基本知识描述型数据挖掘最简单的类型就是概念描述概念描述描述的是数据的特征和比较描述。 特征:给定数据集
    数据挖掘一般可分为描述型数据挖掘和预测型数据挖掘,概念描述讲的就是描述型数据挖掘。
    

    一、概念描述基本知识

    1.1 两种类型的数据挖掘

    从数据分析角度出发,数据挖掘可分为两种类型:

    • 描述型数据挖掘:以简洁概要方式描述数据
    • 预测型数据挖掘:预测性数据挖掘则是通过对所提供数据集应用特定方法分析所获得的一个或一组数据模型,并将该模型用于预测未来新数据的有关性质。

    1.2 概念描述

    描述型数据挖掘又称为概念描述,概念描述是数据挖掘的一个重要部分。描述型数据挖掘最简单的类型就是概念描述。概念描述描述的是数据的特征和比较描述:

    • 特征描述:给定数据集的简洁汇总
    • 比较描述:多用于两个或多个数据集

    数据泛化也是一种概念描述,这类似于数据仓库中的OLAP,但两者之间也是有区别的:

    • 复杂的数据类型和聚集:概念描述可以处理更加复杂的数据类型属性和他们的聚集
    • 用户控制和自动处理:OLAP多是用户的控制和操作,而数据挖掘中的概念描述更努力成为自动化的过程,具备自动知识发现的能力,要远远复杂的多

    二、特征描述

    数据泛化也是一种特征描述。数据泛化的概念:它是一个过程,它将庞大、任务相关的数据集从较低的概念层次抽象到较高的概念层次。具体泛化方法有两类:

    1. 数据立方:类似OLAP
    2. 面向属性的归纳

    数据泛化是非常有用的,举个例子:一个销售系统中的数据库中商品项目可能由诸如itemid,name,brand,price,category,place-made等低层次的属性构成,但销售和市场经理都希望得到在圣诞节期间大量商品基本信息的汇总描述来获得一些信息。

    2.1 面向属性的归纳

    面向属性归纳的基本思想是:首先使用关系数据库查询收集任务相关数据,然后通过观察任务相关数据中每个属性的不同值的个数进行泛化。泛化可以通过属性删除,或者通过属性泛化进行。

    2.1.1 收集任务相关数据

    通过数据挖掘查询或者关系查询获取相关数据,假设我们有如下关系查询语句:

    use Big_university_DB
    select name,gender,major,birth_place,birth_date,residence,phone,gpa
    from student
    where status in {"M.Sc","M.A","M.B.A","Ph.D"}
    

    把词语在关系数据库中执行,返回如下表所示数据。该表一般被称作初始工作表,是要进行归纳的数据。

    namegendermajorbirth_placebirth_dateredidencephonegpa
    JimMCSVancouver,BC,Canada76-12-83511,Main St,Richmand687-45983.67
    ScottMCSMontreal,Que,Canada75-7-28345,IstSt,Vancouver253-91063.70
    LeeFPhysicsSeattle,WA,USA70-8-25231,Austin,Burnaby420-52323.83

    数据已经准备好,下面就开始进行属性归纳,面向属性归纳的基本操作是数据泛化,它有两种方法:属性删除

    2.1.2 属性删除

    顾名思义,属性删除就是删除我们不需要的数据。我们基于如下规则盘点是否采用属性删除方法:如果初始工作表中某个属性有大量不同的值,(1)但是在此属性上没有泛化操作符;或者(2)它的较高层概念可以用其它属性表示,该属性应当从工作关系表中删除。

    举个例子,对于情况1,因为它没有泛化操作符,就意味着它不能被泛化,保留它则与产生简洁的描述规则相矛盾,比如初始工作表中的姓名字段。对于情况2,比如属性street可以被较高的属性city表示,所以删除city属性。

    2.1.3 属性泛化

    属性泛化基于如下规则:如果初始工作表中某个属性有大量不同的值,并且该属性上存在泛化操作符,则应当选择该泛化操作符,并将它用于该属性。

    2.1.4 属性泛化控制

    属性删除和属性泛化两个规则都表明,如果某个属性存在大量的不同取值,就应当进一步泛化,那多大才算是大?这个控制过程我们就称作属性泛化控制。有一些方法可以控制泛化的过程,下面介绍两种常用的方法:

    1. 属性泛化阈值控制,对所有属性设置一个泛化阈值,或对每个属性设置一个泛化阈值,如果属性不同值个数大于这个阈值,就应当进一步进行属性删除或泛化。
    2. 泛化关系阈值控制,如果泛化关系中不同元组的个数超过该阈值,则应当进一步泛化。

    2.1.5 面向属性归纳实例

    现在,我们就对上面的初始工作表中的每个属性进行泛化,泛化过程如下:

    1. name:由于name存在大量不同的值,并且没有泛化操作符,删除之。
    2. gender:只有两个不同值,保留,无需泛化。
    3. major:假设major数量有20,属性泛化阈值为5,并且已定义了一个向上攀升的概念分层{arts,engineering,business},则对major进行泛化。
    4. birth_place:有大量不同取值,应当泛化。可以将birth_place属性删除,泛化到birth_country。
    5. birth_date:泛化到age。
    6. resident:可以泛化到resident_country,像是的概念层次的number,street可以删除。
    7. phone:从泛化中删除。
    8. gpa:存在概念分层,可以泛化到{excellent,very good,…}
      所泛化过程将产生相等元组的组。例如,初始工作表中前两个元组被泛化成相同的元组(即第一个元组),这些相同的元组被合并成一个,同时累计它们的计数值,这一过程最终得到如下泛化关系表:
    gendermajorbirth_countryage_rangeredidence_citygpacount
    MScienceCanada20Richmonverygood1
    MScienceCanada20Vancouveverygood2
    FengineerUSA25Burnabyexcellent2

    2.2 数据泛化的导出表示

    • 二维表
    • 3d交叉表
    • 条形图、饼形图
    • 数据方

    三、解析特征:属性相关性分析

    有时候我们很难确定哪些属性应当纳入类特征或类比较中,我们可以借助某些属性相关分析方法来识别不相关或者弱相关属性。

    3.1 为什么要进行属性分析

    我们已经在上面介绍过,数据仓库和OLAP工具有两个局限性:处理复杂对象和泛化过程难以自动化。

    对用户来说,确定哪些维应当纳入到类特征分析中并不是一件很容易的事,数据关系通常有很多属性(多的有成百上千个),对于有效的数据挖掘,应当选择哪些属性或维,用户所知甚少。另一方面,用户也可能包含了太多的分析属性。

    所以我们应当引进一些方法进行属性相关性分析,以过滤统计不相关或弱相关属性,保留对手头挖掘任务最相关的属性。包含属性/维相关性分析的类特征成为解析特征,包含这种分析的类比较成为解析比较

    3.2 属性相关分析的方法

    关于属性相关分析,在机器学习、统计、模糊和粗糙集理论等方面都有很多研究。属性相关分析基本思想是计算某种度量,用于量化属性与给定类或概念的相关性。这种度量包括信息增益、Gini索引、不确定性相关系数

    展开全文
  • 面向对象程序设计的基本概念

    千次阅读 多人点赞 2021-01-31 17:03:44
    (1) 对象对象类   对象是代码和数据的组合,可以作为一个单位来处理。对象可以是应用程序的一部分,比如可以是控件或窗体。整个应用程序也是一个对象。   VB中的每个对象都是用类定义的。用饼干模子和饼干之间...
  • 面向对象概念及三大特点

    万次阅读 2018-09-19 17:16:52
    面向对象的基本概念 面向对象 oop : object oriented programming 我们之前学习的编程方式就是面向过程的 面向过程和面向对象,是两种不同的编程方式 对比面向过程的特点,可以更好的了解什么是面向对象 过程和...
  • 具有相同或相似性质的一组对象的抽象就是类,类是对一类事物的描述,是抽象的、概念上的意义; 对象是实际存在的该类事物的每个个体,因此也称为实例; 对象的抽象是类,类的具体化就是对象,也可以说类的...
  • 抽象就是把一个对象的分析出各个属性,来代替表达的手法 抽就是分离,象就是表示出来的部分 比如说把一个学生对象抽象一下,就剩下他的一些属性和行为,例如姓名,性别,年龄,身高,学习的能力等等.. 2. (1)解决问题的...
  • 对象,类与接口概念

    千次阅读 2019-02-21 23:14:27
    对象,类与接口 内部类 ​ 一个类定义在另外一个类的内部,分为成员内部类(定义在外部类的成员位置)和局部内部类(定义在外部类的方法里面) 成员内部类 class Outer{ class Inner{} } 成员内部类的特点 1、成员内部...
  • Java程序设计(面向对象)- 基本概念

    万次阅读 多人点赞 2019-05-25 20:10:06
    所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。 定义:以基于对象的思维去分析和解决问题,万物皆对象 对象有以下特点: 对象具有...
  • 编程中类、对象概念

    万次阅读 多人点赞 2017-10-06 16:50:23
    以最直白的例子解释编程中类、对象、类的属性、方法、继承的概念,并说明了面向对象编程的优点,点出面向对象编程和面向过程编程的区别
  • 面向对象程序设计基本概念

    千次阅读 2018-02-23 11:22:40
    问题空间(problem space):是问题解决者对一个问题所达到的全部认识状态,它是由问题解决者利用问题所包含的信息和已贮存的信息主动地构成的。一般由3下面三个方面来定义:...对象(object):一个对象有自己的状...
  •  例如数据结构教材的例题也有描述举例,例1-2中的“树”中的一个棋盘格局,例1-3中“图”的一个圆圈,都称为一个数据元素。 3、数据项(Data Item)  一个数据元素可由若干个数据项组成,例如,例1-1中一...
  • 生活角度面向对象:找合适的人做合适的事 生活角度面向过程:亲历亲为,自力更生 类和对象对象 电脑类 我的机械革命 汽车类 1949红旗 人类 乔布斯,比尔盖茨,马化腾 类:对于一类事物的统称,对当前事务...
  • 举个例子:Person是一个描述所有人的类,Student可以继承于Person,所有Person具有的公有方法Student都有,即任何使用Person对象的地方,都可以毫无顾忌的直接用Student代替。 这种关系是非常强的,有时候产生的...
  • 实体、对象与类的概念

    万次阅读 2016-05-04 07:03:04
    面向对象系列 什么是实体? 指客观世界存在的某个事物 如何描述实体? 通过对实体进行抽象,来描述实体 如何抽象描述实体 每个实体都有其特征和功能,特征和功能通称为属性 实体与实体的不同在于属性的不同 所谓...
  • 使用面向对象概念表示出下面的生活场景: 小明去超市买东西,所有买到的东西都放在了购物车之中,最后到收银台一起结账。 先贴下代码,草草写的。 interface Goods{ //使用接口表示商品 public double...
  •  1)概念数据模型(Conceptual Data Model):简称概念模型,主要用来描述世界的概念化结构,与具体的数据库系统无关。概念数据模型必须换成逻辑或物理数据模型,才能在数据库系统中实现。概念数据模型中最常用的是...
  • 面向对象分析和设计基本概念

    千次阅读 2014-10-12 11:54:31
     面向对象分析和设计基本概念  面向对象是基于一种哲学思想,它认为:客观实体和实体之间的联系构成了现实世界的所有问题,而每一个实体都可以抽象为对象。这种思想尽可能地按照人类认识世界的方法和思维方式来...
  • 对象:是一个自包含的实体,用一组可识别的特征和行为来标识。
  • 第四讲:面向对象程序设计方法及类、对象概念  掌握:面向对象程序设计的方法及特点;类的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;类和对象的作用;面向对象和面向过程的程序...
  • DDD的基本概念介绍

    千次阅读 2020-01-10 15:06:17
    DDD的基本概念澄清 目录 什么是DDD Ubiquitous language (通用语言) Layered architecture(分层架构) Entity(实体) Value Ojbect(值对象) Service(服务) Module(模块) Aggregate(聚合) ...
  • 1、对象和类概念对象:任何一个对象都应该具备两个要素:属性、行为。在C++中每个对象都有数据(体现了‘属性’)和函数(用来对数据进行操作,以实现某些功能)两部分组成。类:具有共性的实体的抽象。类是对象的...
  • 面向对象程序设计的基本概念 1. 对象 对象:面向对象程序设计的基本单元。 一个对象应当具有属性和行为两个要素。 - 属性:描述静态特征 - 行为: 描述动态特征。 2. 类 类: 对所有具有共同特征的事物归为...
  • 领域模型和领域对象概念

    万次阅读 2016-08-18 13:52:30
    又称概念模型、领域对象模型、分析对象模型。它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系。    面向领域对象设计的原则简单的说就是起名字定职能,对象定领域,找关系做关联...
  • 从今天开始有计划的写一些博文。内容主要涉及JAVA语言、面向对象... (一)面向对象基本概念  (二)异常处理与自定义异常  (三)多线程  (四)反射与注释 (一)面向对象的基本概念 1.面向对象?还是面
  • JAVA(类和对象)一 对象概念以及使用什么是对象?类的概念&使用(对象的创建&使用) 什么是对象? 面向对象程序设计(OOP):对象这个概念其实在生活中随处可见我们经常以事物为对象进行探讨,而在程序当中例如...
  • c++面向对象和c面向过程的一些概念

    千次阅读 2017-01-18 14:02:46
    1.面向对象和面向过程的概念 面向过程是分析解决问题的步骤,然后用函数把这些步骤一步一步的实现,然后在使用的时候一一调用则可。 面向对象是把构成问题的事务分解成各个对象,而建立对象的目的也不是为了完成一...
  • 面向对象设计思想-基本概念

    千次阅读 2020-12-22 19:42:31
    面向对象最需要的是 抽象的能力。 这个能力需要通过大量编写代码和思考...a、类是用于描述同一类型的对象的一个抽象的概念,类中定义了这一类对象所具有的静态和动态属性。 b、类可以看成一类对象的模板,对象可以看

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 544,898
精华内容 217,959
关键字:

对象概念描述