【笔记】JAVA期末复习[下]

​ 2021年JAVA期末复习笔记

数据库编程

1. JDBC工作原理

   JDBC API：由SUN公司提供，供程序员调用的接口

   Connection接口：负责数据库连接
   Statement接口：负责数据库操作：增加、删除、修改、查询
   ResultSet接口： 负责数据库返回结果处理

   Connection ：负责连接数据库并担任传送数据的任务
   Statement ：由 Connection 产生、负责执行SQL语句
   ResultSet：负责保存Statement执行后所产生的查询结果

   

2. 驱动管理

   DriverManager类：Sun公司提供

   JDBC驱动：数据库厂商提供

3. JDBC工作模板【查询】

4. import java.sql.*;
   
   public class Main{
       static final String JDBC_DRIVER="com.mysql.jdbc.Driver";
       
       public static void main(String[] agrs){
           try {
               Class.forName(JDBC_DRIVER);
           } catch (ClassNotFoundException e) {
               //这里会发生类没有找到的异常！
               e.printStackTrace();
           }
           
           try{
               Connection con = DriverManager.getConnection("url","zhanghu","mima");
               Statement stmt = con.createStatement();
               String sql = "SELECT a, b, c FROM Table1";
               ResultSe	t rs = stmt.executeQuery(sql);
               
               while(!rs.next()){
                int x = rs.getInt("a");
                String s = rs.getString("b");
                float f = rs.getFloat("c");
               }
               
               rs.close();
               stmt.close();
               con.close();
               
           }catch (SQLException e){
               e.printStackTrace();
           }
       } 
   } 
      
   
      
   
   5. JDBC工作模板【插入】
   
      ```java
      import java.sql.*;
      
      public class Main{
          static final String JDBC_DRIVER="com.mysql.jdbc.Driver";
          
          public static void main(String[] agrs){
              try {
                  Class.forName(JDBC_DRIVER);
              } catch (ClassNotFoundException e) {
                  //这里会发生类没有找到的异常！
                  e.printStackTrace();
              }
              
              try{
                  Connection con = DriverManger.getConnection("jdbc:mysql://localhost:3306/demo","root","123456");
                  String sql = "Insert into 表名(列名,列名) values(?,?)";
      			PreparedStatement pstm = con.prepareStatement(sql);
                  //从控制台得到参数
                  Scanner s = new Scanner(System.in);
                  System.out.println("请输入id：");
                  int id_get = s.nextInt();
                  System.out.println("请输入name：");
                  String name_get = s.nextLine();
                  //插入  （index,值）
                  pstm.setInt(1,id_get);
                  pstm.setString(2,name_get);
                  pstm.execute();
                  
              }
          } 
      } 
   
   
   
   

5. JDBC工作模板【改】

   update 表名称 set 列名称=新值 where 更新条件;

import java.sql.*;
public class Main{
       static final String JDBC_DRIVER="com.mysql.jdbc.Driver";
	public static void main(String[] agrs){
        try {
               Class.forName(JDBC_DRIVER);
        } catch (ClassNotFoundException e) {
               //这里会发生类没有找到的异常！
            e.printStackTrace();
           }

           try{
            Connection con = DriverManger.getConnection("jdbc:mysql://localhost:3306/demo","root","123456");
               sql = "update users set 参数1=?,参数2=? where 参数3=?""
            PreparedStatement pstmt = con.prepareStatement(sql);

               pstmt.setInt(1,要给参数1改的值);
               pstmt.setString(2,要给参数2改的值);
               pstmt.setString(3,目标值);

            //执行sql语句，返回影响行数
               int res=pstmt.executeUpdate();
                if(res>0){
                    System.out.println("更新数据成功");
                }
                pstmt.close();
                conn.close();
               }
           } 
   } 

1.数据库驱动：Driver

加载mysql驱动：Class.forName(“com.mysql.jdbc.Driver”);

加载oracle驱动：Class.forName(“oracle.jdbc.driver.OracleDriver”);

加载相应的驱动需要导入相应的包，如MySQL则需要导入：mysql-connector-java-5.1.13-bin.jar

否则无法正常执行。

2.获取数据库链接：Connection

Connetion类主要用来链接数据库，常通过DriverManager.getConnection()来获取一个连接对象。
这里有3个参数，分别是url，user，passwrod。对应的是要链接的数据库，用户名，密码等。如：
url=jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8
user=root
password=root

3.执行sql语句：Statement

Statement对象用于执行sql语句，有以下3种：

（1）Statement对象用于执行不带参数的简单的SQL语句；

（2）PerparedStatement对象用于执行带或不带参数的预编译SQL语句；

（3）CallableStatement对象用于执行对数据库已存储过程的调用；

​ Statement的常用方法：

（1）executeQuery()方法：运行查询语句，返回ReaultSet对象。

（2）executeUpdata()方法：运行增，删，改操作，返回更新的行数。

（3）addBatch(String sql) ：把多条sql语句放到一个批处理中。

（4）executeBatch()：向数据库发送一批sql语句执行。

4.结果集：ResultSet

执行executeQuery()方法后返回的结果集

​ 常用方法：
（1）getString(String columnName)：获得当前行的某一string类型的字段
（2）getFloat(String columnName)：获得当前行的某一string类型的字段
（3）getDate(String columnName)：获得当前行的某一date类型的字段
（4）getBoolean(String columnName)：获得在当前行的某一Boolean类型的字段
（5）getObject(String columnName)：获取当前行的某一任意类型的字段
（6）next()：移动到下一行

文件操作

1. 比较文件是否相同

   try{
   	File f1 = new File("test");
       File f2 = new File("test2");
       FileInputStream file1 = new FileInputStream(f1);
       FileInputStream file2 = new FileInputStream(f2);
       if(file1.available() == file2.available()){
           whie(file1.read() != -1 && file2.read() != -1 ){
               if(file1.read() != file2.read()){
                   System.out.printlf("NO");
               }
           }
           System.out.println("Yes");
       }else{
           System.out.println("NO");
       } catch (Exception e) {
           System.out.println("打开失败");
           e.printStackTrace();
       }
   }

2. 输入文件操作必须用try…catch结构执行
   文件无数据可读read函数返回-1
   如果数组b为null, 抛出NullPointerException;
   如果off+len>总长度, 执出IndexOutBoundException;
   如果文件不存在，抛出FileNoutFoundException;
   磁盘故障等抛出IOException.

文件夹创建

我们可以使用File类的createNewFile()方法创建一个新文件：

File dummyFile = new File("test.txt");
boolean fileCreated  = dummyFile.createNewFile();

该createNewFile()方法创建一个新的空文件，如果有指定名称的文件不存在。

如果文件已成功创建，则返回true;否则，返回false。如果发生I/O错误，该方法将抛出IOException。

我们还可以在默认的临时文件目录或目录中创建一个临时文件。要在默认临时目录中创建临时文件，请使用File类的createTempFile()静态方法，该方法接受前缀和后缀以生成临时文件名。

File  tempFile = File.createTempFile("abc", ".txt");

文件夹创建

我们可以使用mkdir()或mkdirs()方法创建一个新目录。

仅当路径名中指定的父目录已存在时，mkdir()方法才创建目录。

File newDir  = new File("C:\\users\\home");

只有当C:\users目录已经存在时，newDir.mkdir()方法才会创建主目录。

newDir.mkdirs()方法将创建users目录（如果它不存在于C：驱动器中），它将在C:\users目录下创建主目录。

文件删除

我们需要使用File类的delete()方法来删除文件/目录。

目录必须为空，我们才能删除它。

如果文件/目录被删除，该方法返回true; 否则，返回false。

我们还可以延迟删除文件，直到JVM通过使用deleteOnExit()方法终止。

如果我们在程序中创建临时文件，当程序退出时要删除，这将非常有用。

立即删除dummy.txt文件

File dummyFile = new File("dummy.txt"); 
dummyFile.delete();

在JVM终止时删除dummy.txt文件

File dummyFile = new File("dummy.txt"); 
dummyFile.deleteOnExit();

文件重命名

要重命名文件，我们可以使用renameTo()方法，它使用一个File对象来表示新文件:

boolean fileRenamed = oldFile.renameTo(newFile);

列出文件和目录

我们可以使用File类的listRoots()静态方法获取文件系统中可用根目录的列表。 它返回一个File对象数组。

File[] roots = File.listRoots();

以下代码显示如何列出所有可用的根目录。

import java.io.File;

public class Main {
  public static void main(String[] args) {
    File[] roots = File.listRoots();
    System.out.println("List  of  root directories:");
    for (File f : roots) {
      System.out.println(f.getPath());
    }
  }
}

我们可以使用File类的list()或listFiles()方法列出目录中的所有文件和目录。

list()方法返回一个String数组，而listFiles()方法返回一个File数组。

我们还可以使用这些方法的文件过滤器从返回的结果中排除一些文件和目录。

以下代码显示如何列出目录中的所有文件和目录。

import java.io.File;

public class Main {
  public static void main(String[] args) {
    // Change the dirPath value to list files from your directory
    String dirPath = "C:\\";

    File dir = new File(dirPath);
    File[] list = dir.listFiles();

    for (File f : list) {
      if (f.isFile()) {
        System.out.println(f.getPath() + "  (File)");
      } else if (f.isDirectory()) {
        System.out.println(f.getPath() + "  (Directory)");
      }
    }
  }
}

读操作（Read）

将文件中的数据读入程序，是将程序外部的数据传入程序中，应该使用输入流——InputStream或Reader。而由于读取的是特定的数据源——文件，则可以使用输入对应的子类FileInputStream或FileReader实现。

关于FileInputSream类：

• 继承于InputStream类，这是一个文件输入流，进行文件读操作的最基本的类
• 作用是将文件中的数据输入到内存中，我们可以用它来读文件操作
• 由于字节流的缘故，因此无法读取中文字符

在实际书写代码时，需要首先熟悉读取文件在程序中实现的过程。在Java语言的IO编程中，读取文件是分两个步骤：

1、将文件中的数据转换为流（由系统完成，只需要创建对应的流对象即可）；
2、读取流内部的数据（第二个步骤使用输入流对象中的read方法即可实现）；

使用输入流进行编程时，代码一般分为3个部分：

1、创建流对象，

fis = new FileInputStream("e:\\a.txt");

2、读取流对象内部的数据，

​ 读取流fis中的数据，需要使用read方法，该方法是从InputStream类中继承过来的方法，该方法的作用是每次读取流中的一个字节，如果需要读取流中的所有数据，需要使用循环读取，当到达流的末尾时，read方法的返回值是

int n = fis.read();

将读取的值赋值给int值n，如果流fis为空，则n的值是-1，否则n中的最后一个字节包含的时流fis中的第一个字节，该字节被读取以后，将被从流fis中删除。环读取流中的其它数据，如果读取到的数据不是-1，则将已经读取到的数据n强制转换为byte，即取n中的有效数据——最后一个字节，并存储到数组data中，然后调用流对象fis中的read方法继续读取流中的下一个字节的数据。一直这样循环下去，直到读取到的数据是-1，也就是读取到流的末尾则循环结束。

3、关闭流对象。

字符流

格式化输入－使用java.util.Scanner类

看这个就行：
1.读操作
Scanner in=new Scanner(new BufferedInputStream(new FileInputStream("input.txt")),"UNICODE");
in.next();
2.写操作：
PrintWriter pw=new PrintWriter(new BufferedOutputStream(new FileOutputStream("a1.txt")));
pw.printf("%4d",c);
3.可读可写操作：
File f=new File(filename);
 try{ RandomAccessFile raf=
            new RandomAccessFile(f,"rw");
    }
raf.read();
raf.write(x);
raf.seek(w)

example1：读操作

{ 
    public static void main(String args[]) 
  { try  { Scanner in=new Scanner(new 
              BufferedInputStream(new FileInputStream
              ("input.txt")),"UNICODE");		//看这个就行。BufferedInputStream(new FileInputStream("xx.txt"),"UNICODE")
              String []s=new String[4];
              for(int i=0;i<4;i++) s[i]=in.next();
              in.close();
              for(int i=0;i<4;i++) System.out.println(s[i]);
           }
    catch(Exception e){}
  }
}

example2：写操作

import java.io.*;
import java.util.Scanner;
public class C6_11
{ public static void main(String args[])
  { try{ PrintWriter pw=new PrintWriter
            (new BufferedOutputStream
            (new FileOutputStream("a1.txt")));
            Scanner in=new Scanner(System.in);
            int c,i,j,n;
            System.out.print("Input n=");
            n=in.nextInt();
      for(i=1;i<=n;i++)
      { for(j=1;j<=n-i;j++)
           { System.out.printf("%4s",""); pw.printf("%4s","");}
         c=1;System.out.printf("%4d",c);pw.printf("%4d",c);
         for(j=1;j<i;j++) 
           { c=c*(i-j)/j;
              System.out.printf("%8d",c);pw.printf("%8d",c);
           }
        System.out.println();pw.println();
      }
      pw.close();
    } catch(Exception e) {}   } }

Servlet

Servlet的作用是响应客户端请求，做出处理，使得客户端与服务器端有交互

Servlet API： Servlet规范定义了一套专门用于开发Servlet程序的Java类和接口，这些类和接口提供 Servlet程序开发所涉及的各种功能，它们统称为Servlet API.

HttpServlet

1. Servlet API中提供了专用于HTTP协议的Servlet类——javax.servlet.http.HttpServlet
   HttpServlet实现了Servlet接口
   HttpServlet重写了Servlet接口定义的service方法，为应对浏览器的HTTP请求提供了基础结构
2. 开发中我们编写一个JAVA类使其成为Servlet的实际做法：
   编写一个JAVA类，继承javax.servlet.http.HttpServlet
   覆写HttpServlet类的doGet()或doPost()方法
   Servlet不需要main方法，客户端GET请求到来时，服务器自动调用Servelt的doGet方法，POST请求，自动调用doPost方法

HttpServletRequest

1. 读取请求参数方法

   • getParameter

     参数名区分大小写
     指定名称参数存在但没有设置值，返回空串
     getParameter方法通常用于获取在HTTP请求消息中仅出现一次的参数，即单个值的读取

   • getParameterValues

     返回某个指定名称的所有参数的值

2. 正确提交至Servlet的写法

   页面中写法：WEB.XML配置文件中的Servlet访问路径前 + “ /当前应用 ”

HttpServletResponse

1. 客户端对于Servlet的每次访问请求，Servlet容器都会创建一个用于封装HTTP请求的对象和一个代表HTTP响应消息的对象，当调用Servlet的doGet或doPost方法时，这两个对象会作为参数被传递进去【因此你要重写doGet方法或者doPost方法】

2. 输出响应内容

   getWriter
   返回一个（文本）字符输出流对象
   专用于输出内容为文本字符的网页文档
   getOutPutStream
   返回一个字节输出流对象
   如果要输出二进制格式的响应正文，应该使用该方法

   PrintWriter out = response.getWriter();
   以下方法都可以创建输出
   out.print();
   out.println();
   out.write();
   out.writeln();

3. 设置响应消息头

   HttpServletResponse的setContentType方法设置响应消息头“Content-Type”
   设置Servlet输出内容的MIME类型，网页文档的类型通常为“text/html”
   在类型后面还可以指定响应内容的字符集编码类型，如果不指定，采用默认ISO8859-1字符集编码

   response.setContentType(“text/html;charset=utf-8");

重定向

​ HttpServletResponse的sendRedirect方法实现请求重定向
​ location参数指定了重定向的URL，可以采用相对或绝对路径
​ 浏览器地址栏发生变化，显示为location所指向的URL

String username = request.getParameter("userName");
String pwd = request.getParameter("pwd");

if(username.equals("tom")&&pwd.equals("123")){
  response.sendRedirect("/ResponseDemo/index.html");
}else{
  response.sendRedirect("/ResponseDemo/error.html");
}

常用方法

import javax.servlet.*;
public class formservlet extends HttpServlet{
    @Override
    public void doGet(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException{
	response.setContentType();
    PrinterWriter pw = response.getWriter();
    pw.println("")		//写东西
   	request.getParameter("id");	//取参
}

Web

数据库与web综合。

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>jsptest</title>
  </head>
  <body>
    <form name="form1" method="post" action="2.jsp">
     id: <input name="id" type="text">
      name:<input name="name" type="text">
        <input type="submit" 提交>
    </form>
  </body>
</html>

2.jsp

<%--
  Created by IntelliJ IDEA.
  User: 10147
  Date: 2021/12/24
  Time: 22:37
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.*" %>
<%@ page import="java.sql.*" %>

<html>
<head>
    <title>Title</title>
    <meta name="website" content="http://www.crazyit.org" />
</head>
<body>
<h2>get information</h2>
<%
    request.setCharacterEncoding("utf-8");
    String name=request.getParameter("name");
    String id = request.getParameter("id");
    out.print("id为："+id+"<br>");
    out.print("name为："+name+"<br>");

    Class.forName("com.mysql.cj.jdbc.Driver");//记载数据库驱动，注册到驱动管理器
    String url="jdbc:mysql://localhost:3306/demo";
    String username="root";
    String password="123456";
    Connection con=DriverManager.getConnection(url,username,password);
    String sql = "insert into customer(id,name) values(?,?)";
    PreparedStatement pstm = con.prepareStatement(sql);

    try{
        pstm.setString(1,id);
        pstm.setString(2,name);
        out.print("插入成功！");
    } catch (SQLException e){
        e.printStackTrace();
    }

    out.print("test");
%>
</body>
</html>

html部分
<html>
    <head>
        <h1>
           test 
        </h1>
    </head>
    <body>
        <form action="2.jsp" method="post">
            姓名：<input name="usr_name" type="text">
        	学号：<input name="usr_id" type="text">
            <input type="submit" 提交>
        </form>
    </body>
</html>

2.jsp:
<%@ page import="java.sql.*;" %>
<%@ page import="java.util.*;" %>

<html>
    <title>nothing</title>
    <body>
        <%
        	private static String JDBC_DRIVER = "com.mysql.jdbc.Driver";
        	request.setContentType("utf-8");
        	Class.forName(JDBC_DRIVER);
        	
        	String usr_name_get = request.getParameter("usr_name");
        	String usr_id_get = request.getParameter("usr_id");
            Connection con=DriverManager.getConnection(url,username,password);
            String sql = "select name,id from students where id=? and name?"
			PreparedStatement stmt = con.prepareStatement(sql);
        	stmt.setString(1,usr_name_get);
        	stmt.setString(2,usr_id_get);
        	stmt.execute();
        %>
    </body>
</html>

试题

• Java程序只有两类：Application和Applet

• Java属于（ A ）型语言。
  A.解释 B.编译 C.多线程性 D.安全性

• 简述Java中异常处理的机制？

答：首先Java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象.当出现异常情况时，一个Exception对象就产生了,并放到异常的成员函数里。
Java的异常处理是通过5个关键词来实现的：try,catch,throw,throws和finally。
1.异常处理：在Java语言的错误处理结构由try，catch，finally三个块组成。其中try块存放将可能发生异常的Java语言，并管理相关的异常指针；catch块紧跟在try块后面，用来激发被捕获的异常；finally块包含清除程序没有释放的资源，句柄等。不管try块中的代码如何退出，都将执行 finally块。
2.抛出异常：Java语言可以不在方法中直接捕获，而用throw语句将异常抛给上层的调用者。Throw语句就是来明确地抛出一个异常；首先你必需得到一个Throwable的实例句柄，通过参数传到catch中，或者采用new操作符来创建一个。

• 什么是继承？

答：通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，并把这种关系称为继承，先定义的类称为父类，后定义的类称为子类，并且允许多层的继承关系。

• 请简述重载和重写的区别？

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

• public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  应用程序的main方法中有以下语句，则输出的结果是 B( )。
  
  String   s="12345#aaa#bbb#67890";
  	int     n=s.indexOf("#");
  	int     k=s.indexOf("#",n+1);
  	int     m=s.indexOf("#",k+1);
  	String  s2=s.substring(m+1);
  	System.out.println(s2);	
  A) 123456 B) 67890 C) aaa D) bbb
  
  ps：
  public static void main(String[] args){
          String s="12345#aaa#bbb#67890";
          int n=s.indexOf("#");
          // public  int indexOf(int ch) 
          //返回指定字符在此字符串中第一次出现处的索引。所以 n 的值为5;
          int k=s.indexOf("#",n+1); //9
          int m=s.indexOf("#",k+1); //13
          /* public int indexOf(int ch,  int fromIndex)
           * 返回在此字符串中第一次出现指定字符处的索引，
           * 从指定的索引开始搜索。 所以k为9, m为13
           */
          String s2=s.substring(m+1);
          /*
           * 返回一个新的字符串，它是此字符串的一个子字符串。
           * 该子字符串从指定索引处的字符开始，直到此字符串末尾。
           * 所以从第十四位到最后一位字符串是67890
           */
          System.out.println(s2);
      }

package ListSixNine;

 

interface ClassName {

public String getClassName();

}

 

package ListSixNine;

 

class Company implements ClassName {

public String getClassName(){

return "Company";

}

}

 

package ListSixNine;

 

public class TestDemo07 {

public static void main(String []args){

ClassName name=new Company();

System.out.println(name.getClassName());

}

}

 

结果：

Company