JAVA基础
封装就是将属性私有化，提供公有的方法访问私有属性。
做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（ getter ）方法和赋值（ setter ）方法，用于对这些属性的访问。
如： private String name;
public String getName(){
return;
}
public void setName(String name){
this.name=name;
}
2、 为什么需要封装？
通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。
- init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
- service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
- destory()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
Statement statement = conn.createStatement();
PreparedStatement preStatement = conn.prepareStatement(sql);
执行的时候:
ResultSet rSet = statement.executeQuery(sql);
ResultSet pSet = preStatement.executeQuery();
由上可以看出，PreparedStatement有预编译的过程，已经绑定sql，之后无论执行多少遍，都不会再去进行编译，
而 statement 不同，如果执行多变，则相应的就要编译多少遍sql，所以从这点看，preStatement 的效率会比 Statement要高一些
- import java.sql.Connection;
- import java.sql.DriverManager;
- import java.sql.PreparedStatement;
- import java.sql.ResultSet;
- import java.sql.Statement;
- public class JDBCTest {
- public static void main(String[] args) throws Exception {
- //1 加载数据库驱动
- Class.forName("com.mysql.jdbc.Driver" );
- //2 获取数据库连接
- String url = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8" ;
- String user = "root" ;
- String password = "root" ;
- Connection conn = DriverManager.getConnection(url, user, password);
- //3 创建一个Statement
- String sql = "select id,loginName,email from user where id=" ;
- String tempSql;
- int count = 1000 ;
- long time = System.currentTimeMillis();
- for ( int i= 0 ;i<count ;i++){
- Statement statement = conn.createStatement();
- tempSql=sql+(int ) (Math.random() * 100 );
- ResultSet rSet = statement.executeQuery(tempSql);
- statement.close();
- }
- System.out.println("statement cost:" + (System.currentTimeMillis() - time));
- String psql = "select id,loginName,email from user where id=?" ;
- time = System.currentTimeMillis();
- for ( int i = 0 ; i < count; i++) {
- int id=( int ) (Math.random() * 100 );
- PreparedStatement preStatement = conn.prepareStatement(psql);
- preStatement.setLong(1 , new Long(id));
- ResultSet pSet = preStatement.executeQuery();
- preStatement.close();
- }
- System.out.println("preStatement cost:" + (System.currentTimeMillis() - time));
- conn.close();
- }
- }
上述代码反复执行，
statement cost:95 preStatement cost:90
statement cost:100 preStatement cost:89
statement cost:92 preStatement cost:86
当然，这个也会跟数据库的支持有关系，http://lucaslee.iteye.com/blog/49292 这篇帖子有说明
虽然没有更详细的测试 各种数据库， 但是就数据库发展 版本越高，数据库对 preStatement的支持会越来越好，
所以总体而言， 验证 preStatement 的效率 比 Statement 的效率高
2>安全性问题
这个就不多说了，preStatement是预编译的，所以可以有效的防止 SQL注入等问题
所以 preStatement 的安全性 比 Statement 高
3>代码的可读性 和 可维护性
这点也不用多说了，你看老代码的时候 会深有体会
preStatement更胜一筹
toUpperCase()会对当前对象进行检查 如果不需要转换直接返回当前对象，否则new一个新对象返回；
replace()如果两个参数相同，则直接返回，否则new一个新对象，所以这里y指向"Fmn";
y=y+"wxy" 这里修改y所指向的字符串对象，让它由指向"Fmn"变成指向"Fmnxyz".
public class Square { long width; public Square(long l) { width = l; } public static void main(String arg[]) { Square a, b, c; a = new Square(42L); b = new Square(42L); c = b; long s = 42L; } }
这题考的是引用和内存。//声明了3个Square类型的变量a, b, c//在stack中分配3个内存，名字为a, b, cSquare a, b, c; //在heap中分配了一块新内存，里边包含自己的成员变量width值为48L，然后stack中的a指向这块内存a = new Square(42L);//在heap中分配了一块新内存，其中包含自己的成员变量width值为48L，然后stack中的b指向这块内存b = new Square(42L); //stack中的c也指向b所指向的内存c = b;//在stack中分配了一块内存，值为42long s = 42L; |
|
1
2
3
|
public boolean equals(Object obj) { return (this == obj); } |
Thread(Runnable target, String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
在GoF设计模式中，结构型模式有：
外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。
享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。.
享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。
我们已经知道类体中的方法分为实例方法和类方法两种，用static修饰的是类方法。二者有什么区别呢？当一个类创建了一个对象后，这个对象就可以调用该类的方法。
当类的字节码文件被加载到内存时，类的实例方法不会被分配入口地址，当该类创建对象后，类中的实例方法才分配入口地址，从而实例方法可以被类创建的任何对象调用执行。需要注意的是，当我们创建第一个对象时，类中的实例方法就分配了入口地址，当再创建对象时，不再分配入口地址，也就是说，方法的入口地址被所有的对象共享，当所有的对象都不存在时，方法的入口地址才被取消。
对于类中的类方法，在该类被加载到内存时，就分配了相应的入口地址。从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。类方法的入口地址直到程序退出才被取消。
类方法在类的字节码加载到内存时就分配了入口地址，因此，Java语言允许通过类名直接调用类方法，而实例方法不能通过类名调用。在讲述类的时候我们强调过，在Java语言中，类中的类方法不可以操作实例变量，也不可以调用实例方法，这是因为在类创建对象之前，实例成员变量还没有分配内存，而且实例方法也没有入口地址。
class A
{ int x,y;
static float f(int a){}
float g(int x1,int x2){}
}
class B
{ public static void main(String args[])
{ A a1=new A();
A.f(2,3); //合法。
a1.f(2,4); //合法。
a1.g(2,5); //合法。
A.g(3,2); //非法。
}
}
