精华内容
下载资源
问答
  • 面向对象程序设计思想简述

    千次阅读 2017-11-24 17:17:05
    一些关于面向对象的概念问题的简要描述

    对象:

    • 在现实世界中是一个实体或者一个事物的概念,可以看作是一种具有自身属性和功能的构件。
    • 不关心其内部结构及实现方法,仅仅关心它的功能和它的使用方法,也就是该对象提供给用户的接口。
    • 类似于电视机这个对象,用户只关心如何通过按钮来使用它,这些按钮就是电视机提供给用户的接口。不关心电视机的内部结构或其实现原理。
    • 对象将其属性和操作的一部分对外界开放,作为对外接口,将大部分实现细节封装起来,这是对象的封装性。外界只能通过对象提供的接口来与对象交互。
    • 一个系统由多个对象组成,复杂的对象可由简单对象组成,称为聚合。对象之间的相互作用(通信)构成了软件系统的结构。

    类:

    • 同样类型对象的抽象描述
    • 对象是类的实例(具体化)
    • 对相关类进行分析,抽取其共有的特点形成基类。
    • 通过继承,派生类可以包含基类的所有属性和操作,增加属于自己的一些特性。通过继承还可以将原来一个个孤立的类联系起来,形成层次清晰的结构关系,形成类族。

    综上,面向对象的方法就是利用抽象、封装等机制,借助于对象、类、继承、消息传递等概念进行软件系统构造的软件开发方法。

    抽象

    • 面向对象方法的核心
    • 数据抽象:为程序员提供了对对象属性和状态的描述
    • 行为抽象:对这些数据所需要的操作的抽象

    封装

    • 将一个事物包装起来,不让外界了解它的详细内情
    • 有效实现了两个目标:对数据和行为的包装和信息隐藏

    继承

    • 软件复用的一种方式,通过继承,一个对象可以获得另一个对象的属性,并且可以加入属于自己的一些特性。
    • 继承使得原本孤立的类有效组织起来,形成层次结构关系。
    • 通过继承可复用已有的类,将开发好的类作为构建放入构件库中可供以后开发时直接使用或继承(生成特殊类)。

    多态

    • 多态性:一个接口,多种方式
    • 多态意味着同一属性或操作在一般类和特殊类中具有不同的语意
    • 举例:绘图时声明一个基类“几何图形”,在该类中定义一个“绘图的行为”,并定义该类的派生类“直线”、“椭圆”、“多边形”等,这些类都继承了基类中的“绘图”行为。基类中未定义具体的绘图方法,而是在各派生类当中根据需要对“绘图”重新定义。这样,当不同对象发出同一“绘图”命令时,各对象调用自己的“绘图”程序实现,绘制出不同的图形。
    展开全文
  • 4:以后发展:基于组件(构件模型)、以中间件作为程序的构加基础等等,实现软件标准化 5:面向对象语言:C++、VB、Delphi及JAVA等 二:课程学习的特点 1:观念的转变(从面向过程---面向对象),要忘记“C语言”,...
  • 经过2周的面向对象程序设计的学习,我深有感触,发现Java对我们专业发展发挥的重要作用,它涉及多个领域,是我们未来成为优秀的程序员必备的装备。 我们面向对象程序设计课刚上来就是尝试编辑一个类似于qq一样的...
      经过2周的面向对象程序设计的学习,我深有感触,发现Java对我们专业发展发挥的重要作用,它涉及多个领域,是我们未来成为优秀的程序员必备的武器。
      我们面向对象程序设计课刚上来就是尝试编辑一个类似于qq一样的聊天软件叫“yychat” ,开始我有很多不能理解的地方,例如在编写程序的过程中存在太多的生单词,不知道Java语言的基础知识,对大部分的编写部分不是很清楚等等,我希望能自己编写出这套程序,但这些限制了我的实践,我想花更多的时间去学习掌握不知道的知识和弥补自己的不足。
      我不想放弃,打从心底想学好它,想自己编写出自己的软件。在此我希望能够通过以后的学习,好好加深对这门课的理解,打牢Java语言的基础知识,同时我也会勤学英语将自己的不足加以提升来弥补面向对象程序设计课程中的英语空缺。
      加油,我会成功的!!!
      Fighting!!!
    
    展开全文
  • 程序设计发展

    千次阅读 2019-03-17 00:56:57
    一、程序设计发展史 ​ 40-50年代:机器语言,由二进制发出各种程序指令 ​ 60年代: C语言,其他面向过程语言 ​ 70年代: C++,VB等介于面向过程与面向对象之间 ​ 90年代: Java,PHP,JavaScript等,...

    一、程序设计发展史

    1. ​ 40-50年代:机器语言,由二进制发出各种程序指令

    2. ​ 60年代: C语言,其他面向过程语言

    3. ​ 70年代: C++,VB等介于面向过程与面向对象之间

    4. ​ 90年代: Java,PHP,JavaScript等,面向对象

      ​ 面向对象语言 是符合人的思维逻辑,对一些事物进行程序化编写

    二、Java 语言

    面对程序设计(OOP),有两个重要概念“类”和“对象”

    类:对一类事物抽象的描述,它包含这类事物的特征(类的属性)和行为(类的方法),例如电脑,学生,人类等

    对象:实际存在该类事物的某个个体,是一个具体的实例

    package com.j1901.mean;
    
    public class Demo {
    	public String name;
    	public int age;
    	private String sex = "男";
    	
    	/**
    	 * 定义行为(方法)
    	 * 语法:
    	 * 访问修饰符void 方法名(){
    	 * }
    	 */
    	
    	public void eat(){
    		System.out.println(name + "正在吃饭");
    	}
    	/**
    	 * 输出基本信息
    	 */
    	public void showInfo(){
    		System.out.println("姓名" + name + "年龄" + age + "性别" + sex);
    		//定义一个学生姓名性别地址
    	}
    }
    
    
    package com.j1901.mean;
    
    public class Demo1 {
    	public static void main(String[] args){
    		//通过类 创建对象
    		//语法:类名	对象名	=	new	类名();
    		Demo people = new Demo();
    		//给对象赋值
    		people.name = "程冲";
    		people.age = 22;
    		//Demo.sex  私有属性 不能被其他任何类访问,只能自己访问
    		
    		//访问访问  对象名.方法名()
             people.eat();
    		System.out.println("输出年龄:" + people.age);
    		System.out.println("性别:");
    		
    		//访问ShowInfo
    		people.showInfo();
    	}
    }
    
    

    Java的注释

    单行注释 // 快捷键 Ctrl + /

    多行注释 /* 代码 */

    文档注释,一般注释类,方法,属性

    /**

    */

    当编写文档注释时,jdk可以自动生成 对应类API

    1、通过命令 在当前目录下 cmd->javadoc 类名 或者也可以生成整个包的文档注释

    默认在当前目录下 javadoc 参数

    2、通过 Myeclipse生成,在工具类中 -> project ->Genneric -> javadoc 选择项目或者包生成整个文档,默认在项目的doc中创建index.html

    文档注释的默认注释:

    • @author 文档作者
    • @version 版本
    • @docroot 表产生文档的根路径
    • @param 表参数的类型
    • @return 表参数的返回值
    • @see 表参见某个文档,指文档来源
    • @exception 指抛出的异常
    • @throw 指抛出异常的名称

    Java的分隔符

    1、 ; 每句话结束都必须用分号结束,可以若干个分号。

    2、每一个语句块都需要用花括号{};{}表示一个方法块,例如:方法,类,语句块,静态语句块

    3、空格 换行 和分号 可以任意多个 不会被JVM编译报错

    Java标识符

    用于标识一个特定的元素,用于给某个元素命名。例如:类名 方法名 属性名等 尽量要求“见名知意”

    要求:

    1.由字母 数字 下划线 $符组成;其中不能以数字开头

    2.标识符不能是关键字;

    3.标识符区分大小写

    4.定义类的标识符:首字母大写后面首字母大写(驼峰命名法)

    5.定义方法名:首字母小写,后面首字母大写

    6.定义属性(变量)名 与方法名一样 私有变量建议 _ 开头。

    Java关键字

    1.Java中用于特定意义,做一些专门用法的字符,称为关键字keyword

    2.所有关键字都是小写,一共是50个关键字 (48+2 goto const)

    Java关键字
    abstract
    assert
    boolean
    break
    byte
    continue
    case
    catch
    char
    class
    const
    double
    default
    do
    extends
    else
    final
    float
    for
    goto
    long
    if
    implements
    import
    native
    new
    null
    instanceof
    int
    interface
    package
    private
    protected
    public
    return
    short
    static
    strictfp
    super
    switch
    synchronized
    this
    while
    void
    throw
    throws
    transient
    try
    volatile
    enum

    a) 访问修饰符

    public共有的protected受保护的
    private私有的

    b)类,方法和变量修饰符

    Abstract抽象Class
    Extends继承的关键字Synchronized线程同步
    Interface接口的关键字Volatile线程的较轻同步
    Implements实现接口的关键字Transient瞬时状态
    Native本地的Final
    New创建对象Strictfp
    Static静态的

    c)程序控制符

    Break跳出循环Instanceof判断对象类型
    Continue跳出本次循环Switch选择
    Forfor循环Case选择的分支
    DoIf条件判断
    While循环Else条件判断
    Default默认Return返回方法 ,返回对象

    d)异常处理

    Try尝试捕获异常Cath捕获异常
    Finally最终执行的代码块 (无论是否有异常)Throw抛出一个异常
    Throws定义要抛出的异常

    e)包相关

    1. Import 导入指定的包和类

    2. Package : 定义类所在的包的位置

    f)变量引用

    1. Super 超类定义 父类

    2. This 表示当前

    3. Void 方法的返回值为空 的 定义

    g)保留字

    ​ Goto 、Const

    三、Java的数据类型

    Java是一门强类型语言(在JDK10以后也支持弱类型变相声明)

    Java数据类型分为两大块

    1.基本数据类型(简单数据类型,不提供任何与该数据类型相关的行为和方法)

    ​ 1.8大基本数据类型。

    数据类型字节(1-8个位bit)范围
    byte1-2的7次方~2的7次方-1
    short2-2的15次方~ 2的15次方-1
    int4-2的31次方~ 2的31次方-1
    long8……
    float4(单精度,存小数)……
    double8(双精度)……
    char2个字节……
    Boolean1True/False

    ​ 一字节等于8位。

    2.引用数据类型(包装类型,复杂数据类型)

    package com.j1901.mean01;
    
    public class Text2 {
    	public static void mian(String[] args){
    		//定义变量
    		int num1 = 1001; //分配一个内存为4个字节的空间,里面存放的值为1001
    		float f1 = 12.23F; //Java中默认将小数作为double类型
    		double d1 = 23.35; //基本数类型转换问题
    		
    		char c1 = 'a'; // 字节		只能存放一个字符
    		System.out.println((int)c1);//字符和int可以相互转换
    		
    		int num4 = 43;
    		System.out.println((char)num4);
    		// boolean  布尔 
    			boolean flag1= true;
    			boolean flag2 = false;
    				 
    			System.out.println(flag1);
    				
    			// 问题:  字符和字符串有什么关系 ?
    			// 1、字符是基本数据类型 字符串是引用数据类型 , 字符串中包含如果个字符。
    		    // 2 字符是单引号,字符串是双引号
    			char c5='\n'; // \表示java中的转义字符,  \n 表示换行   \t 表示制表符(tab)
    	}
    }
    
    

    Java的数据类型转换

    ​ 程序计算式,必须保证数据类型一致,如果数据类型不一致需要转化

    ​ 从底类型到高类型是自动转化,反之,高类型到低类型是强制转换

    int a = 1001;
    long b = a;
    
    int c = (int)b;
    

    ​ 数据类型从低到高排列:byte/short/char/int/long/float/double

    Java的变量

    ​ 变量:在程序运行过程中,其值可以改变的量

    全局变量

    ​ 定义在方法外(就是属性)

    局部变量

    ​ 定义在方法里面

    package com.j1901.bianliang;
    
    public class Test1 {
    
    	public int age;
    	public short ss;
    	public byte bb;
    	public long ll;
    	public float ff;
    	public double dd;
    	public boolean flag;
    	public char cc;
    	
    	
    	public static void main(String[] args) {
    		 //变量:  在程序运行过程中,其值可以改变的量   
    		  // 分为 全局变量 和  局部变量
    		 // 全局变量:  定义在方法外面 (就是属性)
    		 // 局部变量:  定义在方法的里面
    		
    		int num1 =1;   // num1 就是变量  
    		
    		num1=2;
    		num1=22;
    		System.out.print(num1);
    		
    		//全局变量  
    		//age=18;  由于age属于对象的属性  ,需要创建对象才可以调用
    		
    		Test1 test1 = new Test1();
    		test1.age=18;
    		
    		// 可以连续定义 相同类型的变量  
    		int a=35 ,b=36;
    		System.out.println(a+b);
    		
    		//常量 :    
    		System.out.print(123F); // 直接常量
    				
    		//间接常量     final 修饰的变量都是常量  ,其值不能改变 
    		final int num2=1001;
    		// num2=1002;
    		
    		// 8个基本数据类型的默认值 
    		//  int   0
    		
    		int num3;
    	//	System.out.print(num3);   // 局部变量  必须赋值才可以使用 ,全局变量不用赋值 就可以使用,
    		//  全局变量基本数据类型的默认值 分别 
    		System.out.println("基本数据类型的默认值");
    		System.out.println(test1.age);// 0
    		System.out.println(test1.ss);// 0
    		System.out.println(test1.bb);// 0
    		System.out.println(test1.ll);// 0
    		System.out.println(test1.ff);// 0.0
    		System.out.println(test1.dd);// 0.0
    		
    		System.out.println(test1.cc);// 空格
    		System.out.println(test1.flag);// false
    		
    		 
    		
    
    	}
    
    }
    
    
    展开全文
  • 前言设计模式(design pattern)是一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。关键词:重用代码、工程化、面向对象。设计模式起源于建筑设计学,最先由 Gang of Four 提升到了理论高度。

    前言

    设计模式(design pattern)是一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。关键词:重用代码、工程化、面向对象。设计模式起源于建筑设计学,最先由 Gang of Four   提升到了理论高度。

    可复用面向对象体系分为两大系统:工具箱和框架。Java中的API属于工具箱(toolkit),Java EE (Enterprise Edition)属于框架(Framework)。设计模式是大神们在构造 Java EE 的时候的重要理论依据,学习设计模式有助于深入了解 Java EE。


    我最近在实验楼 学习完了一门课程《Java进阶之设计模式》。截止至2015年12月16日,我已经在实验楼网站有效学习了960分钟,完整学习了5门课程。功夫在课外,我认为实验楼是一个能够开阔视野,快速入门新领域的地方。其主要特点是:课程设置广泛,内容深入浅出,提供linux环境。

    GOF最早提出的设计模式总共有23个,分为三类型:创建型模式(5个),构造型模式(7个),行为型模式(11个)。后来,人们总结出了更多的设计模式,参考wikipedia

    • 创建型:单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
    • 构造性:适配器模式、装饰模式、代理模式、组合模式、桥梁模式、外观模式、享元模式
    • 行为型:模板方法模式、命令模式、责任链模式、迭代器模式、中介者模式、观察者模式、访问者模式、状态模式、解释器模式

    实验楼里面讲解了其中的6个,这6个大体上是23个中使用频率最高的6个:工厂方法模式、抽象工厂模式、单例模式、适配器模式、装饰者模式、观察者模式。我下面将首先简单介绍设计原则,然后小结一下上述常用6种模式。我写本篇博客使用的参考资料包括:实验楼的课程、《Head First Design Patterns》、《设计模式(Java版)》、wikipedia、百度百科。


    设计原则

    • 开闭原则(OCP):open for extension, but close for modification。在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展。这个是最最基础的原则。

    • 单一职责原则(SRP):never be more than one reason for a class to change。专注做一件事情,仅有一个引起变化的原因,“职责”可以理解成“变化的原因”。唯有专注,才能够保证对象的高内聚;唯有单一,才能保证对象的细粒度。

    • 里氏替换原则(LSP):Liskov提出:” Let  Φ(x) be a property provable about objects x of type T. Then  Φ(y) should be true for objects y of type S, where S is a subtype of T.” 这里的type,我理解成class。子类的对象可以无条件地替换父类的对象,并且不引起程序的改变。或者说:只要父类能出现的地方,子类就可以出现。

    • 依赖倒置原则(DIP):High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions. 即高层模块不依赖低层模块;高、低层模块都依赖其抽象;抽象不依赖细节,反过来细节依赖抽象。在JAVA中,所谓的抽象,就是接口或者抽象类;所谓细节,就是就实现类(能够实例化生成对象的类)。为什么说“倒置”?因为在传统的面向过程的设计中,高层次的模块依赖于低层次的模块,抽象层依赖于具体层(这样不好),倒置过来后,就成为了面向对象设计的一个原则了(这样子好)。

    • 接口隔离原则(ISP):The dependency of one class to another should depend on the smallest possible interface. 类间的依赖关系应该建立在最小的接口上面。客户端不应该依赖他不需要的接口,只提供调用者需要的方法,屏蔽不需要的方法。一个接口代表一个角色,使用多个专门的接口比使用单一的总接口更好。

    • 迪米特法则(LoD)又称最少知识原则(LKP): Each unit should only talk to its friends; don’t talk to strangers. Only talk to your immediate friends. Each unit should have only limited knowledge about other units. 曾经在美国有一个项目叫做Demeter。LoD is a specific case of loose coupling.此原则的核心观念就是类之间的弱耦合,在这种情况下,类的复用率才可以提升。


    工厂方法模式

    Head First (简称HF ) 说:There is more to making objects than just using the new operator. Instantiation is an activity that shouldn’t always be done in public and can often lead to coupling problems. 这就是工厂方法的来源。

    首先简单提一下:简单工厂。HF : The Simple Factory isn’t actually a Design Pattern; it’s more of a programming idiom. 代码实现:把 new操作的过程封装到一个class SimpleFactory 的一个方法中。这个方法有一个参数,这个参数决定如何new。

    简单工厂进行抽象化,得到工厂方法模式。工厂方法模式定义:Factory Method Pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method let a class defer instantiation to subclasses. 简而言之,一个工厂父类作为“总管”,管理旗下的具体工厂子类,new 操作在具体工厂子类里面。定义中”defer”的意思是:父类不立刻进行new操作,而是交给子类进行new操作。

    代码工厂方法模式例子Java源代码 (推荐在新标签页打开)。我改编自HF 的pizza例子(我本学期早上流行吃包子)

    小结:(看完代码之后再看小结)
    一个工厂子类,看上去很像一个简单工厂。确实如此,不过这一些工厂子类都继承自同一个工厂父类,需要实现同一个抽象方法createBaoZi,然后利用多态性。简单工厂像是一个“一锤子买卖”,而工厂方法模式则搭建了一个框架,让工厂子类决定生产那一个具体产品。工厂方法模式更加抽象,更具有通用性,耦合度更低。

    在Main类里面,new 一个工厂子类,把其引用赋给一个工厂父类的引用。从代码层面可以看出,当需要扩充新的工厂的时候,增加一个继承工厂父类的子类就行了。Main类里面的那个工厂父类的引用无需改变。更进一步说,Main类里面的所有的用到工厂父类的引用的地方都无需改变,这就是体现了开闭原则的中的“close for modification”


    抽象工厂模式

    抽象工厂模式定义:Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

    首先需要知道一个概念“a family of products”,翻译成“产品族”。Head First : Factory Method provides an abstract interface for creating one product. Abstract Factory provides an abstract interface for creating a family of products.

    产品族:假设有三类抽象产品:手机、笔记本、平板。手机分为两个具体产品:iphone 6s和华为Mate8;电脑分为两个具体产品:Macbook Pro和Surface Book;平板分为iPad Air和Surface 3。那么从手机里面二选一,从笔记本里面二选一,从平板里面二选一,总共产生了8个不同的产品族。比如”iphone 6s + Macbook Pro + iPad Air”就是8个产品族中的1个(土豪!)。

    代码抽象工厂模式例子Java源代码 (推荐在新标签页打开)

    小结:抽象工厂模式是对工厂方法的进一步抽象。是把一组具有同一主题的单独的工厂封装起来。抽象工厂可以看成是”工厂的工厂“,抽象工厂中的一个抽象方法,很像一个工厂方法模式。一个工厂有多抽象工厂,就像是有多个工厂方法模式。


    单例模式

    有时候存在这种需求:强制要求某个类只能实例化一个对象, one and only one. 单例模式解决了这种需求,其定义是:Singleton Pattern ensures a class has only one instance, and provide a global point of access to it.

    应用场景:

    • 要求生成唯一序列号的环境
    • 需要共享访问点或共享数据,例如CSDN每一篇博客都有一个计数器,用来统计阅读人数,使用单例模式保持计数机的值
    • 需要创建的对象消耗大量资源,比如IO和数据库资源
    • 需要定义大量的静态常量或者静态方法(工具类)的环境,比如Java基础类库中的java.lang.Runtime类

    仔细想想,如果使用全局变量,则可以实现定义中的后半句,但是无法实现定义中的前半句,而且使用全局变量会污染命名空间。

    代码:单例模式Java源代码,可以在新标签页打开

    小结:单例模式,顾名思义,让一个类有且只有一个实例对象。这样做可以达到节约或者控制系统资源的目的。在代码层面,其最主要的特征是其构造函数是私有的。次要特点是:数据成员Singleton的实例引用是静态的,而且有一个静态的getInstance()方法,用来负责 new Singleton() 和返回 Singleton的实例引用。


    观察者模式

    这是一个常用的行为型模式,又称为“发布者——订阅者”模式。发布者比如报社,订阅者比如老百姓。清晨爷爷奶奶们出去晨练,看见一个卖报纸的小男孩在街上大声吆喝:“今天的报纸来了!”,然后爷爷奶奶们得到通知,都去买了报纸。报社是主题(Subject),爷爷奶奶们是观察者(Observer),卖报纸的小男孩,负责告诉Observer:“Subject更新了!”

    定义:The Observation Pattern defines a one-to-many dependency between objects so that when one objects changes state, all of its dependents are notified and updated automatically.

    代码观察者模式Java代码,可以在新标签页打开

    小结:定义中的one就是Subject, many就是Observers;one就是发布者,many就是订阅者;one就是事件源,many就是监听者。多个观察者(Observer)“围观”一个被观察者(Subject),可以说被观察者是万众瞩目的焦点。观察者和被观察者之间是抽象耦合(类图在上面的链接里),它们属于不同的抽象化层次,非常容易扩展。使用场景是:关联行为;事件多级触发;消息队列等。


    适配器模式

    这是一个结构型模式。周边适配器到处都是,比如手机充电器就是一个把插座上面的两孔国标插座,转换成USB接口。去了美国,怎么给我的荣耀手机充电?那就那一个适配器,把美国的两孔/三孔美标插座转换成两孔国标插座。

    定义:The Adapter Pattern converts the interface of a class into another interface the client expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.

    在上面的情景中,荣耀手机就是定义中的“client”;两孔国标接口就是”interface the client expect”;美国的两孔/三孔美标插座就是定义中 “converts the interface of a class”中的”interface”;Adapter 负责动词”convert”。

    代码适配器模式 Java源代码,可以在新标签页中打开

    小结:适配器Adapter的核心,是实现Target接口, 组合Adaptee接口。通过实现和组合,这两种类与类之间的关系,把两个本不兼容的类(Target 和 Adaptee)联系在一起。增强了类的透明性,松耦合,提高了类的复用,增强了代码的灵活性。


    装饰者模式

    这是一个结构型模式。

    很多情况下,需要扩展功能,增加职责。如果说生成子类是静态的添加额外的职责的话,那么装饰者模式则提供了一种动态的方法,较为灵活。

    定义:attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

    代码装饰者模式 Java源代码,可以在新标签页中打开

    小结:关键是Decorator同时继承和组合Component,Component是被装饰者装饰的对象。装饰者和被装饰者可以独立发展,耦合度很低,很好的符合了开闭原则,是继承关系的一种替代方案。或者说,是一种对继承关系的有力的补充,可以解决类膨胀的问题。Java.IO就是参照装饰者模式设计的。


    一点感悟

    我现在是计算机科学与技术(CS)的大三上学期。设计模式的学习,我都是利用课外时间。我学习设计模式的初衷,除了见见世面之外,就是学习Java(我大一大二都是写C++,大三上学期才学Java),可谓一箭双雕。我下载了《Head First Design Patterns》在GitHub上的样例代码, which is written in Java。我一边看书,一边看代码,抄代码,一边改编代码。理论与敲代码结合,快速提升、强化基本能力。

    • 敲了不少Java代码,对Java的”感觉”加深了,代码是需要积累的
    • 我在eclipse装一个插件,用来绘制UML类图。我对eclipse的”感觉”加深了,体会到了插件的强大威力
    • 继承,多态。以前写C++代码,只用封装,很少用继承和多态。毕竟平时主要在写”小算法”,没有涉及到大的宏观层面的设计。在设计模式中,大量运用继承(还有实现),多态
    • decouple。这个词在HF 中高频率出现。降低耦合,面向接口,可以增强整个程序的扩展性,便于维护,适合多团队多人合作开发
    • 通过几个设计模式,慢慢体会了设计模式中的6条原则,这些原则不是”教条主义“,不能刻板遵守。而是要慢慢把这些思想融入到程序设计中
    • 关于算法和设计模式。网上看到一些评论,有一个评论很生动:算法像是”单兵作战和武器装备“,设计模式像是”仗列的阵型“。算法用来解决具体问题,设计模式用来合理的把算法隔离到各个正确的地方去。真正体会设计模式,还是需要很多年的实践积累

    设计模式的博客就写到这里。最近在较短时间内,集中学习了6个常用设计模式,收获颇丰。掌握了基本思想和方法,在以后的学习和实践中,遇到新的需要使用的模式,我就能快速学会和运用。

    一个设计模式学习网站

    展开全文
  • 学习C++的时候我们都知道C++是面向对象程序设计,而C语言是面向过程的程序设计语言,这这一篇文章将会去介绍面向过程程序设计和面向对象程序设计的区别和C++语言的基础输入输出以及string的使用 面向对象程序设计...
  • 程序设计语言诞生  1946冯·诺依曼提出了冯·诺依曼原理:  CPU逐条从存储器中取出指令执行,按指令取出存储的数据经运算后送回。  数据和指令(存储地址码、操作码)都统一按二进制编码输入。数据值的改变是重新...
  • 程序设计的发展过程是根据业务系统的复杂程度来决定的   程序设计的发展过程分为三个阶段: 1.过程式程序设计 ... 不足:程序系统知识为了现有的功能实现,没有考虑将来发生变化之后的应对,违背了软件...
  • 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标:...
  • 程序切片的起源与发展

    千次阅读 2018-12-03 16:41:29
    程序切片的起源与发展 程序切片技术是一种分解程序程序分析技术。其常用于软件测试、运行维护等方面。 产生 1979年,美国Mark Weise首次在他的博士论文中提出了程序切片思想。 用途 程序切片技术在计算机...
  • 最早的面向对象程序设计语言

    千次阅读 2012-09-21 15:41:53
    简介  1967年5月20日,在挪威...Simula 67被认为是最早的面向对象程序设计语言,它引入了所有后来面向对象程序设计语言所遵循的基础概念:对象、类、继承。之后,在1968年2月形成了Simula 67的正式文本。 挪威
  • 面向对象程序设计

    千次阅读 2011-10-23 22:26:22
    面向对象程序设计 求助编辑百科名片 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象...
  • 对面向过程和面向对象都有所涉及,在这里这个小结(有些是在网上收集的) 自己的理解: 面向过程是一种以事件为中心的编程思想,以功能(行为)为导向,按模块化的设计,就是分析出解决问题所需要的步骤,然后用...
  • 1.1 程序设计语言发展的四个阶段  到目前为止,程序设计语言的发展经过了机器语言、汇编语言、高级语言、第四代语言四个阶段,每一个阶段都使程序设计的效率大大提高。我们常常把机器语言称为第一代程序设计语言,...
  • 计算机存储的发展(块存储,文件存储,对象存储)

    万次阅读 多人点赞 2018-09-15 15:04:08
    对象存储 1、对象 2、对象存储设备 3、元数据服务器(Metadata Server,MDS) 4、对象存储系统的客户端Client 三者之间异同比较 参考文献 如果要实现一个计算机,那么这个计算机一定要有以下的三个部分构成:...
  • 20世纪90年代中后期诞生并迅速成熟的UML(Unified Modeling Language,统一建模语言)是面向对象技术发展的一个重要里程碑。UML 统一了面向对象建模的基本概念、术语和表示方法,不仅为面向对象的软件开发过程提供了...
  • 编译原理的地位 是软件技术的基础 是计算机专业的基础课程,是专业必修课 编译原理的作用 编译原理是介绍如何将高级语言程序变换成低级语言程序的方法。...ADA 对象式语言:Java, C++ 等 函数式语
  • C++语言程序设计 培养目标:1.建立基本的计算机程序设计概念体系和基本的程序设计方法. ... 初步掌握面向对象程序设计的方法.  3.逐步提高学生的编程能力和调试程序的能力,为后面的学习打好基础. 第一章
  • 最早的程序设计都是采用机器语言来编写的,直接使用二进制码来表示机器能够识别和执行的指令和数据。简单来说,就是直接编写0和1的序列来代表程序语言。例如:使用0000 代表 加载(LOAD),0001 代表 存储...
  • Java语言特点

    万次阅读 多人点赞 2019-06-30 19:37:45
    Java语言是简单的 Java语言的语法与C语言和C++语言很接近,从某种意义上讲,它是由C和C++演变而来,使得...提供了丰富的类库和API文档,以及第三方开发包工具包,还有大量的基于Java的开源项目,帮助程序设计人...
  • 这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。 循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。 什么是循环...
  • 学习Java的你,真的会面向对象编程吗?

    千次阅读 多人点赞 2020-07-19 15:23:30
    学习Java的你,真的会面向对象编程吗?本文主要讲解什么是面向对象,以及如何在Java中实现面向对象编程,欢迎您前来学习!
  • 面向对象发展过程

    千次阅读 2011-10-23 23:25:11
    面向对象发展过程 来源:CSDN 作者:ljianl 发布时间:2007-6-9 人气:580   面向对象(Object Oriented)编程技术最先被广泛使用的语言是C++,Bjarne Stroustrup写...
  • 对C++面向对象的编程的理解

    千次阅读 2019-01-16 18:05:06
    面向对象方法历经了30多年的研究和发展,已经日益成熟和完善,应用也越来越深入和广泛,现其已经发展为主流的软件开发方法。 本节主要介绍面向对象方法的优点以及它的一些基本概念。 2.3.1面向对象方法的优点(1)与...
  • Java面向对象总结篇

    千次阅读 多人点赞 2019-01-17 15:48:33
    面向对象在百度百科中是这样解释的:“面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物”。说的好像很流弊的样子,看看就行。 说道面向对象,大家肯定会想到面向对象的三大基本...
  • Java面向对象(知识点整理)

    万次阅读 多人点赞 2021-02-22 08:53:55
    文章目录面向对象类与对象匿名对象创建对象的内存分析栈(stack)堆(heap)方法区PC寄存器本地方法栈内部类成员内部类局部内部类匿名内部类静态内部类包装类拆箱和装箱操作字符串转换基本数据类型和包装类型的区别...
  • 如何学习微信小程序? 学习微信小程序所需基础

    万次阅读 多人点赞 2020-03-30 16:23:19
    说的通俗一些,微信小程序就是微信中非常小巧的程序(这不废话......),我们打开自己手机中的微信,向下一拉,就可以看到小程序列表了。比如“腾讯QQ”这个小程序,我们可以利用它,接收QQ的消息;再入“跳一跳”,...
  • 万字长文深度剖析面向对象的javascript

    万次阅读 热门讨论 2020-12-02 09:46:56
    本将会深入讲解面向对象在javascript中的应用,并详细介绍三种对象的生成方式:构造函数,原型链,类。
  • 在传统的软件开发过程中多采用结构化技术完成软件开发的一系列工作,但这种方法并不适应发型软件产品的开发,而随着硬件发展,对于大型软件产品的需求又逐步提高,于是面向对象方法就应运而生。面向对象方法在上世纪...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 203,155
精华内容 81,262
关键字:

发展对象之后的程序