Java Web 项目，数据库建表

Java 使用executeUpdate向数据库中创建表格

创新互联长期为上1000家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为蒲城企业提供专业的成都做网站、网站制作，蒲城网站改版等技术服务。拥有10多年丰富建站经验和众多成功案例,为您定制开发。

一、创建mysql.ini文件，配置如下

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://127.0.0.1:3306/select_test

user=root

pass=123456

这样以后修改数据库的配置直接在mysql.ini文件中修改。

二、编写代码

　initParam方法： 获得mysql.ini中的数据

createTale方法： 连接数据库，并且executeUpdate执行sql语句。此例的sql文件为创建表语句。

　main方法： 传入Sql语句。

class ExecuteDDL {

private String driver;

private String url;

private String user;

private String pass;

Connection conn;

Statement stmt;

public void initParam(String paramFile) throws Exception {

Properties props = new Properties();

props.load(new FileInputStream(paramFile));

driver = props.getProperty("driver");

url = props.getProperty("url");

user = props.getProperty("user");

pass = props.getProperty("pass");

}

public void createTale(String sql) throws Exception{

try {

Class.forName(driver);

conn = DriverManager.getConnection(url,user,pass);

stmt = conn.createStatement();

stmt.executeUpdate(sql);

}

finally

{

if (stmt != null) {

stmt.close();

}

if (conn != null) {

conn.close();

}

}

}

/**

* @param args

* @throws Exception

*/

public static void main(String[] args) throws Exception {

// TODO Auto-generated method stub

ExecuteDDL ed = new ExecuteDDL();

ed.initParam("src/mysql.ini");

ed.createTale("create table student " +

"(id int, " +

"name varchar(50), " +

"num varchar(20) )");

System.out.println("Creating table success!");

}

　注意事项：传入的Sql语句最好在MySql测试通过，并且传入的mysql.int文件的路径必须正确。　

当执行完毕后，在MySql的select_test数据库中查看该Student表是否已经创建成功了。

三、使用executeUpdate方法，向表中插入数据。

将上面的创建表的Sql语句改为插入数据表的语句，执行executeUpdate方法，其结果就是想表中插入数据。

创建insertSql变量。

private static String insertSql = "insert into student values(1,'XiaoMing','06108787')";

　执行插入语句。

ed.createTale(insertSql);

学习java se注重的只是点是哪些，最难学的知识点有哪些呢？

1. 基本数据类型

整形：

byte 1 个字节

short 2 个字节

int 4个字节

long 8个字节

字符：

char 2个字节

浮点数：

float 4个字节

double 8个字节

布尔：

boolean 1个字节

2.java 7 新增二进制整数

以0b或者0B开头

3.java中字符时16位的Unicode编码方式，格式是'\uXXXX'，其中xxxx代表一个十六进制整数

4.java中规定了正无穷大、负无穷大和零

正无穷大= 一个正数除以0

负无穷大= 一个负数除以零

0.0 除以0.0 或者 对一个负数开方 得到一个非数

5. 在java中布尔类型只能是true和false

6. 在java中没有多维数组

看似像C语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2] 是真实存在的，装的是地址，和c语言中动态分配为的数组一样

int [][] b = new int[3][4]

7. Java中带包的编译方法

javac -d . Hello.java 会在当前目录下生成目录树

运行 java 包名字.类名字

8. Java多态中的对象的filed 不具有多态性，如 父类 对象 = new 子类（）， 对象.field 是调用的父类的，即使子类中覆盖了该字段。

9. instanceof 运算符

格式： 引用变量名 instanceof 类名（或者接口） 他用于判断前面的对象是否是后面对象的类，子类、实现类的实例，是返回true，否者返回false

10. Java 中基本数据类型和对应封装类之间的转化

int a = 1;

Integer A = new Integer(a);

a = A.intValue();

其他的类型也是这样的。

11.单例（singleton）类 例子

复制代码 代码如下:

class Singleton

{

private static Singleton instance;

private Singleton(){}

public static Singleton getInstance()

{

if(instance == null)

{

instance = new Singleton();

}

return instance;

}

public static void main(String[] args)

{

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

System.out.println(s1 == s2);

}

}

12.final修饰的成员变量初始化问题

类Field： 必须在静态初始块中或声明该FIeld时指定初始值

实例Field：必须在非静态初始块中或声明该FIeld时指定初始值或构造器中声明

13.Final 变量必须显式初始化，系统不会对final变量进行隐式初始化

14.java会使用常量池来管理曾经用过的字符串直接常量，例如：String a = "java"; ，系统把常量字符串“java”存在常量池，当再次执行 String b = "java"; a == b 是true

15.final 方法不可以重写，final类不能被继承

如果用private 方法 和 final private 是一样的

若果是用final修饰的方法在子类中出现，那是子类新定义的，与父类没有关系

16.不可变类：创建后该类的Field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。

17.缓存实例的不可改变类

复制代码 代码如下:

class CacheImmutale

{

private static int MAX_SIZE = 10;

private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];

private static int pos = 0;

private final String name;

private CacheImmutale(String name)

{

this. name = name;

}

public String getName()

{

return name;

}

public static CacheImmutale valueOf(String name)

{

for(int i = 0; i MAX_SIZE; ++i)

{

if(cache[i] != null cache[i].getName().equals(name))

return cache[i];

}

if(pos == MAX_SIZE)

{

cache[0] = new CacheImmutale(name);

pos = 1;

}

else

{

cache[pos++] = new CacheImmutale(name);

}

return cache[pos -1];

}

public boolean equals(Object obj)

{

if(this == obj)

return true;

if(obj != null obj.getClass() == CacheImmutale.class)

{

CacheImmutale ci = (CacheImmutale)obj;

return name.equals(ci.getName());

}

return false;

}

public int hashCode()

{

return name.hashCode();

}

}

public class CacheImmuteTest

{

public static void main(String[] args)

{

CacheImmutale c1 = CacheImmutale.valueOf("Hello");

CacheImmutale c2 = CacheImmutale.valueOf("Hello");

System.out.println(c1 == c2);

}

}

用缓存实例要看某个对象的使用频率，若重复使用那就利大于弊，若不经常使用那弊就大于利

还有java提供的java.lang.Integer 创建数值在-128-127之间的数采用缓存机制的

Integer in2 = Integer.valueOf(6);

Integer in3= Integer.valueOf(6);

in2 == in3 is true;

18. static 和 abstract 不能同时修饰一个方法，没有类抽象方法

19.一个类可以又一个父类，实现多个接口，接口中Filed是public 、static、final的，方法是public abstract的

20.非静态内部类的方法访问某个变量，搜索顺序为：先内部类中方法内- 内部类 - 外部类中如果都找不到则出现编译错误

复制代码 代码如下:

import java.util.*;

public class DiscernVariable

{

private String prop = "外部类的实例变量";

private class InClass

{

private String prop = "内部类的实例变量";

public void info()

{

String prop = "局部变量";

System.out.println("外部类的field值：" + DiscernVariable.this.prop);

System.out.println("内部类的field值：" + this.prop);

System.out.println("局部变量的值：" + prop);

}

}

public void test()

{

InClass in = new InClass();

in.info();

}

public static void main(String[] args)

{

new DiscernVariable().test();

}

}

21.非静态内部类不能有静态方法、静态Field、静态初始化块

22.在外部类之外访问内部类

访问非静态内部类：outclass.Inclass varname = new outclass().new InClass();

访问静态内部类： outclass.Inclass varname = new outclass.Inclass();

复制代码 代码如下:

import java.util.*;

class Out

{

class In

{

public In()

{

System.out.println("非静态内部类构造器");

}

}

}

public class CreatInnerInstance

{

public static void main(String[] args)

{

Out.In in = new Out().new In();

/*

以上的代码可分开写为：

Out.In in;

Out out = new Out();

in = out.new In();

*/

}

}

class SubClass extends Out.In

{

//显示定义SubClass的构造器

public SubClass(Out out)

{

//通过转入的Out对象显示调用In的构造器

out.super();

}

}

复制代码 代码如下:

import java.util.*;

class StaticOut

{

static class StaticIn

{

public StaticIn()

{

System.out.println("静态内部类构造器");

}

}

}

public class CreatStaticInnerInstance

{

public static void main(String[] args)

{

StaticOut.StaticIn in = new StaticOut.StaticIn();

/*

以上的代码可分开写为：

StaticOut.StaticIn in;

in = new StaticOut.StaticIn();

*/

}

}

class SubClass extends StaticOut.StaticIn

{

//无须创建内部类实例

}

tale软件如何

tale软件如何，Tale是一款基于Java的博客Web系统，使用了轻量级 mvc 框架 Blade 开发。特性

设计简洁，界面美观

自定义文章链接

支持多主题（默认主题 pinghsu）

支持插件扩展

支持 Emoji 表情

支持网易云音乐播放

支持附件和数据库备份

部署简单，不依赖 Tomcat

无需数据库，内嵌 Sqlite

java如何把Map map = new HashMap(); 按 Key 排序

首先Map排序需要自己写一堆算法。其次HashMap是无序的，即使已经排序正确了，取值时也不一定就是按顺序取出的。所以直接排序存放是不可行的。

但可以曲线救国的办法，通过SetString keys = map.keySet();取得map的key值集合，然后单独给keys来个排序就简单多了，然后按排序后的keys去遍历取值，就OK了。

java的缓冲机制

所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。缓存机制的实现有很多中，这里讲一种。

public class CacheImmutale{

//声明要缓存的类名；

private final String className;

//声明10个缓存池

private static CacheImmutale[] cache= new CachImmutale[10];

//记录缓存的位置，最新位置为[pos-1]

private static int pos=0;

//构造器

public CacheImmutale(String className){

this.className=className;

}

//返回方法

public String getName(){

return className;

}

//返回对象实例名，传进要使用的实例名，由该方法去判断缓存池中是否存在

public static CacheImmutale valueOf(String className){

//遍历缓存池，若存在，返回

for(int i=0;i

if(cache[i]!=nullcache[i].getName().equals(className)){

return cache[i];

}

}

//如果缓存池满，则采取先进先出

if(pos==10){

cache[0]=new CacheImmutale(className);

pos=1;

return cache[0];

}

else{

cache[pos++]=new CacheImmutale(className);

return cache[pos-1];

}

}

public boolean equals(Object obj){

if(obj instanceof CacheImmutale){

CacheImmutale c1=(CacheImmutale)obj;

if(className.equals(c1.getName())){

return true;

}

}

return false;

}

public int hashCode(){

return className.hashCode();

}

}

文章标题：tale博客java代码的简单介绍
本文链接：http://myzitong.com/article/doogeig.html