精华内容
下载资源
问答
  • 面向对象有一个法则: 信息隐藏 --类的成员属性,私有的private --类的方法公有public的,通过方法修改成员属性的值 打个比方:朋友在熟悉,也不会到他抽屉直接拿东西,而是通过他的公开接口(公开方法)来...

    信息隐藏原则(1):

    面向对象有一个法则: 信息隐藏

    --类的成员属性,是私有的private

    --类的方法是公有public的,通过方法修改成员属性的值

    打个比方:朋友在熟悉,也不会到他抽屉直接拿东西,而是通过他的公开接口(公开方法)来访问、修改东西。

    信息隐藏原则(2):

    所谓信息隐藏:通过类的方法来间接访问类的属性,而不是直接访问类的属性。

    信息隐藏原则(3):

    --类成员是私有private的

    --get和set方法是公有public的,统称为getter和setter

    --外界对类成员的操作只能通过get和set方法

    --可以用Java  IDE(Eclipse)快速生成

    this(1):

    --this负责指向本类中的成员变量

    --this负责指向本类中的成员方法

    如 this.add(5, 3);  // 调用本类的add方法,this可以忽略(在不影响歧义的情况下)

    --this可以代替本类中的构造函数

    如this(5);  // 调用本类的一个形参的构造函数

     

    展开全文
  • JSP隐藏对象

    千次阅读 2013-08-26 15:23:46
    隐藏对象outjavax.servlet.jsp.JspWriter类的实例。服务器向客户端输出的字符类内容可以通过out对象输出。 2.request 请求对象 隐藏对象requestjavax.servlet.ServletRequest类的实例。代表客户端的请求。...

    1.out输出流对象

    隐藏对象out是javax.servlet.jsp.JspWriter类的实例。服务器向客户端输出的字符类内容可以通过out对象输出。


    2.request 请求对象

    隐藏对象request是javax.servlet.ServletRequest类的实例。代表客户端的请求。request包含客户端的信息以及请求的信息,如请求哪个文件,附带的地址栏参数等。每次客户端请求都会产生一个request实例。


    3.response 响应对象

    隐藏对象response是javax.servlet.ServletResponse类的实例,代表服务器端的响应。服务器端的任何输出都是通过response对象发送到客户端浏览器。每次服务器端都会产生一个response实例。


    4.config 配置对象

    隐藏对象config是javax.servlet.ServletConfig类的实例,ServletConfig封装了配置在web.xml中初始化JSP的参数。JSP中通过config获取这些参数。每个JSP文件都有一个config对象。


    5.session 会话对象

    隐藏对象session是javax.servlet.http.HttpSession类的实例。session与cookie是记录客户访问信息的两种机制,session用于服务器端保存用户信息,cookie用于客户端保存用户信息。Servlet通过request.getSession()获取session对象,而在JSP中可以直接使用。如果JSP中配置了<%@ page session="false" %>,则隐藏对象session不可用。每个用户对应一个session对象。


    6.application 应用程序对象

    隐藏对象application是javax.servlet.ServletContext类的对象。application封装了JSP所在的Web应用程序的信息,例如web.xml中配置的全局的初始化信息。Servlet中application对象通过ServletConfig.getServletContext()来获取。整个Web应用程序对应一个application对象。


    7.page 页面对象

    隐藏对象page为javax.servlet.jsp.HttpJspPage类的实例,page对象代表当前JSP页面,是当前JSP编译后的Servlet类的对象。page相当于普通java类中的关键字this。


    8.pageContext 页面上下文对象

    隐藏对象pageContext为javax.servlet.jsp.PageContext类的实例。pageContext对象代表当前JSP页面编译后的内容。通过pageContext能够获取到JSP中的资源。


    9.exception 异常对象

    隐藏对象exception为java.lang.Exception类的对象。exception封装了JSP中抛出的异常信息。要使用exception对象,需要设置<%@ page isErrorPage="true" %>。隐藏对象exception通常被用来处理错误页面。

    展开全文
  • 在"初识Javascript"章节中,提到通过作用域和闭包来隐藏内部细节,并给外部提供访问接口,就初次接触到了信息隐藏的概念了。同时,我们知道在面向对象的高级语言中,创建包含私有成员的对象最基本的特性之一,提供...

    在"初识Javascript"章节中,提到通过作用域和闭包来隐藏内部细节,并给外部提供访问接口,就初次接触到了信息隐藏的概念了。同时,我们知道在面向对象的高级语言中,创建包含私有成员的对象是最基本的特性之一,提供属性和方法对私有成员进行访问来隐藏内部的细节。虽然JS也是面向对象的,但没有内部机制可以直接表明一个成员是公有还是私有的。还是那句话,依靠JS的语言灵活性,我们可以创建公共、私有和特权成员,信息隐藏是我们要实现的目标,而封装是我们实现这个目标的方法。我们还是从一个示例来说明:创建一个类来存储图书数据,并实现可以在网页中显示这些数据。

    1. 最简单的是完全暴露对象。使用构造函数创建一个类,其中所有的属性和方法在外部都是可以访问的。

    var Book = function(isbn, title, author) {
    if(isbn == undefined) {
    throw new Error("Book constructor requires a isbn.");
    }
    this.isbn = isbn;
    this.title = title || "";
    this.author = author || "";
    }
    Book.prototype.display = function() {
    return "Book: ISBN: " + this.isbn + ",Title: " + this.title + ",Author: " + this.author;
    }

    display方法依赖于isbn是否正确,如果不是你将无法获取图像以及链接。考虑到这点,每本图书isbn必须存在的,而图书的标题和作者是可选的。表面上看只要指定一个isbn参数似乎就能正常运行。但却不能保证isbn的完整性,基于此我们加入isbn的验证,使图书的检查更加健壮。

    var Book = function(isbn, title, author) {
    if(!this.checkIsbn(isbn)) {
    throw new Error("Book: invalid ISBN.");
    }
    this.isbn = isbn;
    this.title = title || "";
    this.author = author || "";
    }
    Book.prototype = {
    checkIsbn: function(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    },
    display: function() {
    return "Book: ISBN: " + this.isbn + ",Title: " + this.title + ",Author: " + this.author;
    }
    };

    我们添加了checkIsbn()来验证ISBN的有效性,确保display()可以正常运行。但是需求有变化了,每本书可能有多个版本,意味着同一本可能有多个ISBN号存在,需要维护单独的选择版本的算法来控制。同时尽管能检查数据的完整性,但却无法控制外部对内部成员的访问(如对isbn,title,author赋值),就谈不上保护内部数据了。我们继续改进这个方案,采用接口实现(提供get访问器/set存储器)。

    var Publication = new Interface("Publication", ["getIsbn", "setIsbn", "checkIsbn", "getTitle", "setTitle", "getAuthor", "setAuthor", "display"]);
    var Book = function(isbn, title, author) {
    // implements Publication interface
    this.setIsbn(isbn);
    this.setTitle(title);
    this.setAuthor(author);
    }
    Book.prototype = {
    getIsbn: function() {
    return this.isbn;
    },
    setIsbn: function(isbn) {
    if(!this.checkIsbn(isbn)) {
    throw new Error("Book: Invalid ISBN.");
    }
    this.isbn = isbn;
    },
    checkIsbn: function(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    },
    getTitle: function() {
    return this.title;
    },
    setTitle: function(title) {
    this.title = title || "";
    },
    getAuthor: function() {
    return this.author;
    },
    setAuthor: function(author) {
    this.author = author || "";
    },
    display: function() {
    return "Book: ISBN: " + this.isbn + ",Title: " + this.title + ",Author: " + this.author;
    }
    };

    现在就可以通过接口Publication来与外界进行通信。赋值方法也在构造器内部完成,不需要实现两次同样的验证,看似非常完美的完全暴露对象方案了。虽然能通过set存储器来设置属性,但这些属性仍然是公有的,可以直接赋值。但此方案到此已经无能为力了,我会在第二种信息隐藏解决方案中来优化。尽管如此,此方案对于那些没有深刻理解作用域的新手非常容易上手。唯一的不足是不能保护内部数据且存储器增加了多余的不必要代码。
    2. 使用命名规则的私有方法。就是使用下划线来标识私有成员,避免无意中对私有成员进行赋值,本质上与完全暴露对象是一样的。但这却避免了第一种方案无意对私有成员进行赋值操作,却依然不能避免有意对私有成员进行设置。只是说定义了一种命名规范,需要团队成员来遵守,不算是一种真正的内部信息隐藏的完美方案。

    var Publication = new Interface("Publication", ["getIsbn", "setIsbn", "getTitle", "setTitle", "getAuthor", "setAuthor", "display"]);
    var Book = function(isbn, title, author) {
    // implements Publication interface
    this.setIsbn(isbn);
    this.setTitle(title);
    this.setAuthor(author);
    }
    Book.prototype = {
    getIsbn: function() {
    return this._isbn;
    },
    setIsbn: function(isbn) {
    if(!this._checkIsbn(isbn)) {
    throw new Error("Book: Invalid ISBN.");
    }
    this._isbn = isbn;
    },
    _checkIsbn: function(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    },
    getTitle: function() {
    return this._title;
    },
    setTitle: function(title) {
    this._title = title || "";
    },
    getAuthor: function() {
    return this._author;
    },
    setAuthor: function(author) {
    this._author = author || "";
    },
    display: function() {
    return "Book: ISBN: " + this.getIsbn() + ",Title: " + this.getTitle() + ",Author: " + this.getAuthor();
    }
    };

    注意:除了isbn,title,author属性被加上"_"标识为私有成员外,checkIsbn()也被标识为私有方法。

    3. 通过闭包来真正私有化成员。如果对闭包概念中的作用域和嵌套函数不熟悉的朋友,可以参考"面向对象的Javascript之一(初识Javascript)"文章,这里不再详细论述。

    var Publication = new Interface("Publication", ["getIsbn", "setIsbn", "getTitle", "setTitle", "getAuthor", "setAuthor", "display"]);
    var Book = function(newIsbn, newTitle, newAuthor) {
    // private attribute
    var isbn, title, author;
    // private method
    function checkIsbn(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    }
    // previleged method
    this.getIsbn = function() {
    return isbn;
    };
    this.setIsbn = function(newIsbn) {
    if(!checkIsbn(newIsbn)) {
    throw new Error("Book: Invalid ISBN.");
    }
    isbn = newIsbn;
    }
    this.getTitle = function() {
    return title;
    },
    this.setTitle = function(newTitle) {
    title = newTitle || "";
    },
    this.getAuthor: function() {
    return author;
    },
    this.setAuthor: function(newAuthor) {
    author = newAuthor || "";
    }
    // implements Publication interface
    this.setIsbn(newIsbn);
    this.setTitle(newTitle);
    this.setAuthor(newAuthor);
    }
    // public methods
    Book.prototype = {
    display: function() {
    return "Book: ISBN: " + this.getIsbn() + ",Title: " + this.getTitle() + ",Author: " + this.getAuthor();
    }
    };

    这种方案与上一种有哪些不同呢?首先,在构造器中使用var来声明三个私有成员,同样也声明了私有方法checkIsbn(),仅仅在构造器中有效。使用this关键字声明特权方法,即声明在构造器内部但却可以访问私有成员。任何不需要访问私有成员的方法都在Book.prototype中声明(如:display),也即是将需要访问私有成员的方法声明为特权方法是解决这个问题的关键。但此访问也有一定缺陷,如对每一个实例而言,都要创建一份特权方法的副本,势必需要更多内存。我们继续优化,采用静态成员来解决所面临的问题。顺便提一句:静态成员仅仅属于类,所有的对象仅共用一份副本(在"面向对象的Javascript之二(实现接口)中有说明,参见Interface.ensureImplements方法"),而实例方法是针对对象而言。

    var Publication = new Interface("Publication", ["getIsbn", "setIsbn", "getTitle", "setTitle", "getAuthor", "setAuthor", "display"]);
    var Book = (function() {
    // private static attribute
    var numsOfBooks = 0;
    // private static method
    function checkIsbn(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    }
    // return constructor
    return function(newIsbn, newTitle, newAuthor) {
    // private attribute
    var isbn, title, author;
    // previleged method
    this.getIsbn = function() {
    return isbn;
    };
    this.setIsbn = function(newIsbn) {
    if(!Book.checkIsbn(newIsbn)) {
    throw new Error("Book: Invalid ISBN.");
    }
    isbn = newIsbn;
    }
    this.getTitle = function() {
    return title;
    },
    this.setTitle = function(newTitle) {
    title = newTitle || "";
    },
    this.getAuthor = function() {
    return author;
    },
    this.setAuthor = function(newAuthor) {
    author = newAuthor || "";
    }
    Book.numsOfBooks++;
    if(Book.numsOfBooks > 50) {
    throw new Error("Book: at most 50 instances of Book can be created.");
    }
    // implements Publication interface
    this.setIsbn(newIsbn);
    this.setTitle(newTitle);
    this.setAuthor(newAuthor);
    };
    })();
    // public static methods
    Book.convertToTitle = function(title) {
    return title.toUpperCase();
    }
    // public methods
    Book.prototype = {
    display: function() {
    return "Book: ISBN: " + this.getIsbn() + ",Title: " + this.getTitle() + ",Author: " + this.getAuthor();
    }
    };

    这种方案与上种相似,使用var和this来创建私有成员和特权方法。不同之处在于使用闭包来返回构造器,并将checkIsbn声明为私有静态方法。可能有人会问,我为什么要创建私有静态方法,答案在于使所有对象公用一份函数副本而已。我们这里创建的50个实例都只有一个方法副本checkIsbn,且属于类Book。根据需要,你也可以创建公有的静态方法供外部调用(如:convertToTitle)。这里我们继续考虑一个问题,假设以后我们需要对不同的书做限制,比如<<Javascript高级编程>>最大印发量为500,<<.NET>>最大印发量为1000,也即说需要一个最大印发量的常量。思考一下,利用已有的知识,我们如何声明一个常量呢?其实不难,我们想想,可以利用一个只有访问器的私有特权方法就可以实现。

    var Publication = new Interface("Publication", ["getIsbn", "setIsbn", "getTitle", "setTitle", "getAuthor", "setAuthor", "display"]);
    var Book = (function() {
    // private static attribute
    var numsOfBooks = 0;
    // private static contant
    var Constants = {
    "MAX_JAVASCRIPT_NUMS": 500,
    "MAX_NET_NUMS": 1000
    };
    // private static previleged method
    this.getMaxNums(name) {
    return Constants[name.ToUpperCase()];
    }
    // private static method
    function checkIsbn(isbn) {
    if(isbn == undefined || typeof isbn != "string") return false;
    isbn = isbn.replace("-", "");
    if(isbn.length != 10 && isbn.length != 13) return false;
    var sum = 0;
    if(isbn.length == 10) {
    if(!isbn.match(\^\d{9}\)) return false;
    for(var i = 0;i < 9;i++) {
    sum += isbn.charAt(i) * (10 - i);
    }
    var checksum = sum % 11;
    if(checksum == 10) checksum = "X";
    if(isbn.charAt(9) != checksum) return false;
    } else {
    if(!isbn.match(\^\d{12}\)) return false;
    for(var i = 0;i < 12;i++) {
    sum += isbn.charAt(i) * (i % 2 == 0 ? 1 : 3);
    }
    var checksum = sum % 10;
    if(isbn.charAt(12) != checksum) return false;
    }
    return true;
    }
    // return constructor
    return function(newIsbn, newTitle, newAuthor) {
    // private attribute
    var isbn, title, author;
    // previleged method
    this.getIsbn = function() {
    return isbn;
    };
    this.setIsbn = function(newIsbn) {
    if(!Book.checkIsbn(newIsbn)) {
    throw new Error("Book: Invalid ISBN.");
    }
    isbn = newIsbn;
    }
    this.getTitle = function() {
    return title;
    },
    this.setTitle = function(newTitle) {
    title = newTitle || "";
    },
    this.getAuthor = function() {
    return author;
    },
    this.setAuthor = function(newAuthor) {
    author = newAuthor || "";
    }
    Book.numsOfBooks++;
    if(Book.numsOfBooks > 50) {
    throw new Error("Book: at most 50 instances of Book can be created.");
    }
    // implements Publication interface
    this.setIsbn(newIsbn);
    this.setTitle(newTitle);
    this.setAuthor(newAuthor);
    };
    })();
    // public static methods
    Book.convertToTitle = function(title) {
    return title.toUpperCase();
    }
    // public methods
    Book.prototype = {
    display: function() {
    return "Book: ISBN: " + this.getIsbn() + ",Title: " + this.getTitle() +
    ",Author: " + this.getAuthor() + ", Maximum: ";
    },
    showMaxNums: function() {
    return Book.getMaxNums("MAX_JAVASCRIPT_NUMS");
    }
    };

    最完美的情况就是你所封装的程序对调用者而言,仅仅需要知道你的接口就可以,根本不关心你如何实现。但问题在于,随着工程量的扩大,你的封装内容必然会增大,在项目发生交接时,对于一个对作用域和闭包等概念不熟悉的成员来说,维护难度会变得如此之大。有些时候应需求响应必须改动源码(这里不一定指改接口),可能是新增一些细节,即使拿到你的源码却无从下手,那就不好做了。因此,我的建议:封装不要过度,接口一定要清晰,可扩展

    转载于:https://www.cnblogs.com/hmiinyu/archive/2012/01/20/2327964.html

    展开全文
  • jsp的四个域对象和九大隐藏对象

    千次阅读 2014-05-25 17:46:20
    Request:代表的来自客户端的请求,例如我们在FORM表单中填写的信息等,最常用的对象。 Reponse:代表的对客户端的响应,也就是说可以通过“response”对象来组织发送到客户端的数据。 Out: Session:对象...

    1、JSP九大内置对象:

    JSP根据Servlet API 规范提供了某些内置对象,开发者不用事先声明就可以使用标准的变量来访问这些对象。

    Request:代表的是来自客户端的请求,例如我们在FORM表单中填写的信息等,是最常用的对象。取得请求参数
    Reponse:代表的是对客户端的响应,也就是说可以通过“response”对象来组织发送到客户端的数据。响浏览器输出内容
    Out:输出到浏览器
    Session:对象代表服务器与客户端所建立的会话,当需要在不同的JSP页面中保留客户信息的情况下使用,比如在线购物、客户轨迹跟踪等。“session” 对象建立在cookie的基础上,所以使用时应注意判断一下客户端是否打开了cookie。在当前会话中有效,新会话中无效
    application:对象负责提供应用程序在服务器中运行时的一些全局信息。在当前web应用中有效
    Config:对象提供一些配置信息。获取jsp在web.xml文件中配置的初始化参数
    Pagecontext:对象直译时可以称作“页面上下文”对象,代表的是当前页面运行的一些属性。
    Page:代表了正在运行的由JSP文件产生的类对象,不建议一般读者使用。
    exception:对象则代表了JSP文件运行时所产生的例外对象,此对象不能在一般JSP文件中直接使用,而只能在使用了“<%@ page isErrorPage="true "%>”的JSP文件中使用。

     可以按照作用分为:

    输入输出:request,response,out

    作用域之间通信:session,application,pageContext,(request)

    Servlet对象:page,config

    错误对象:Execpiton


    PageContext对象作用:

    1)可以引用其它8个内置对象
          如果一个普通的java类,拥用PageContext对象,则该普通Java类就可以与Web资源交互,例如取得客户端IP地址

      2)域对象
        >>PageContext域对象只能在当前JSP页面中有效,请求出了该JSP页面,原PageContext对象内容销毁
        >>PageContext将值放入到指定的域对象,同样需要从指定的域对象中取值
        >>findAttriute()会根据name依次去JSP中四个域对象查询,找到即止,如果都找不到,返回null字符串
            
     
      3)封装Web常用的操作,例如转发/包含/。。。。
        >>PageContext.include()
        >>PageContext.forward()

     

    2、四大作用域:

    任何一个Java对象都有其作用域范围,JSP的内置对象也不例外。归纳起来,共有四种范围:
    page:page范围内的对象仅在JSP页面范围内有效。超出JSP页面范围,则对象无法获取。
    request:客户向服务器发起的请求称为request(请求)。由于采用<jsp:forward>和response.sendRedirect()等重定位计数,客户端发起的request请求可以跨越若干个页面。因此定义为request范围的JSP内置对象可以在request范围内的若干个页面内有效。
    session:客户端与服务器的交互过程,称为session(会话)。在客户端与服务器的交互过程中,可以发起多次请求,一个session可以包含若干个request。定义为session范围的JSP内置对象可以跨越若干个request范围有效。
    application:部署在服务器上的Web应用程序与所有客户端的的交互过程,称为application。一个application可以包含若干个session。定义为application范围的JSP内置对象可以跨越若干个session范围有效。


     

    三、九大对象对应的作用域:












    3 JSP工作原理
      1)Web服务器会在第一次访问某jsp时,将jsp翻译成java原码,该原码是一个servlet  
      2)jsp的三个生命周期方法:date_jsp(),_jspInit(),_jspDestory(),_jspService()方法,生命周期类似于servlet
      3)在_jspService()方法,Web服务器自动默认创建8个内置对象并设置值
      4)其中静态的资源通过out.write()方法输出,动态资源通过out.print()方法输出
      5)从最终的本质上讲,jsp都是servlet,按照servlet方式运行
     

     
    4 JSP语法

      1)JSP模版元素
        就是JSP中的<html>静态的标签
     
      2)JSP表达式
        语法:<%="变量/常量"%>,字符串用""号定界,无需分号结束
        需要向浏览器输出内容时,可以使用JSP表达式,
        类似于Servlet中resposne.getWriter().write("哈哈");     
     
      3)JSP脚本片断
        语法:<%一行呀多行Java代码,以分号结束%>
        生成的源码,都位于_jspService()方法中,多个JSP脚本片段可以相互访问

      4)JSP声明
        语法:<%! 声明实例变量或普通方法%>
       
      5)JSP注释
        语法:<%-- JSP特有的注释 --%>
        JSP引擎不会将其翻译成Servlet源码,即忽略
        其它注释都会被翻译进Sercvlet源码
        JSP特有注释不允许嵌套
    ============================================================   
    *4 JSP中四个域对象汇总
      1)什么是域对象:在多个动态Web资源之间共享信息,需要域对象;例如:Servlet到Servlet,Servlet到Jsp,Jsp到Jsp
      2)JSP中域对象有四个:PageContext->request->session->application
      3)应用场合:
        >>PageContext:只能应用在当前面页的一次请求中
        >>request:只要在一次请求中,不论该请求经过N个动态资源,只且只能是转发
        >>session:只要在一次新会话中,不论该请求经过N个动态资源,不论转发还是重定向,例如:购物车
        >>application:只要在当前web应用中,不论该请求经过N个动态资源,不论转发还是重定向,不论多个新会话,
        例如:在线访问计数器,QQ群聊室
      4)参见<<jsp中4个域对象.JPG>>

    *5 JSP内置非JavaBean标签(美化+业务逻辑)
      1)JSP标签主要目的:替代JSP页面中的<%%>脚本符号,
      2)目标:达到美化和业务逻辑相统一的JSP页面
      3)常用的标签/动作
        <jsp:include/>(动态包含/运行/执行)
            (1)将被包含的jsp都生成对应的servlet,即如果包含3个jsp的话,则生成3个servlet
            (2)在运行jsp时,动态包含
            (3)总的jsp文件,生成的servlet结构良好    
            (4)<%@include%>指令是通过file属性,而<jsp:include>标签是通过page属性

        <jsp:forward/>
            转发到指定的jsp页面

        <jsp:param/>   
            包含一个或多个参数
       
       4)JSP错误的种类:
        >>JSP语法出错
        >>JSP语法无错,但翻译成Servlet时出错了,源码有,但字符没有
        >>JSP语法无错,翻译成Servlet时无错,执行class时出错了
       
    *6 JSP中内置JavaBean标签 + Page对象
      <jsp:useBean/>
        先查询,如果查询不到,再创建新的JavaBean对象,同时绑定到指定域对象中
        对于<jsp:useBean/>标签中的内容,只能在创建新的JavaBean对象时执行        
        id=绑定到域对象的名字
      <jsp:setProperty/>
        为JavaBean设置值
        param表示参数的名
        只能当参数名和JavaBean的属性名一致的情况下,可以使用通配符收集,代码如下:
        <jsp:setProperty name="student(域对象中的name属性的值)" property="*"(属性名和参数名一致)/>

      <jsp:getProperty/>
        取得JavaBean属性的值

    7 EL和JSTL快速入门
     *1)EL可以替代和简化JSP脚本的输出  
      2)语法格式:${EL语法},前提:<%@ page isELIgnored="false"%>
      3)输出普通变量/JavaBean/多个JavaBean嵌套的值
      4)EL只会从域对象中查询值,找不到返回""空串,底层就是pageContext.findAttribute()方法的封装
     * 5)JSTL替代和简化JSP脚本的迭代操作的输出
      6)JSTL的开发步骤:
        >>导入二个jar包:Jstl.jar和Standard.jar[都是class文件]
            >>在需要使用jsp的页面中导入如下代码:
            <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 



    展开全文
  • 可以看出java一直在致力于隐藏指针的相关信息及概念,令我们潜移默化的认为在java中一切都是对象,但在数据引用转换过程中 如果都是对象级的 相对来说性能的消耗就有些大了 所以其实java中很多我们平时不注意的地方...
  • Js基于对象还是面向对象的一、什么叫做面向对象二、什么叫做基于对象三: Js的特性四:js通过原型链等来模拟出和面向对象很类似的功能。五:总结 一、什么叫做面向对象 面向对象的三大特点(封装,继承,多态)...
  • JSP隐藏对象介绍

    2010-01-16 08:36:00
    1.request对象 客户端的请求信息被封装在request对象中,通过它才能了解到客户的需求,然后做出响应。它HttpServletRequest类的实例。 序号 方 法 说 明1 object getAttribute(String name) 返回指定属性的属性...
  • 封装一种信息隐藏技术,在java中通过关键字private实现封装。什么封装?封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际上使用方法将类的数据隐藏起来,控制用...
  • 理解封装的概念封装面向对象三大特质之一(继承和多态),它指的对象的状态信息封装在对象内部,不允许外部程序直接访问,而是通过该类所提供的方法实现对内部信息的操作和访问。对一个类或对象进行封装可以实现...
  • 信息隐藏和this

    2021-03-07 10:36:57
    1)面向对象法则:信息隐藏——通过类的方法来间接访问类的属性,而不是直接访问类的属性 类的成员属性private 类的方法public的,通过方法修改成员属性的值 类成员私有的private get 和 set 方法公有的...
  • Java面向对象的三大特性封装、继承、多态封装:将类的信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作与访问。​封装的实现步骤:修改属性的可见性:设为private创建...
  • 1、封装封装面向对象的三大特性之一,就是将类的状态信息隐藏在类内部,不允许外部程序直接访问,而通过该类提供的方法来实现对隐藏信息的操作和访问。封装的好处:隐藏类的实现细节;让使用者只能通过程序规定的...
  • Java信息隐藏和this

    2020-01-30 00:44:45
    面向对象的一个法则:信息隐藏 -类的成员属性,私有的private -类的方法公有的public,通过方法修改成员属性的值 -get和set方法公有public的,统称为getter和setter -外界对类成员的操作只能通过get和set方法 -...
  • 隐藏对象是索引图像,通过改变调色板的顺序来隐藏信息,这Gifshuffle算法的基本思想,排序的方式有很多种。对于256色的调色板矩阵来说,最多可以容纳1684个bit信息。 这里我只实现最简单的版本,即将调色板分为...
  • 该项目是通过。 可用脚本 在项目目录中,可以运行: npm start 在开发模式下运行应用程序。 打开在浏览器中查看。 如果进行编辑,页面将重新加载。 您还将在控制台中看到任何棉绒错误。 npm test 在交互式监视...
  • 静态动态成员 一下用面向对象的相关概念来解释js中的仿面向对象,因为js中不像其他语言,不存在面向对象语言的相关特性,但可以通过一些技巧来模仿面向对象。我用同样的概念来概述js的这些方仿面向对象的概念,因为...
  • 信息隐藏(Information Hiding)又名数据隐藏(Data Hiding),起源于古代就出现的隐写,与密码技术不同,隐写技术通过将数据存储在其他可公开的载体中,使对手难以知道保密通信或保密存储的存在,也难以找到破解对象,...
  • 对象的封装

    2017-06-29 11:54:00
    封装指依照信息屏蔽的原则,把对象的属性和操作结合在一起,构成一个独立的对象。 通过限制对属性和操作的訪问权限。能够将属性“隐藏”在对象内部。对外提供一定的接口,在对象之外仅仅能通过接口对对象进行...
  • qq_遁去的一_1隐藏就是封装吧。...封装一种信息隐藏技术,在java中通过关键字private实现封装。什么封装?封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际 上使用方法将类...
  • 面向对象的特征

    2020-10-30 22:01:46
    面向对象的特征主要有封装、继承和多态。...信息隐藏是用户对封装性的认识,封装则为信息隐藏提供支持。封装保证了模块具有较好的独立性,使得程序维护修改较为容易。对应用程序的修改仅限于类的内部,因而可以将应
  • 文章目录一些名词原理框图基本要求系统特性 一些名词 首先讲几个重要名词,载体对象、伪装对象和...下面原理图,秘密消息和载体对象c通过信息嵌入算法变成伪装对象,就可以经过不安全的信道,利用密钥进行信息提取
  • 将类的某些信息隐藏在类内部,不允许外部程序直接访问 通过该类提供方法来实现对隐藏信息的操作和访问 隐藏对象的信息 留出访问的接口 封装的特点 只能通过规定的方法访问数据 隐藏类的实例细节,方便修改和...
  • 封装面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念,这样能避免受到外界的干扰和误用,从而确保了安全。数据封装引申出了另一个重要的 OOP 概念,即数据隐藏。 数据封装一种把数据和操作数据的...
  • 在我们编程的过程中,我们应该尽可能的把...我们可以这样理解封装和信息隐藏,信息隐藏是我们的目标,因为我们不想太多无关的信息暴露在对象之外,而封装就是实现我们目标的方法。封装就可以被定义为在对象内部隐...
  • 委托,一种特殊的类,它将调用时操作对象和指定方法的封装。委托的构造函数,需两个参数target,methodPtr分别用于指定操作的对象和方法。委托的调用通过Invoke方法,方法的原型及委托定义一致。委托同时提供了...
  • 封装:将对象的实现细节隐藏,然后定义一些公有方法来显示该对象的功能,要访问该类的代码和数据,必须通过接口控制。 优点: 封装就是防止该类的代码和数据被外部类定义的代码随机访问 适当的封装可以让程式...
  • 类的隐藏与封装

    2019-09-10 11:06:23
    封装面向对象的三大特征之一, 它指的对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实现对内部信息的操作和访问。对一个类或对象实现良好的封装,可以达到...

空空如也

空空如也

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

信息隐藏是通过对象的