精华内容
下载资源
问答
  • ServletConfig对象与ServletContext区别

    千次阅读 多人点赞 2017-05-03 17:58:43
    在编写servlet过程中,需要用到 ServletConfig、ServletContext对象,对这两种对象的介绍如下: ServletContext对象:servlet容器在启动时会加载web应用,并为每个web应用创建唯一的servlet context对象,可以把...

    在编写servlet过程中,需要用到 ServletConfig、ServletContext对象,对这两种对象的介绍如下:

    ServletContext对象:servlet容器在启动时会加载web应用,并为每个web应用创建唯一的servlet context对象,可以把ServletContext看成是一个Web应用的服务器端组件的共享内存,在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象,凡是web容器中的Servlet都可以访问。

    servletConfig对象:用于封装servlet的配置信息。从一个servlet被实例化后,对任何客户端在任何时候访问有效,但仅对servlet自身有效,一个servlet的ServletConfig对象不能被另一个servlet访问。

    在servlet中如何获取ServletContext对象和ServletConfig对象,请看下面代码:

    [java] view plain copy
    1. import javax.servlet.ServletConfig;  
    2. import javax.servlet.ServletException;  
    3. import javax.servlet.ServletRequest;  
    4. import javax.servlet.ServletResponse;  
    5. import javax.servlet.http.HttpServlet;  
    6.   
    7. public class Servlet1 extends HttpServlet{  
    8.   
    9.     @Override  
    10.     public void init() throws ServletException  
    11.     {  
    12.         ServletConfig config = this.getServletConfig();  
    13.         System.out.println("Servlet1 config=="+config);  
    14.         System.out.println("Servlet1 间接获取context==" +config.getServletContext() );  
    15.         System.out.println("Servlet1 直接获取context==" + this.getServletContext());  
    16.         System.out.println("Servlet1 param_value==" + config.getInitParameter("servlet1_param_name"));  
    17.         System.out.println("context_value==" + this.getServletContext().getInitParameter("context_param"));  
    18.         System.out.println("*********************************");  
    19.     }  
    20.       
    21.     @Override  
    22.     public void service(ServletRequest req, ServletResponse resp)  
    23.             throws ServletException{  
    24.           
    25.     }  
    26.       
    27.     @Override  
    28.     public void destroy() {  
    29.       
    30.     }  
    31. }  


    Servlet2的代码:

    [java] view plain copy
    1. import javax.servlet.ServletConfig;  
    2. import javax.servlet.ServletException;  
    3. import javax.servlet.ServletRequest;  
    4. import javax.servlet.ServletResponse;  
    5. import javax.servlet.http.HttpServlet;  
    6.   
    7. public class Servlet2 extends HttpServlet {  
    8.     @Override  
    9.     public void init() throws ServletException  
    10.     {  
    11.         ServletConfig config = this.getServletConfig();  
    12.         System.out.println("Servlet2 config=="+config);  
    13.         System.out.println("Servlet2 间接获取context==" +config.getServletContext());  
    14.         System.out.println("Servlet2 直接获取context==" + this.getServletContext());  
    15.         System.out.println("Servlet2 param_value==" + config.getInitParameter("servlet2_param_name"));  
    16.         System.out.println("context_value==" + this.getServletContext().getInitParameter("context_param"));  
    17.         System.out.println("*********************************");  
    18.     }  
    19.       
    20.     @Override  
    21.     public void service(ServletRequest req, ServletResponse resp)  
    22.             throws ServletException{  
    23.           
    24.     }  
    25.       
    26.     @Override  
    27.     public void destroy() {  
    28.       
    29.     }  
    30. }  

    web.xml文件的配置:

    [html] view plain copy
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <web-app version="2.4"   
    3.     xmlns="http://java.sun.com/xml/ns/j2ee"   
    4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    5.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   
    6.     http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
    7.   <servlet>  
    8.     <servlet-name>servlet_1</servlet-name>  
    9.     <servlet-class>com.test.servlet.Servlet1</servlet-class>  
    10.     <init-param>  
    11.        <param-name>servlet1_param_name</param-name>  
    12.        <param-value>value1</param-value>  
    13.     </init-param>  
    14.     <load-on-startup>1</load-on-startup>  
    15.   </servlet>  
    16.   <servlet>  
    17.     <servlet-name>servlet_2</servlet-name>  
    18.     <servlet-class>com.test.servlet.Servlet2</servlet-class>  
    19.     <init-param>  
    20.        <param-name>servlet2_param_name</param-name>  
    21.        <param-value>value2</param-value>  
    22.     </init-param>  
    23.     <load-on-startup>0</load-on-startup>  
    24.   </servlet>  
    25.   <context-param>  
    26.      <param-name>context_param</param-name>  
    27.      <param-value>value3</param-value>  
    28.   </context-param>  
    29.   <welcome-file-list>  
    30.     <welcome-file>index.jsp</welcome-file>  
    31.   </welcome-file-list>  
    32. </web-app>  

    部署到tomcat中,然后启动服务,在控制台打印出如下信息:


    Servlet2 config==org.apache.catalina.core.StandardWrapperFacade@13d422d
    Servlet2 间接获取context==org.apache.catalina.core.ApplicationContextFacade@1123c5f
    Servlet2 直接获取context==org.apache.catalina.core.ApplicationContextFacade@1123c5f
    Servlet2 param_value==value2
    context_value==value3
    *********************************
    Servlet1 config==org.apache.catalina.core.StandardWrapperFacade@14683c0
    Servlet1 间接获取context==org.apache.catalina.core.ApplicationContextFacade@1123c5f
    Servlet1 直接获取context==org.apache.catalina.core.ApplicationContextFacade@1123c5f
    Servlet1 param_value==value1
    context_value==value3
    *********************************

    通过控制台打印的信息可以得出如下结论:

    1、在web.xml配置文件中,对没个servlet的配置里,有一项<load-on-startup></load-on-startup>,它的含义是:标记容器是否在启动的时候就加载这个servlet。当值为0或者大于0时,表示容器在应用启动时就加载这个servlet;当是一个负数时或者没有指定时,则指示容器在该servlet被选择时才加载。正数的值越小,启动该servlet的优先级越高。

    servlet_2虽然配置在servlet_1后面,但是它的load-on-startup为0,启动的优先级高于servlet_1,所以servlet_2先启动。

    2、获取ServletContext的两种方式,直接获取和间接获取,得到的对象都是同一个。同时在servlet1和servlet2中取得的ServletContext对象都是同一个对象,说明整个web应用都只有一个唯一的ServletContext实例;

    3、servlet1与servlet2的serveletConfig对象是不一样的,说明ServletConfig对象的作用范围仅在servlet中。

    一.ServletConfig和ServletContext

    1.它们的作用和区别

    1)作用

    • 可以从web.xml中读取数据,给Servlet使用

    它们都能够给Servlet预置参数

    2)区别

    • config和Servlet是1对1的关系
    • context和Servlet是1对多的关系

    Tomcat会保障它们和Servlet的关系


    2.ServletConfig

    1)场景介绍

    • 假设开发一个网页游戏
    • 如果在线人数达到最大值时,新登录的人需要排队
    • 需要开发登录功能LoginServlet
    • 在此Servlet内要获取在线人数最大值并加以判断
    • 最大值maxonline要求可以配置

    2)实现方式

    • 将参数配置到web.xml内
    • 该参数只给登录功能LoginServlet使用,使用config读取

    3.ServletContext

    1)场景介绍

    • 项目通常都有很多查询功能,几乎每个查询都支持分页
    • 分页的已知条件: 页码page, 每页显示行数size
    • size要求可以配置,便于系统上线时实施人员去修改

    2)实现方式

    • 配置到web.xml中
    • 因为多个功能都要使用该参数,所以使用context来读取它

    4.ServletContext的特殊用途

    1)特殊用途

    • config和context典型的用途是读取web.xml中的常量(看2,3)
    • 特殊用途:context还可以读写变量
    • 用该对象读写的变量是可以被所有servlet共用的
    • setAttribute()/getAttribute()

    2)场景介绍

    • 要统计软件的流量(访问量/访问人次)
    • 任何人访问软件的任何功能,则流量+1

    3)实现方式


    案例一:ServletConfig的使用

    package web;
    
    import java.io.IOException;
    
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class LoginServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    	
    	/***
    	 * Tomcat创建servlet的逻辑:new之后,调用init()之前创建ServletConfig对象
    	 * LoginServlet s = new LoginServlet();
    	 * ServletConfig config = new ServletConfig();
    	 * 将web.xml中的数据加载到对象中
    	 * s.init(config);
    	 */
    	
    	@Override
    	public void init(ServletConfig config) throws ServletException {
    		super.init(config);
    		String maxOnline = config.getInitParameter("maxOnline");
    		System.out.println(maxOnline);
    	}
    
    	//模拟登陆
    	@Override
    	protected void service(HttpServletRequest req, HttpServletResponse res) 
    			throws ServletException, IOException {
    		//此config就是init()方法传入的那个
    		ServletConfig config = getServletConfig();
    		String maxOnline = config.getInitParameter("maxOnline");
    		System.out.println(maxOnline);
    		System.out.println("正在登录...");
    	}
    
    }
    

    配置文件:

    <!-- LoginServlet案例(ServletConfig) -->
      <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>web.LoginServlet</servlet-class>
        <!-- 给此Servlet预置参数 -->
        <init-param>
          <param-name>maxOnline</param-name>
          <param-value>3000</param-value>
        </init-param>
      </servlet>
      <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
      </servlet-mapping>

    访问一次该servlet输出结果:

    3000

    3000

    正在登录...

    =======================================================================

    案例二:ServletContext的使用

    package web;
    
    import java.io.IOException;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class findDeptServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
    	@Override
    	protected void service(HttpServletRequest req, HttpServletResponse res) 
    			throws ServletException, IOException {
    		/**
    		 * tomcat启动时就会创建唯一的context
    		 * 并且会调用他的方法加载web.xml中的公用参数,任何servlet都可以使用
    		 */
    		ServletContext context = getServletContext();
    		String size = context.getInitParameter("size");
    		System.out.println("分页查询部门数据:"+size);
    	}
    }
    
    package web;
    
    import java.io.IOException;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class findEmpServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
    	@Override
    	protected void service(HttpServletRequest req, HttpServletResponse res) 
    			throws ServletException, IOException {
    		/**
    		 * tomcat启动时就会创建唯一的context
    		 * 并且会调用他的方法加载web.xml中的公用参数,任何servlet都可以使用
    		 */
    		
    		ServletContext context = getServletContext();
    		String size = context.getInitParameter("size");
    		System.out.println("分页查询员工数据:"+size);
    	}
    
    	
    }

    配置文件:

    <!-- (ServletCotext全局) 可以通过ServletContext读取该参数-->
      <context-param>
        <param-name>size</param-name>
        <param-value>20</param-value>
      </context-param>
    
      <!-- findDeptServlet和案例findEServlet -->
      <servlet>
        <servlet-name>findDept</servlet-name>
        <servlet-class>web.findDeptServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>findDept</servlet-name>
        <url-pattern>/findDept</url-pattern>
      </servlet-mapping>
      <servlet>
        <servlet-name>findEmp</servlet-name>
        <servlet-class>web.findEmpServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>findEmp</servlet-name>
        <url-pattern>/findEmp</url-pattern>
      </servlet-mapping>

    分别访问servlet一次输出结果:

    分页查询部门数据:20
    分页查询员工数据:20

    =============================================================
    案例三:ServletContext的特殊使用,访问变量,将变量存入ServletContext,其他servlet都可使用
    一般一般WEB项目中都有1-2个这样的Servlet
    package web;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    
    public class InitServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
    	/**
    	 * 该Servlet不负责处理具体的业务,只用来在Tomcat启动时初始化数据
    	 * 一般WEB项目中都有1-2个这样的Servlet
    	 * init()或init(ServletConfig config)两种方法都可以
    	 */
    	@Override
    	public void init() throws ServletException {
    		super.init();
    		ServletContext context = getServletContext();
    		//将数据保存在context对象中,默认访问量为0
    		context.setAttribute("count", 0);
    	}
    }
    

    在findDeptServlet和findEmpServlet中添加如下代码:

    //统计访问量
    Integer count = (Integer)context.getAttribute("count");
    //更新count,重新写入ServletContext
    context.setAttribute("count", ++count);
    System.out.println("当前访问量:"+count);
    配置文件如下:

    <!-- InitServlet案例 servlet-mapping可以不写 -->
      <servlet>
        <servlet-name>init</servlet-name>
        <servlet-class>web.InitServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
      </servlet>
    分别访问findDeptServlet和findEmpServlet多次输出结果:
    分页查询员工数据:20
    当前访问量:1
    分页查询员工数据:20
    当前访问量:2
    分页查询部门数据:20
    当前访问量:3
    分页查询员工数据:20
    当前访问量:4
    分页查询部门数据:20
    当前访问量:5
    总结:
    1.当需要给Servlet预置参数时使用这样的对象
    2.若参数只给一个Servlet使用,用ServletConfig
    3.若参数只给多个Servlet使用,用ServletContext




    展开全文
  • 面向对象与基于对象区别

    千次阅读 2016-01-23 16:42:49
    面向对象和基于对象区别是多态,和继承无关。  基于对象仅仅支持了抽象数据类型的功能,继承也不过体现了一种is-a的关系,也是抽象数据类型,只是建立了一个层次体系。但是什么是面向对象呢?就是根 据对象的...
      面向对象和基于对象的区别是多态,和继承无关。   
    基于对象仅仅支持了抽象数据类型的功能,继承也不过体现了一种is-a的关系,也是抽象数据类型,只是建立了一个层次体系。但是什么是面向对象呢?就是根 据对象的实际类型不同,可以自动完成不同的行为,而仅仅通过一致的调用形式。换句话说,也就是虚函数实现的多态。以上观点,在OO设计中已经得到了公认, 多态的另一种实现方法是泛型。

     

    “面向对象”和“基于对象”两个不同的概念。面向对象的三大特点(封装,继承,多态)却一不可,通常“基于对象”使用对象,但是无法利用现有的对象模板产生新的对象类型,继而产生新的对象,也就是说“基于对象”没有继承的特点,而“多态”是表示为父类类型的子类对象实例,没有了继承的概念也就无从谈论“多态”。现在的很多流行技术都是基于对象的,它们使用一些封装好的对象,调用对象的方法, 设置对象的属性。但是它们无法让程序员派生新对象类型。他们只能使用现有对象的方法和属性。所以当你判断一个新的技术是否是面向对象的时候,通常可以使用 后两个特性来加以判断。“面向对象”和“基于对象”都实现了“封装”的概念,但是面向对象实现了“继承和多态”,而“基于对象”没有实现这些,的确很饶 口。


    从事面向对象编程的人按照分工来说,可以分为“类库的创建者”和“类库的使用者”。使用类库的人并不都是具备了面向对象思想的人,通常知道如何继承和派生新对象就可以使用类库了,然而我们的思维并没有真正的转过来,使用类库只是在形式上是面向对象,而实质上只是库函数的一种扩展。面向对象是一种思想,是我们考虑事情的方法,通常表现为我们是将问题的解决按照过程方式来解决呢,还是将问题抽象为一个对象来解决它。很多情况下,我们会不知不觉的按照过程方式来解决它,而不是考虑将要解决问题抽象为对象去解决它。


    面向对象主要有几个特性,封装、继承、多态。没有封装就不能继承,没有继承就没有运行时的多态。基于对象并不是单独的理论,而是面向对象的初级阶段,就是只有封装。只能是把属性、方法放进类中,实例化对象调用。学习面向对象要从基础知识入手,学会定义类、接口的定义、继承。然后要深入细致的研究现实事物,把现实事物或是需求文档中的名词抽象出来生成类或属性,如果是主语,多半还要根据整句的描述生成方法,定义类结构。之所以叫抽象,是因为定义类成员时要忽略掉系统不需要的其它东西。慢慢你就发现原来写程序要不停的增删代码和重构。

                    转自:http://blog.sina.com.cn/s/blog_4ca200e20100hstp.html

    展开全文
  • 对象与对象引用变量的区别

    千次阅读 2015-02-08 18:47:24
    为便于说明,我们先定义一个简单的类:  class Vehicle {  int passengers;  int fuelcap;... 通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作。  1)右边的“new Vehicl

    为便于说明,我们先定义一个简单的类:
      class Vehicle {
      int passengers;
      int fuelcap;
      int mpg;
      }
      有了这个模板,就可以用它来创建对象:
      Vehicle veh1 = new Vehicle();
      通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作。
      1)右边的“new Vehicle”,是以Vehicle类为模板,在堆空间里创建一个Vehicle类对象(也简称为Vehicle对象)。
      2)末尾的()意味着,在对象创建后,立即调用Vehicle类的构造函数,对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写,Java会给你补上一个默认的构造函数。
      3)左边的“Vehicle veh1”创建了一个Vehicle类引用变量。所谓Vehicle类引用,就是以后可以用来指向Vehicle对象的对象引用。
      4)“=”操作符使对象引用指向刚创建的那个Vehicle对象。
      我们可以把这条语句拆成两部分:
      Vehicle veh1;
      veh1 = new Vehicle();
      效果是一样的。这样写,就比较清楚了,有两个实体:一是对象引用变量,一是对象本身。
      在堆空间里创建的实体,与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。不仅如此,我们仔细研究一下第二句,找找刚创建的对象叫什么名字?有人说,它叫“Vehicle”。不对,“Vehicle”是类(对象的创建模板)的名字。一个Vehicle类可以据此创建出无数个对象,这些对象不可能全叫“Vehicle”。
      对象连名都没有,没法直接访问它。我们只能通过对象引用来间接访问对象。
      为了形象地说明对象、引用及它们之间的关系,可以做一个或许不很妥当的比喻。对象好比是一只很大的气球,大到我们抓不住它。引用变量是一根绳,可以用来系汽球。
      如果只执行了第一条语句,还没执行第二条,此时创建的引用变量veh1还没指向任何一个对象,它的值是null。引用变量可以指向某个对象,或者为null。它是一根绳,一根还没有系上任何一个汽球的绳。执行了第二句后,一只新汽球做出来了,并被系在veh1这根绳上。我们抓住这根绳,就等于抓住了那只汽球。
      再来一句:
      Vehicle veh2;
      就又做了一根绳,还没系上汽球。如果再加一句:
      veh2 = veh1;
      系上了。这里,发生了复制行为。但是,要说明的是,对象本身并没有被复制,被复制的只是对象引用。结果是,veh2也指向了veh1所指向的对象。两根绳系的是同一只汽球。
      如果用下句再创建一个对象:
      veh2 = new Vehicle();
      则引用变量veh2改指向第二个对象。
      从以上叙述再推演下去,我们可以获得以下结论:(1)一个对象引用可以指向0个或1个对象(一根绳子可以不系汽球,也可以系一个汽球);(2)一个对象可以有N个引用指向它(可以有N条绳子系住一个汽球)。
      如果再来下面语句:
      veh1 = veh2;
      按上面的推断,veh1也指向了第二个对象。这个没问题。问题是第一个对象呢?没有一条绳子系住它,它飞了。多数书里说,它被Java的垃圾回收机制回收了。这不确切。正确地说,它已成为垃圾回收机制的处理对象。至于什么时候真正被回收,那要看垃圾回收机制的心情了。
      由此看来,下面的语句应该不合法吧?至少是没用的吧?
      new Vehicle();
      不对。它是合法的,而且可用的。譬如,如果我们仅仅为了打印而生成一个对象,就不需要用引用变量来系住它。最常见的就是打印字符串:
      System.out.println(“I am Java!”);
      字符串对象“I am Java!”在打印后即被丢弃。有人把这种对象称之为临时对象。

    展开全文
  • 面向对象与面向过程的区别

    千次阅读 多人点赞 2016-04-10 10:54:04
    首先一个问题就是类与对象,那么我们就必须要理解面向对象和面向过程的区别,经过查阅资料以及网上很多大神们的讲解,我小小总结一下,我喜欢用实例来讲解,所以比较的时候多以实例为主: 1.面向对象和面向过程的...

    学习C++一般都会思考这个问题,c++里的++到底比C语言多了什么东西,有什么不一样呢??

    首先一个问题就是类与对象,那么我们就必须要理解面向对象和面向过程的区别,经过查阅资料以及网上很多大神们的讲解,我小小总结一下,我喜欢用实例来讲解,所以比较的时候多以实例为主:

    1.面向对象和面向过程的区别:

    面向过程:procedure oriented programming POP
    面向对象:object oriented programming OOP


    个人理解:一个博大,一个精深;一个是面向运行阶段,一个是面向编译阶段:
    博大:面向对象的博大,将某一类事物的共同属性进行抽象,将其所有的属性,行为按功能集合;
    精深:面向过程,思考到事物发展的每一步,细如发丝,考虑到任何一种可能发生的情况,一步步的执行,判断,直至事物的结束(深邃);
    面向过程:就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步的实现,使用的时候一个个调用就可以了;
    面向对象:是把事物分解成不同的对象,建立对象的目的不是完成某一个步骤,而是为了描述某个事物在整个解决问题的步骤中的行为;


    艾兰.库伯的《软件创新之路》中提到:

    面向过程和面向对象的区别并不像人们想象得那么大,面向对象的大部分思想在面向过程中也能体现
    面向过程最大的问题(也许是唯一先天的缺陷)在于随着系统的膨胀,面向过程将无法应付,最终导致系统的崩溃
    面向对象的提出正是试图解决这一软件危机

    目前看来,似乎有一定成效
    但仍任重道远


    例如设计一个象棋:面向过程的思路就是首先分析问题的步骤:
    1.开始游戏;
    2.黑子先走;
    3.绘制棋盘画面;
    4.判断输赢;
    5.白子走;
    6.绘制棋盘;
    7.判断输赢;
    8.返回到步骤2;
    9.输出最后的结果;
    就这样一步步的实现,问题就解决了;


    而面向对象则是从另外一个思路来设计解决问题:
    1.玩家系统:黑白ABCD都是玩家,所以属性,步骤功能一样;
    2.绘制棋盘系统;
    3.规则系统:决定哪个先走,判断输赢等操作;
    可以看出面向对象是以功能来划分,而不是步骤,黑子落棋后通知白棋棋盘发生变化,绘制棋盘系统就开始把变化绘制出来,规则系统则判定结果;赢了则返回,否则由白字继续走;


    如果要加一个悔棋功能,面向过程则需要改动很多地方,黑子撤回棋,棋盘变化,然后载绘制,再判断,可能很多要变化;随着功能的越来越多,系统无法应付功能需求的规则的复杂而膨胀,最终导致奔溃;但是面向对象只需要得到悔棋命令后,绘制棋盘系统将棋盘重新绘制,调用规则系统判定即可,减少了大的改动;保证了面向对象程序的可扩展性;


    又如汽车:
    面向过程:
    1.打开车门,关车门,插入钥匙点火,踩离合挂一档,松手刹,慢抬离合给油门,打方向。。。这样车才会行驶,每个步骤都是一个函数,函数的调用顺序就决定了程序运行的顺序;前面是宝马,再来一辆奔驰,又要来一遍,写很多,如果中途要放个歌曲,又的在某个位置加上一个函数,修改程序;最重要的是函数;
    面向对象:
    则是以汽车为对象,上面一系列的功能都是汽车有的,要做什么事儿,告诉汽车就行了;来辆奔驰,创建个奔驰对象,改变一个车型,告诉汽车怎么做,就可以了,不用一步步的用函数实现了;
    但是面向对象也是一个个过程组合起来的,具有封装性;所以它需要很大的空间;


    当然,要达到局部改动就可以完成功能而不影响大局的编程需要经验机器丰富的编程人员,设计分块合理,使用对象不能保证你的程序就是面向对象的,初学者很多程序员可能以面向对象之虚而行面向过程之实。这样设计出的程序的可移植性和扩展性就有一定的问题;

    例如:对人这类这种高级动物:
    如果面向对象:你只需要吃饭,跑步,睡觉几个命令即可;
    面向过程:做饭,拿筷子,夹菜,夹饭,嚼,咽、、、一步步的写相应的函数,一个一个调用实现功能;顺序的向下做;
    但是:对象是由一个个过程组合起来的;具有封装性;稍微重要的说两遍!因为他们并不是完全独立的!没有关系!




    展开全文
  • 对象引用与对象区别

    千次阅读 2013-01-10 10:59:15
    可是,如果我分不清对象与对象引用,那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。  为便于说明,我们先定义一个简单的类:  class Vehicle { int...
  • C#--对象与区别

    热门讨论 2018-05-21 17:44:15
    (里面的赵老师,张三,但是不是对象) 属性: 一个的特征,可以理解成这个的属性 (名字,性别) 方法:一个的行为可以理解成方法(吃饭,睡觉,上课) 属性值:描述这个特征的值: 比如说颜色为属性,...
  • Foundation对象是Objective-C对象,而Core ...这里说一下两者在iOS中的内存管理问题,以前在MRC情况下,都是开发人员手动管理对象内存,二者区别不大。但在ARC情况下,由于Foundation框架是OC对象,所以由系统自动管...
  • 返回vector对象与引用的区别

    千次阅读 2018-11-12 18:44:59
    返回vector对象与引用的区别
  • java类与对象区别

    千次阅读 2014-09-30 15:25:23
    类和对象区别
  • 而且,现在大量的java学习书籍都将对象以及对象的引用混为一谈,然而实际上它们有着本质的区别。为了帮助更多的java学习者更好的理解,我将自己的学习理解记录下来。今天我们就来一起了解一下对象对象引用之间的...
  • 面向过程编程和面向对象编程的步骤、特性与区别? ** 面向过程编程和面向对象编程的区别 ** 面向过程编程: 分析出解决问题所需要的步骤,然后用函数把这些步骤一步步实现,使用的时候再一个个的依次调用即可。 优点...
  • java面向对象与面向过程的区别

    千次阅读 2018-01-02 16:58:07
    java面向对象与面向过程的区别
  • Java中类与对象的关系与区别

    千次阅读 2018-04-12 12:43:59
    对象就是一个真实世界中的实体,对象与实体是一一对应关系的,意思就是现实世界的每一个实体都是一个对象,所以对象是一个具体的概念。类是对象的一个集合,对象是类的实例。而对象的产生在Java中是使用new来实现的...
  • 作为一个在电商行业混迹多年的产品经理,对面向对象的理解一直模棱两可,有的时候觉得自己知道什么是面向对象,有的时候又说不出来,经过这几天的整理思考,把对面向对象与面向过程的思考给大家分享下: 首先,我们...
  • 面向对象和基于对象区别

    热门讨论 2017-10-07 15:59:25
    面向对象和基于对象区别  很多没有区分“面向对象”和“基于对象”两个不同的概念。面向对象的三大特点(封装,继承,多态)缺一不可。通常“基于对象”是使用对象,但是无法利用现有的对象模板产生新的对象...
  • JSONJS对象区别

    千次阅读 2017-02-08 11:56:28
    总是感觉json对象(其实json不是对象)和js对象的字面量表示法相同,最近学习json,真心搞不懂,js对象和json有什么区别?!就是感觉json的key要用” “括起来,但是js对象的字面量表示法不需要。   比如://js对象...
  • C/C++面向过程面向对象区别

    千次阅读 2019-03-18 22:18:04
    C++是面向对象的(object oriented programming—OOP)。强调对象,由对象实施动作。 C是面向过程的(procedure oriented programming—POP)。强调执行的过程。 总结起来就是: 面向对象是首先抽象出各种对象...
  • 类,对象,方法函数的区别

    千次阅读 多人点赞 2019-03-11 19:37:30
    面向对象编程将数据和操作数据相关的方法封装到对象中,组织代码和数据的方式更加接近的思维,使程序的扩展性更强、可读性更好,从而大大提高了编程的效率。    Python 完全采用了面向对象的思想,是真正面向...
  • 可变对象 不可变对象我们知道在python中一切皆对象。在python世界中可以把对象大体分成两大类:不可变对象:数字(int,float, double)、字符串、元组(tuple)、function等可变对象:字典(dict)、列表(list)...
  • Java中类与对象的概念区别

    千次阅读 2014-08-26 23:29:52
    Java是一种面向对象的程序设计语言(Object Oriented Programming:OOP),面向对象的程序设计语言中有类和对象的概念,它们在概念上有什么区别呢?  这往往是一个令面向对象的初学者感到迷惑的问题。    下面...
  • 可是,如果我分不清对象与对象引用,那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。 为便于说明,我们先定义一个简单的类: class Vehicle { int ...
  • 与对象区别

    万次阅读 多人点赞 2018-08-13 09:35:36
    对于初学者来说,类与对象之间的关系的非常模糊不清的,在这里跟大家分享一下,让初学者有所帮助。   一、类的概念: 类是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述,其...
  • 面向过程面向对象区别

    千次阅读 2017-07-18 19:54:04
    面向过程面向对象区别一直对面向对象面向过程只是一个模糊大众化的理解,查看了一些文档,也引用了一些内容 整理了下 记录自己的理解依旧是引用了经典的蛋炒饭和盖浇饭的例子,我仔细的分析了下,和网上看的可能会...
  • 对象与引用对象

    千次阅读 2014-06-03 22:16:43
    概念介绍 对象与对象引用
  • 面向过程面向对象的本质区别思考

    万次阅读 多人点赞 2013-05-25 20:31:55
     不久前有在面试的时候被问及面向对象和面向过程的本质区别是什么?对于这个问题小生  也没有做过多的思考,今天在此做一个总结,探求一些面向对象和面向过程本质的区别在哪里。  简单对比  面向过程就像是...
  • 对象用&传递参数和对象用作普通参数传递其实就是 引用传递
  • 文字池(pool of literal strings)和堆(heap)中的字符串对象。  A aa;  这个语句声明一个类A的引用变量aa[我们常常称之为句柄],而对象一般通过new创建。所以题目中s仅仅是一个引用变量,它不是对象。  二...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 711,837
精华内容 284,734
关键字:

对象与人员的区别