Java学习笔记

java环境搭建安装下载

jdk里面包含jre，只需要下载jdk就可以了，【注意细节】安装时不安装公共JRE，因为JDK本身就含有JRE

不要按默认目录安装，因为里面还有空格，可以安装到D盘

https://www.oracle.com/cn/java/technologies/javase/javase-jdk8-downloads.html

配置path路径

D:DevJavajdk1.8.0_231bin

D:DevJavajdk1.8.0_231jrebin

开发工具

https://www.eclipse.org/downloads/packages/

自动提示

打开window->preference 搜索content assist ，在java里面找到Auto Activation 下 Auto activation trigger for Java ：替换成：

.abcefghijklmnopqrstuvwxyz(,0123456789

常用快捷键

代码助手:Alt+/
快速修正：Ctrl+1
删除选中的行：Ctrl+D
组织导入：Ctrl+Shift+O
格式化代码：Ctrl+Shift+F

查看某个类的源代码：Ctrl+点进去
快速Outline：Ctrl+O
打开继承体系：Ctrl+T

打开资源：Ctrl+Shift+R
打开类型：Ctrl+Shift+T
上下移动选中的行：Alt+Up/Down
上下复制选中的行：Ctrl+Alt+Up/Down

单行注释：Ctrl+/
多行注释：Ctrl+Shift+/
取消多行注释: Ctrl+Shift+
变为大/小写：Ctrl+Shift+X/Y

Alt+Shift+R：重命名

如何查看快捷键

断点调试
F5：Step Into/进入
F6：Step over/跳过
F7：Step return/返回
F8：Resume/继续

Javaweb

javaweb就是：web应用程序，属于动态页面

环境配置

需要的软件：Apache Tomcat,eclipse,jdk8

Apache Tomcat

下载：https://tomcat.apache.org/download-80.cgi#8.5.72

支持的版本

Apache Tomcat version 8.5 implements the Servlet 3.1 and JavaServer Pages 2.3

运行Tomcat

打开Tombcat所在目录，找到bin目录下的startup.bat运行文件

在Eclipse中配置

Window>Preferences>Server>Runtime Environments>Add>选择：找到Tomcat的根目录>Apply and close

XML

可扩展标记语言

特殊符号的表示约束文档书写规则

DTD

Schema

解析XML

使用dom4j

下载地址：https://dom4j.github.io/

示例：

import java.net.URL;

import org.dom4j.document;
import org.dom4j.documentException;
import org.dom4j.io.SAXReader;

public class Foo {

    public document parse(URL url) throws documentException {
        SAXReader reader = new SAXReader();
        document document = reader.read(url);
        return document;
    }
}

public void bar(document document) throws documentException {

    Element root = document.getRootElement();

    // iterate through child elements of root
    for (Iterator it = root.elementIterator(); it.hasNext();) {
        Element element = it.next();
        // do something
    }

    // iterate through child elements of root with element name "foo"
    for (Iterator it = root.elementIterator("foo"); it.hasNext();) {
        Element foo = it.next();
        // do something
    }

    // iterate through attributes of root
    for (Iterator it = root.attributeIterator(); it.hasNext();) {
        Attribute attribute = it.next();
        // do something
    }
 }

项目默认配置文件



  项目名称
  
    index.html
    index.htm
    index.jsp
    default.html
    default.htm
    default.jsp

初始化参数配置


    Encoding
    UTF-8

配置404页面


    404
    /404.jsp

http协议

规定了一系列浏览器访问服务器的规则，规定请求和响应的数据规则，什么样的数据以及数据的排列规则

网址：

IP地址：

端口号：

请求和响应就是数据的交流

请求

数据包：访问的网址

request 客户端> 服务器端

请求头：Request Headers

请求方式  地址  HTTP版本
GET /web01/ HTTP/1.1 

域名
Host: localhost:8080 

Connection: keep-alive
Cache-Control: max-age=0
sec-ch-ua: "Chromium";v="94", "Google Chrome";v="94", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1

客户端信息：浏览器版本
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,**;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost:8080/web01/
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
cookie: JSESSIonID=2FE0CE80CF51439132319D34667183BB

Form Data

username=12&password=12

响应

数据包：网页的资源

response 服务器端> 客户端

响应头

Response Headers

HTTP/1.1 200
Content-Type: text/html;charset=utf-8
Content-Length: 200
Date: Mon, 11 Oct 2021 12:50:03 GMT
Keep-Alive: timeout=20
Connection: keep-alive

响应状态码

200

404

响应体









Insert title here


欢迎你







www.sunao.com


	
www.sunao.com

JSP

Java服务器页面，一个简化的servlet

java EE的入门课程

用来开发动态页面

创建jsp项目

jsp是java和HTML的组合

Dynamic Web Project

new>other>web>Dynamic Web Project

选择Severlet版本

新建网站入口:index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>




Insert title here

编码设置

选择jsp文件>右击>选择Properties>修改Other里面的选择为UTF-8

手动修改：utf-8

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here


欢迎你

运行web项目

选择项目>Run as>Run On Server>选择配置好的Tomcat版本

在jsp页面书写java代码

使用<% %>

这里面可以调用jsp的内置对象，也可以调用java的对象

<%@page import="java.util.Date"%>
<%@page import="javax.xml.crypto.Data"%>
<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here


欢迎你
<%
// 这里可以任意书写java代码
// out是jsp里面的内置对象
	out.println("当前登录用户：SIKI");
	// 显示在客户端
	out.println(new Date());
	// 显示在服务器
	System.out.println(new Date());
%>

注释注释java

注释jsp里面的java代码，和java里面的注释一样

<%@page import="java.util.Date"%>
<%@page import="javax.xml.crypto.Data"%>
<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here


欢迎你
<%
// 这里可以任意书写java代码
// out是jsp里面的内置对象
	
	// 显示在服务器
	System.out.println(new Date());
%>

注释HTML

注释HTML代码，也可以注释java代码

<%@page import="java.util.Date"%>
<%@page import="javax.xml.crypto.Data"%>
<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here


欢迎你
<%-- 注释HTML代码 --%>
    
<%
// 这里可以任意书写java代码
// out是jsp里面的内置对象
	
	// 显示在服务器
	System.out.println(new Date());
%>

java包的引入

<%@page import="java.util.Date"%>
<%--
 多个包的时候使用 逗号 隔开 
--%>
<%@page import="java.util.Date,java.util.Math"%>

jsp变量理解jsp

每个jsp页面可以看做一个java类，实际是每个jsp页面都会对应一个类，是系统自动生成的一个类，当访问jsp页面的时候就会访问这类的代码

jsp里面的成员变量/定义表达式

<%! 
	// 定义java代码
	// 成员变量 可以保存下来
	int count = 0; 
%>

jsp里面的局部变量

<%
	// 局部变量  
	// 运行一次初始化一次
	int number = 0;
	count++;
	number++;
	out.println("count:"+count);
	out.println("number:"+number);
%>

jsp表达式输出表达式

作用：专门往页面上输出内容的

<%
String str = "www.sunao.com";
%>

<%=str %>

定义表达式

<%! 
	// 定义java代码
	// 成员变量 可以保存下来
	int count = 0; 
%>

与java代码的混合使用

<%@page import="com.sun.util.DBUtil"%>
<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here






<%
String username = request.getParameter("username");
String password = request.getParameter("password");
String repassword = request.getParameter("repassword");
int age = Integer.parseInt(request.getParameter("age"));
String sex = request.getParameter("sex");

boolean isSuccess = DBUtil.addUser(username, password,repassword, age, sex);
if(isSuccess) {
	//out.println("注册成功");
%>
	恭喜<%= username %>注册成功
	返回登录页面
<%
}
else 
{
	//out.println("注册失败");
%>
	注册失败
	<%
}


%>

jsp内置对象 out

打印输出

out.println();

request

// 获取用户参数
String username = request.getParameter("username")

解决乱码问题

request.setCharacterEncoding("utf-8");

请求转发

把页面作为数据直接返回

session.setAttribute("user", user);
request.getRequestDispatcher("personCenter.jsp").forward(request, response);

response

// 给客户端数据
PrintWriter writer = response.getWriter();
writer.println("printWriter");

服务器之间的数据传递

客户端每次请求都是不同的request，只有重定向之后才可以把数据传给另一个jsp文件

//需要传递的数据 k V
request.setAttribute(key,value);
request.getRequestDispatcher("login.jsp").forward(request,response);

// 需要接收的数据
Object data = request.getAtrribute(key);

Session会话

生命周期：可以设置

作用

让当前登录的用户，在任何页面都可以显示用户信息

把用户信息保存下来，每个页面都可以访问

存储的位置：

同一个客户端访问的时候，session的地址相同，不同的客户端session不同

<%
User user =(User)session.getAttribute("user");
if(user!=null){
%>
当前登录用户：<%=user.getUsername() %>

<%
}
%>

appliction

整个服务器端就存在一个application对象，相当于网站

所有客户端访问的都是同一个application

作用

存储所有客户端都需要的数据

比如：登录客户端个数，当前用户登录个数

int number = 0;
//application.setAttribute("usercount", arg1);
if(application.getAttribute("userNumber")!=null){
number = (Integer)application.getAttribute("userNumber");
}
number++;
application.setAttribute("userNumber", number);

page

只在当前页面生效的对象，等于当前jsp的页面的this

pageContext

页面的容器

// 四个域对象：page request session application 作用域从左到右依次增大
// pageContext获取四大域对象
pageContext.getOut();
pageContext.getRequest();
pageContext.getResponse();
pageContext.getSession();//httpSession
pageContext.getServletContext();//application

// 设置属性
pageContext.setAttribute("key", "sun");
// 指定域 设置属性
pageContext.setAttribute("user", "ss", pageContext.SESSION_SCOPE);

Servlet

作用：更加适合做逻辑处理

jsp更加做展示

创建servlet

package com.sun.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 注解 访问路径
@WebServlet("/demo_do")
// 继承 HttpServlet
public class DemoServlet extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.getWriter().append("我的doget方法");
	}
	
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.getWriter().append("doPost");
	}
}

Servlet获取application

ServletContext application = this.getServletContext();

Servlet获取session

HttpSession session = request.getSession();

通过配置文件配置servlet访问路径

在xml中



	
		LoginServlet
		com.sun.servlet.LoginServlet
	
	
		LoginServlet
		/login_do
	
	
		RegisterServlet
		com.sun.servlet.RegisterServlet
	
	
		RegisterServlet
		/register_do

生命周期

package com.sun.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       

    public TestServlet() {
        super();
        System.out.println("构造方法");
    }
    
    @Override
    public void init() throws ServletException {
    	// TODO Auto-generated method stub
    	super.init();
    	System.out.println("init方法");
    }
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    	// TODO Auto-generated method stub
    	super.service(req, resp);
    	System.out.println("service方法");
    }
    
    @Override
    public void destroy() {
    	// TODO Auto-generated method stub
    	super.destroy();
    	System.out.println("destroy方法"); 
    }

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doGet方法");
	}


	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doPost方法");
	}

}

构造方法
init方法
doGet方法
service方法
十月 13, 2021 11:08:51 上午 org.apache.catalina.core.StandardContext reload
信息: 已开始重新加载名为[/web03]的上下文
destroy方法

重定向

重定向是客户端需要处理的地址

所有不需要传递数据的都可以使用重定向

servlet与：servlet、jsp之间可以互相重定向，以及请求转发

直接访问这个页面

重定向和请求转发的区别

重定向：客户给你一个维修部门的电话号码，让你自己打

请求转发：客户帮你接通维修部门的电话

request.setAttribute("msg", "注册成功，请登录");
response.sendRedirect(request.getContextPath()+"login.jsp");

jsp 内置标签 jsp:include

作用：可以包含内置页面，重复的页面比如头部和底部可以重复利用，便于维护

路径相对路径

缺点：在请求转发的时候会存在路径不对的问题

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




进入test1

结果

进入test1

解析绝对路径

/test1.jsp">进入test1

结果

这里会加上项目路径

进入test1

服务器路径

服务器需要解析的路径，使用相对路径即可

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here



<%
pageContext.setAttribute("key", "sun");
pageContext.setAttribute("user", "ss", pageContext.SESSION_SCOPE);
out.println(session.getAttribute("user"));


%>

MVC 模型层Model

存放数据

不同的数据分类成不同的数据模型，对java类进行分类

每个数据模型在数据库中都对应一个表

用户：

课程

视图层View

存放jsp页面

控制层Controller

存放servlet

JavaEE架构层 web层

MVC

service层

业务逻辑

注册登录

dao层

数据库交互

EL表达式

取数据

让jsp页面变得更优雅，美观

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>




Insert title here


page request session application
    作用：直接取得四大域里面的数据，域名+Scope
<%
request.setAttribute("number", 2000);
session.setAttribute("user", "sunao");
application.setAttribute("count", 80000);
%>

当前在线人数：${requestScope.number}

用户名：${sessionScope.user};

之前的写法

<%
Object o = request.getAttribute("msg");
if(o!=null) out.println(o+"
");
%>

el表达式

${requestScope.msg}

调用对象的属性和方法

调用数据时，其属性必须有get方法

<%
User user = (User)session.getAttribute("user");
%>
欢迎<%=user.getUsername() %>！

欢迎${user.username}！

欢迎${user.getUsername()}！

调用map里面的数据

<%
Map map = new HashMap();
map.put("name", "sun");
request.setAttribute("map", map);
%>
使用map调用name：${map.name }

list集合中

<%
List list = new ArrayList();
list.add(new User("sun","ai1",12,"baoy",false));
list.add(new User("sun1","a2i",12,"baoy",false));
list.add(new User("sun2","a3i",12,"baoy",false));

request.setAttribute("list", list);
%>

list1内容：${list[1].getUsername()}

list2内容：${list[2].username}

获取项目路径

// 之前使用的是 request.getContextPath() 
// 只要是get方法 el表达式都可以使用
// 首先获得request对象，通过pageContext对象
${pageContext.request.contextPath}

局限性：只能取数据，和简单的运算

${empty user} 返回true或false
${1+1}

jstl表达式

标签库，用来存储数据的，以及逻辑处理

下载jar包：http://www.java2s.com/Code/Jar/j/Downloadjstlapi12jar.htm

放到lib文件夹下边，将自动放到Libraries库中

jsp页面引入jstl

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>




Insert title here

jstl标签

设置数据，移除数据、输出数据


${requestScope.username}

${username }

条件语句



// if语句
true

//相当于if else

已经成年了
你是未成年

for循环


${i}

利用el表达式和jstl表达foreach循环配合使用，遍历集合

items：集合对象

var：集合里面的元素


${user.username}:${user.password}:${user.age}

EL与jstl混合使用

中间没有任何java代码

<%@page import="com.sun.model.User"%>
<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>




Insert title here


首页




登录
注册



当前登录用户：${user.username}！



各种商品的展示

JSON数据格式 json基础数据

字符串：“siki” “ww.sikidedu.com” " " “我是中国人”
数字：100 200
空： null
布尔： true / false

复杂数据

对象：都是成对出现的数据

可以包含对象数组和基础数据类型

{ 
	"key":"基础数据/对象",
	"name":"Michel",
	"age":20,
	"成绩":{
			"数学":200
		},
	"数组":[100,200,200,300],
	"数组2":[{"对象":1},{"hh":1}]
}

数组：都是单身狗

可以包含对象数组和基础数据类型

[ 100,200,200,300] 长度为4 索引从0开始
[] 空数组

下载jar包

https://www.json.org/json-en.html

JSON的序列化与反序列化序列化

// 序列化 持久化
Goods goods = new Goods("香蕉", "夏威夷", 100, 400);
String json = JSON.toJSONString(goods);
System.out.println(json);

序列化

每个对象类型 {“username”:“make”,“age”:12}的数据

都要与之对应的数据模型（比如User、Goods）

// 反序列化  反持久化
String s = "{"des":"夏威夷","inventory":400,"name":"香蕉","price":100}";
Goods goods = JSON.parseObject(s, Goods.class);
System.out.println(goods.getName());
System.out.println(goods.getDes());
System.out.println(goods.getPrice());

如果是多个对象组成的数组JSON数据，需要使用parseArray(string,class)解析数据

String s = "[{"username":"make","age":12},"
				+ "{"username":"make","age":12},"
				+ "{"username":"make","age":12}]";
		
List list = JSON.parseArray(s, UserTest.class);
for (UserTest user : list) {
	System.out.println(user);
}

Ajax动态请求

在页面不进行跳转和刷新的情况下向服务器发起请求

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>




Insert title here




注册

${msg}

用户名

密码

年龄

性别:男女

服务器端的servlet处理

package com.sun.controller;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.sun.service.UserServise;

@WebServlet("/verifyUsername")
public class VerifyUsernameServlet extends HttpServlet {
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取用户名，验证是否存在
		boolean exst = new UserServise().isExst(request.getParameter("username"));
		System.out.println(exst);
        // 这里响应一个json的数据给客户端
		response.getWriter().append("{"isSuccess":"+!exst+"}");
	}
}

过滤器

servlet是被访问的，filter是用来过滤访问路径

配置文件过滤访问路径

通过配置文件配置需要过滤访问路径



  web05
  
    index.html
    index.htm
    index.jsp
    default.html
    default.htm
    default.jsp
  
  
    Test1Filter
    com.sun.filter.Test1Filter
  
  
    AdminFilter
    com.sun.filter.AdminFilter
  
  
    EncodeFilter
    com.sun.filter.EncodeFilter
    
      Encoding
      UTF-8
    
  
  
    Test1Filter
    
//@WebFilter("
    public AdminFilter() {
        // TODO Auto-generated constructor stub
    }

	
	public void destroy() {
		// TODO Auto-generated method stub
	}

	
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		// place your code here
		HttpServletRequest httpReq = (HttpServletRequest) request;
		HttpServletResponse httpResp = (HttpServletResponse) response;
		Object o = httpReq.getSession().getAttribute("user");
		if (o!=null) {
			User user = (User)o;
			if (user.isAdmin()) {
				chain.doFilter(request, response);//放行
			}else {
				httpResp.sendRedirect(httpReq.getContextPath()+"/index.jsp");
			}
		}else {
			httpResp.sendRedirect(httpReq.getContextPath()+"/index.jsp");
		}
		// pass the request along the filter chain
		
	}

	
	public void init(FilterConfig fConfig) throws ServletException {
		// TODO Auto-generated method stub
	}

}

监听器监听

request session application

package com.sun.filter;

import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.annotation.WebListener;


@WebListener
public class ApplicationAttrListener implements ServletContextAttributeListener {


    public ApplicationAttrListener() {
    }

    public void attributeAdded(ServletContextAttributeEvent arg0)  { 
System.out.println("attributeAdded："+arg0.getName()+",value:"+arg0.getValue());
    	
    }


    public void attributeRemoved(ServletContextAttributeEvent arg0)  {      System.out.println("attributeRemoved："+arg0.getName()+",value:"+arg0.getValue());
    }


    public void attributeReplaced(ServletContextAttributeEvent arg0)  { 
System.out.println("attributeReplaced："+arg0.getName()+",value:"+arg0.getValue());
    }
	
}

配置监听器

注解和配置文件不能同时存在，否则报错


  com.sun.listener.SessionListener

配置session生命周期

数据库 JDBC 安装MYSQL Connector for java

里面包含MySQL驱动

导入MySQL驱动

通过驱动里面的api访问MySQL数据库

中间人，翻译

找到C:Program Files (x86)MySQLConnector J 8.0文件夹下的mysql-connector-java-8.0.26.jar包就是驱动

操作数据库的工具包：commons-dbutils-1.7.jar

导入到库

新建文件夹lib

复制到lib里面

右击build path

链接数据库

package com.sum.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JDBCUtils {
	private static String url = "jdbc:mysql://localhost:3306/cakeshop?userUnicode=true&characterEncoding=UTF8";
	private static String root = "root";
	private static String sql_password = "123456";
	
	// 创建连接
	public static Connection getConnection() {
		// 加载驱动
		try {
			Class.forName("com.mysql.cj.jdbc.Driver");
			return DriverManager.getConnection(url,root,sql_password);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	// 关闭连接
	public static void closeAll(ResultSet rs, PreparedStatement state, Connection con) {
		try {
			if (rs!=null) rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		try {
			if (state!=null) state.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	
		try {
			if (con!=null) con.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}	
}

操作数据库

package com.sum.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCDemo01 {

	public static void main(String[] args) {
		//selectAll();
		//System.out.println(selectByUP("1", "1"));
		//selectUserByPage(1,10);
		//insert("hhh","hhj");
		//delete(19);
		update(12, "sdfsf");
	}
	
	public static void selectAll() {
		
		ResultSet rs = null;
		PreparedStatement state = null;
		Connection con = null;

		// 注册驱动 
		try {
			con = JDBCUtils.getConnection();
			
			String sql = "SELECT * FROM cakeshop.goods";
			// 执行SQL语句
			state = con.prepareStatement("SELECt * FROM cakeshop.goods");
			rs = state.executeQuery();
			
			// 输出结果
			while (rs.next()) {
				System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3)+","+rs.getString(4));
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.closeAll(rs, state, con);
		}

	}

	public static boolean selectByUP(String username,String password) {
		Connection con = null;
		PreparedStatement pstate = null;
		ResultSet rs = null;
		try {
			con = JDBCUtils.getConnection();
			// 执行语句
			String sql = "select * from user where username=? and password=?";
			pstate = con.prepareStatement(sql);
			pstate.setString(1, username);
			pstate.setString(2, password);
			
			rs = pstate.executeQuery();
			// 输出结果
			if (rs.next()) {
				return true;
			}else {
				return false;
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			JDBCUtils.closeAll(rs, pstate, con);
		}
		return false;
	}
	
	public static void selectUserByPage(int pageindex,int pagesize) {
		Connection con = null;
		PreparedStatement pstate = null;
		ResultSet rs = null;
		try {
			con = JDBCUtils.getConnection();
			
			// 执行语句
			String sql = "select * from user limit ?,?";
			pstate = con.prepareStatement(sql);
			pstate.setInt(1, (pageindex-1)*pagesize);
			pstate.setInt(2, pagesize);
			
			rs = pstate.executeQuery();
			// 输出结果
			while (rs.next()) {
				System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3)+","+rs.getString(4));
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			JDBCUtils.closeAll(rs, pstate, con);
		}
	}
	
	public static void insert(String username,String password) {
		
		ResultSet rs = null;
		PreparedStatement pstate = null;
		Connection con = null;
		
		try {
			con = JDBCUtils.getConnection();
			
			String sql = "insert into user(username,password) value(?,?)";
			pstate = con.prepareStatement(sql);
			pstate.setString(1, username);
			pstate.setString(2, password);
			int update = pstate.executeUpdate();//返回值代表受到影响的行数
			System.out.println(update);
			
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			JDBCUtils.closeAll(rs, pstate, con);
		}
	}
	
	public static void delete(int id) {
		
		ResultSet rs = null;
		PreparedStatement pstate = null;
		Connection con = null;
		
		try {
			con = JDBCUtils.getConnection();
			
			String sql = "delete from user where id = ?";
			pstate = con.prepareStatement(sql);
			pstate.setInt(1, id);
			int num = pstate.executeUpdate();//返回值代表受到影响的行数
			if (num>0) {
				System.out.println("删除成功");
			}else {
				System.out.println("删除失败");
			};
			
		} catch (Exception e) {
			System.out.println(e);
		}finally {
			JDBCUtils.closeAll(rs, pstate, con);
		}
		
		
	}
	
	
	public static void update(int id,String password) {
		
		ResultSet rs = null;
		PreparedStatement pstate = null;
		Connection con = null;
		
		try {
			con = JDBCUtils.getConnection();
			
			String sql = "update user set password=? where id=?";
			pstate = con.prepareStatement(sql);
			pstate.setString(1, password);
			pstate.setInt(2, id);
			int update = pstate.executeUpdate();//返回值代表受到影响的行数
			if (update>0) {
				System.out.println("修改成功");
			}
			
		} catch (Exception e) {
			System.out.println(e);
		}finally {
			JDBCUtils.closeAll(rs, pstate, con);
		}
		
	}
	
}

事务

转账操作，保证多个操作要么同时成功要么同时失败

con.setAutoCommit(false);//开启事务
//-----------------------------------------------------------------------//		
String sql = "update user set balance= balance - ? where username=?";
pstate1 = con.prepareStatement(sql);
pstate1.setInt(1, money);
pstate1.setString(2, userame1);
int update = pstate1.executeUpdate();//返回值代表受到影响的行数
if (update>0) {
    System.out.println("修改成功");
}

String string = null;
string.toCharArray();

String sql2 = "update user set balance= balance + ? where username=?";
pstate2 = con.prepareStatement(sql2);
pstate2.setInt(1, money);
pstate2.setString(2, username2);
update = pstate2.executeUpdate();//返回值代表受到影响的行数
if (update>0) {
    System.out.println("修改成功");
}
//-----------------------------------------------------------------------//		
con.commit();//事务提交

连接池

第三方的连接池：dbcp c3p0

package com.sum.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

public class JDBCUtils {
	private static String url = "jdbc:mysql://localhost:3306/cakeshop?userUnicode=true&characterEncoding=UTF8";
	private static String root = "root";
	private static String sql_password = "123456";
	// 创建连接池
	private static ArrayList conList = new ArrayList();
	static {
		for (int i = 0; i < 5; i++) {
			conList.add(creatConnection());
		}
	}
	// 创建连接
	public static Connection getConnection() {
		if (conList.isEmpty() == false) {
			Connection con = conList.get(0);
			conList.remove(con);
			return con;
		} else {
			return creatConnection();
		}
	}
	
	// 创建连接
	private static Connection creatConnection() {
		// 加载驱动
		try {
			Class.forName("com.mysql.cj.jdbc.Driver");
			return DriverManager.getConnection(url,root,sql_password);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	// 关闭连接
	public static void closeAll(ResultSet rs, PreparedStatement state, Connection con) {
		
		closeResultSet(rs);
		closePreparedStatement(state);
		closeConnection(con);
		
	}
	
	// 关闭连接
	public static void closeAll(ResultSet rs, PreparedStatement state1, PreparedStatement state2, Connection con) {
		
		closeResultSet(rs);
		closePreparedStatement(state1);
		closePreparedStatement(state2);
		closeConnection(con);
		
	}
	private static void closeResultSet(ResultSet rs) {
		try {
			if (rs!=null) rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	private static void closePreparedStatement(PreparedStatement state) {
		try {
			if (state!=null) state.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	private static void closeConnection(Connection con) {
//		try {
//			if (con!=null) con.close();
//		} catch (SQLException e) {
//			e.printStackTrace();
//		}
		conList.add(con);//归还连接
	}
	
	
}

c3p0连接池

需要引入c3p0和

package com.sum.jdbc;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0DateSource {
	private static String url = "jdbc:mysql://localhost:3306/cakeshop?userUnicode=true&characterEncoding=UTF8";
	private static String root = "root";
	private static String sql_password = "123456";
	
	private static ComboPooledDataSource ds;
	
	static {
		ds=new ComboPooledDataSource();
		try {
			ds.setDriverClass("com.mysql.cj.jdbc.Driver");
			ds.setJdbcUrl(url);
			ds.setUser(root);
			ds.setPassword(sql_password);
			
			ds.setInitialPoolSize(5);
			ds.setMaxPoolSize(20);
			ds.setMinPoolSize(1);
			
			
		} catch (PropertyVetoException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static Connection getConnection() {
		try {
			return ds.getConnection();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	// 关闭连接
		public static void closeAll(ResultSet rs, PreparedStatement state, Connection con) {
			
			closeResultSet(rs);
			closePreparedStatement(state);
			closeConnection(con);
			
		}
		
		// 关闭连接
		public static void closeAll(ResultSet rs, PreparedStatement state1, PreparedStatement state2, Connection con) {
			
			closeResultSet(rs);
			closePreparedStatement(state1);
			closePreparedStatement(state2);
			closeConnection(con);
			
		}
		private static void closeResultSet(ResultSet rs) {
			try {
				if (rs!=null) rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		private static void closePreparedStatement(PreparedStatement state) {
			try {
				if (state!=null) state.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		private static void closeConnection(Connection con) {
			try {
				if (con!=null) con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	
}

c3p0-config



	
		jdbc:mysql://localhost:3306/cakeshop
		com.mysql.cj.jdbc.Driver
		root
		root
		30000
		30
		10
		30
		100
		10
		200

SSH框架

框架简单的来说就是半成品，通过半成品可以更快的开发项目

数据结构与算法什么是算法

算法是用于解决特定问题的一系列执行步骤

使用不同的算法，解决同一个问题，效率可能相差非常大

比如：求第N个斐波那契数（fibonacci number）

package com.mj;

import javax.xml.transform.Templates;

public class Main {

	
	
	
	public static int fib(int n) {
		if (n<=1) return n;
		return fib(n-1)+fib(n-2);
	}
	
	public static int fib2(int n) {
		int first = 0;
		int second = 1;
		for (int i = 0; i < n-1; i++) {
			int temp = first;
			first = second;
			second = temp+second;
		}		
		return second;
	}
	
	public static void main(String[] args) {
		System.out.println(fib2(64));	
		
	}

}

评估算法

正确性，可读性，健壮性（对不合理输入的反应能力和处理能力）

时间复杂度

估算程序指令的执行次数（执行时间）

空间复杂度

估计所需占用的存储空间

大O表示法时间复杂度和空间复杂度

低阶的部分直接省略

常数阶：忽略常数 > > O ( 1 ) ; 忽略常数>>O(1); 忽略常数>>O(1);对应无循环

system.out.println("..");

线性阶： 2 n + 3 > > O ( n ) ; 2n+3>>O(n); 2n+3>>O(n); 一个循环n次的代码+一个有限的代码

for(int i=0;i 
平方阶：
    
     
      
       
        n
       
       
        ²
       
       
        +
       
       
        2
       
       
        n
       
       
        +
       
       
        3
       
       
        >
       
       
        >
       
       
        O
       
       
        (
       
       
        n
       
       
        ²
       
       
        )
       
       
        ;
       
       
        
       
      
      
       n²+2n+3>>O(n²);
      
     
    n²+2n+3>>O(n²);两个嵌套循环n的代码 
for(int i=0;i 
立方阶：
    
     
      
       
        4
       
       
        n
       
       
        ³
       
       
        +
       
       
        n
       
       
        ²
       
       
        +
       
       
        2
       
       
        n
       
       
        +
       
       
        3
       
       
        >
       
       
        >
       
       
        O
       
       
        (
       
       
        n
       
       
        ³
       
       
        )
       
      
      
       4n³+n²+2n+3>>O(n³)
      
     
    4n³+n²+2n+3>>O(n³) 三个循环n次的代码 
for(int i=0;i 
对数阶一般省略底数，
    
     
      
       
        l
       
       
        o
       
       
        
         g
        
        
         2
        
       
       
        n
       
      
      
       log_2n
      
     
    log2n和
    
     
      
       
        l
       
       
        o
       
       
        
         g
        
        
         8
        
       
       
        n
       
      
      
       log_8n
      
     
    log8n统称
    
     
      
       
        l
       
       
        o
       
       
        g
       
       
        n
       
      
      
       logn
      
     
    logn。 
对数阶：
    
     
      
       
        l
       
       
        o
       
       
        g
       
       
        ₂
       
       
        n
       
       
        =
       
       
        l
       
       
        o
       
       
        g
       
       
        ₂
       
       
        9
       
       
        ∗
       
       
        l
       
       
        o
       
       
        
         g
        
        
         9
        
       
       
        n
       
       
        >
       
       
        >
       
       
        O
       
       
        (
       
       
        l
       
       
        o
       
       
        g
       
       
        n
       
       
        )
       
      
      
       log₂n = log₂9*log_9n>>O(logn)
      
     
    log₂n=log₂9∗log9n>>O(logn) 循环条件为：
    
     
      
       
        i
       
       
        <
       
       
        n
       
       
        ,
       
       
        i
       
       
        =
       
       
        2
       
       
        i
       
       
        ;
       
       
        n
       
       
        =
       
       
        
         2
        
        
         n
        
       
      
      
       i 
for(int i=0;i 
nlogn阶：
    
     
      
       
        n
       
       
        l
       
       
        o
       
       
        g
       
       
        ₂
       
       
        n
       
       
        >
       
       
        >
       
       
        O
       
       
        (
       
       
        n
       
       
        l
       
       
        o
       
       
        g
       
       
        n
       
       
        )
       
       
        
       
      
      
       nlog₂n >>O(nlogn)
      
     
    nlog₂n>>O(nlogn) 
for(int i=0;i 
指数阶：
    
     
      
       
        
         2
        
        
         n
        
       
       
        >
       
       
        >
       
       
        O
       
       
        (
       
       
        
         2
        
        
         n
        
       
       
        )
       
      
      
       2^n>>O(2^n)
      
     
    2n>>O(2n) 
 

    
     
      
       
        O
       
       
        (
       
       
        1
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        l
       
       
        o
       
       
        g
       
       
        n
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        n
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        n
       
       
        l
       
       
        o
       
       
        g
       
       
        n
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        n
       
       
        ²
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        n
       
       
        ³
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        
         2
        
        
         n
        
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        n
       
       
        !
       
       
        )
       
       
        <
       
       
        O
       
       
        (
       
       
        
         n
        
        
         n
        
       
       
        )
       
      
      
       O(1) 
算法网站 
https://leetcode-cn.com/problemset/algorithms/ 
线性表 
动态数组 
特点：增改查复杂度为O(1),增加数据如果需要扩容复杂度是O(n) 
缺点：添加数据需要扩容O(n)，插入删除数据复杂度为O(1~n) 
链表 
特点：增删改查，O(1~n)，不需要扩容，节省内存 
循环链表

Java学习笔记

注册

Java相关栏目本月热门文章