java期末
java知识
1.Javac.exe java.exe javap.exe javadoc.exe的含义和用法; Javac A.java java A Javap? Javadoc?
javac.exe 是编译程序,用于编译.java文件
java.exe 是执行程序,用于执行编译好的.class文件
javadoc.exe 是JAVA文档工具,用于生成Java说明文档
jdb.exe 是调试器,用于调试JAVA代码
javaprof.exe 是剖析工具
2.Java的输入和输出:scanner: hasNext(),nextlnt(),…; print println printf(“%d”,10)的类对象和方法;
输入:
scanner:
public class scanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //生成scanner对象
System.out.print("请输入你的姓名:");
String name = sc.nextLine();//输入字符串
System.out.print("请输入你的年龄:");
int age = sc.nextInt();//输入整数
System.out.println("姓名:" + name +"\n" +"年龄:" + age);
}
}
nextInt() 输入整数
nextLine() 输入字符串
nextDouble() 输入双精度数
next() 输入字符串(以空格作为分隔符
JOptionPane
io.Console
import java.io.Console;//导入java.io.Console
public class User {
public static void main(String[] args) {
Console con = System.console();//建立安全输入
String name = con.readLine("请输入账号:");
String passworld = con.readLine("请输入密码:");
System.out.printf("账号:%s", name);
System.out.printf("%n密码:%s", passworld);
}
}
输出:
System.out.print() 不换行直接输出
public class User {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.print(a);//print()不换行输出a的值
System.out.print(b);//print()不换行输出b的值
}
}
System.out.println() 换行输出
public class User {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a);//println()换行输出a的值
System.out.println(b);//println()换行输出b的值
}
}
System.out.printf() 格式化输出
public class User {
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.printf("a=%d%n",a);//printf()格式化输出
System.out.printf("b=%d",b);//printf()格式化输出
}
}
3.String 的定义方法、=或new(区别);注意格式;string stringbuffer的定义;2个类的区别和转换方法。区别。赋值或定义方法。常用方法的含义。
2个类常用方法有哪些,对比区别。上网查详细。 Insert replace append chatAt setCharAt
String ->stringbuffer 转换方法.toString() (strngbuffer(string 对象))stringBuffer – > string
S1=”abcd” s2=”abcd” s3=new String(“abcd”) s4=new String(“abcd”)
=后面是常量 new后面是堆空间
String:
1.String创建的对象是不可变的,一旦创建不可改变
2.对象值可以改变其实是创建了一个新的对象,然后把新的值保存进去
3.String类被final修饰,不可以被继承
4.String创建的对象的值存在于常量池,不用的时候不会被销毁
5.String运行时间较长
6.String适用于比较短而小的字符串
StringBuffer:
1.StringBuffer创建的对象是可变的
2.它的改变不像String那样重新创建对象,而是通过构造方法
3.StringBuffer创建的对象的值存在于栈区,不用的时候会被销毁
4.StringBuffer运行时间较短
5.StringBuffer适用于比较长的字符串、比较多的字符串
StringBuffer –> String
1、构造 String str1 = new String(stringBuffer);
2、toString String str2 = stringBuffer.toString();
String —> StringBuffer
1、构造 StringBuffer stringBuffer1 = new StringBuffer(str);
2、append StringBuffer stringBuffer2 = new StringBuffer(); stringBuffer2.append(str);
String类常用方法
1.获取:
1)获取字符串str长度
int i = str.length();
2)根据位置(index)获取字符
char c = str.charAt(index);
3)获取字符在字符串中的位置
int i =str.indexOf(char ch); //获取的是第一次出现的位置
int i =str.indexOf(char ch ,int index); //从位置index后获取ch出现的第一次的位置
int i =str.indexOf(str1) ;// 获取str1 在str 第一次出现的位置
int i=str.indexOf(str1, index0);//获取从index位置后str第一次出现的位置
int i = str.lastIndexOf(ch或者 str1) //获取ch或者str1最后出现的位置
2.判断
1)判断是否以指定字符串str1开头、结尾
boolean b = str.startWith(str1) //开头
boolean b = str.endsWith(str1) //结尾
2)判断是否包含某一子串
boolean b = str.contains(str1)
3)判断字符串是否有内容
boolean b = str.isEmpty();
4)忽略大小写判断字符串是否相同
boolean b = str.equalsIgnoreCase(str1);
3.转换
1)将字符数组 -char[] ch- 转化成字符串
i. String str =new String(ch); //将整个数组变成字符串
ii. String str =new String(ch,offset,count)
//将字符数组中的offset位置之后的count个元素转换成字符串
1. String str =String.valueOf(ch);
2. String str =String.copyValueOf(ch,offset,count);
3. String str =String.copyValueOf(ch);
2)将字符串转化为字符数组
char[] ch = str.toCharAarray();
3)将字节数组转换为字符串
同上1) 传入类型变为Byte[];
4)将字符串转换为字节数组
Byte[] b = str.toByteArray();
5)将基本数据类型装换成字符串
String str = String.valueOf(基本数据类型数据);
若是整形数据可以用 字符串连接符 + “”
eg : String str = 5+””;
得到字符串 “5”
4.替换 replace();
str.replace(oldchar,newchar)//将str里oldchar变为newchar
str.replace(str1,str2)//将str中str1,变为str2
5.切割 split();
String[] str1 = str.split(“,”); //将str用 “,”分割成String数组
6.子串
String s = str.substring(begin);
// s 为 str 从begin位置到最后的字符串
String s = str.substring(begin,end)
//s 是 str 从begin 位置到end 位置的字符串
7.转换大小写:
String s1 = str. toUpperCase(); //将str变成大写字母
String s2 = str. toLowerCase(); //将str变成小写字母
除去空格:
String s =str.trim();
比较:
int i = str.compareTo(str1);
StringBuffer常用方法
/***StringBuffer 是一个容器,长度可变,可以直接操作字符串,用toString方法变为字符串 **/
1.存储
1)append(); //将指定数据加在容器末尾,返回值也是StringBuffer
eg:
StringBuffer sb = new StringBuffer(//可以加str);
StringBuffer sb1=ab.append(数据) //数据可以任何基本数据类型
注:此时sb == sb1他们是同一对象,意思是可以不用新建sb1直接 sb.append(数据) 使用时之后接使用sb
2)insert();// 插入
sb.insert(index ,数据);2.删除
sb.delete(start ,end); //删除start到end的字符内容
//注意:这里的所有包含index的操作都是含头不含尾的
sb.deleteCharAt(index);//删除指定位置的字符
//清空StringBuffer缓冲区
sb=new StringBuffer();
sb.delete(0,sb.length());3.获取
char c = sb.charAt(index);//获取index上的字符
int i = sb.indexOf(char)://获取char字符出现的第一次位置
//与 String 中的获取方法一致参考前面
4.修改 String类中无次操作方法
sb =sb.replace(start,end,string)//将从start开始到end的字符串替换为string;
sb.setCharAr(index ,char);//将index位置的字符变为新的char
5.反转 sb.reverse();//将sb倒序6. getChars(int srcBegin,int srcEnd,char[] ch,int chBegin)
//将StringBuffer缓冲区中的指定数据存储到指定数组中
4.a和A、0的ascii码值多少。a97 A65 048
5.数组的length是方法还是属性 a.length a[i].length(不规则变长数组) 属性
数组具有 length 属性 用 数组变量名.length 可获得数组长度。
int[] arr = new int[8];
int lengthInt=arr.length; //获得数组长度
System.out.println(lengthInt); // 打印结果8
字符串(String)具有 length()方法
String str = "abcdefg";
int lengthStr = str.length(); //获得字符串长度
System.out.println(lengthStr); // 打印结果7
字符串(String) 底层实现时 利用 char[] value; 字符型数组
字符串(Stingth) 中 length()方法源码:
public int length() {
return value.length;
}
同样基于数组的 length 属性。
创建字符串数组时,获得数组的长度也是要利用 数组length属性
String[] strs = {"香蕉","苹果","梨","西瓜","麻瓜"};
int lengthStrs =strs.length;
System.out.println(lengthStrs); // 数组长度为5
任何数组都有 length属性 访问长度时用 .length
6.final的字义是终极,修饰类\方法\变量,及含义,
final关键字可以修饰类、方法、变量,当final修饰类、方法、变量时,分别表示: 类不可被继承;方法不能被重写;变量值不能被更改。
final类
final修饰的类不能被继承,即不能有子类。当子类继承父类时,将可以直接访问到父类内部数据,这可能会导致一些安全问题。为了保证一个类不可被继承,可以使用final来修饰类。
final方法
final修饰的方法不可被重写,如果不希望子类重写父类的某个方法,则使用final修饰该方法
注:final修饰的方法不能被重写,能被重载。
final变量
final修饰的变量一旦获得了初始值就不可被改变,final修饰的变量必须由程序员显示地指定初始值,系统不会对final成员进行隐式初始化。
final修饰的类变量和实例变量能指定初始值的地方如下:
(1)final类变量(static修饰的变量):
在静态初始化块中指定初始值
声明该变量时指定初始值
注:以上两个只需满足其中之一,不能同时指定
(2)final实例变量
在非静态初始化块中指定初始值
声明该实例变量时指定初始值
构造器中指定初始值
注:以上三个只需满足其中之一,不能同时指定
7.Swing界面问题:布局方式有哪些,默认布局Flowayout; Border、Grid、Card,null含义。键盘时间shift/ctrl+F/N如何判断及实现?(是否按下)
1、 边界布局(BorderLayout)
2、流式布局(FlowLayout)
3、网格布局(GridLayout)
4、盒子布局(BoxLaYout)
5、空布局(null)
还有其他两种布局,分别是GridBagLayout(网格包布局)、CardLayout(卡片布局)
注意:JFrame和JDialog默认布局为BorderLayout,JPanel和Applet默认布局为FlowLayout
OnKeyDown事件:
procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if Shift>=[ssShift] then //如果按下了Shift键则在第一个面板上显示Shift}
StatusBar1.Panels[0].Text:= 'Shift';
if Shift>=[ssAlt] then //如果按下了Alt键则在第二个面板上显示Alt}
StatusBar1.Panels[1].Text:= 'Alt';
if Shift>=[ssCtrl] then //如果按下了C t r l 键则在第三个面板上显示Ctrl}
StatusBar1.Panels[2].Text:= 'Ctrl';
end;
8.try-catch-finally:try有,catch必有,finally可选。finally如有必执行一次。
catch中的父子关系的异常类的前后放置位置. 子前父后,Exception放最后
try{
//代码执行区域
}catch(Exception e){
//异常处理区域
}finally{
//无论如何都会执行的代码区域
}
try、catch、finally语句块的执行顺序:
1)当try没有捕获到异常时:try语句块中的语句逐一被执行,程序将跳过catch语句块,执行finally语句块和其后的语句;
2)当try捕获到异常,catch语句块里没有处理此异常的情况:此异常将会抛给JVM处理,finally语句块里的语句还是会被执行,但finally语句块后的语句不会被执行;
3)当try捕获到异常,catch语句块里有处理此异常的情况:在try语句块中是按照顺序来执行的,当执行到某一条语句出现异常时,程序将跳到catch语句块,并与catch语句块逐一匹配,找到与之对应的处理程序,其他的catch语句块将不会被执行,而try语句块中,出现异常之后的语句也不会被执行,catch语句块执行完后,执行finally语句块里的语句,最后执行finally语句块后的语句。
9.IO流式读写:
InputStream和outputStream是字节流、Reader和Writer是字符流。基础类是FilelnputStream和FileReader, BufferReader、BufferlnputStream、DataXXXX,ObjectXXX等是高级读类,必须通过基础类才能访问到文件,不能直接访问文件。
Readline(); writer(); newLine();
I/O流基础概念
- 输入流:只能读取数据,不能写入数据。
- 输出流:只能写入数据,不能读取数据。
因为程序是运行在内存中,以内存角度来理解输入输出概念,如下:
按照处理的数据单位分为字节流和字符流
- 字节流:操作的数据单元是8位的字节。InputStream、OutputStream作为抽象基类。
- 字符流:操作的数据单元是字符。以Writer、Reader作为抽象基类。
- 字节流可以处理所有数据文件,若处理的是纯文本数据,建议使用字符流。
IO流中的三类数据源
基于磁盘文件:FileInputStream、FileOutputSteam、FileReader、FileWriter
基于内存:ByteArrayInputStream ByteArrayOutputStream(ps:字节数组都是在内存中产生)
基于网络:SocketInputStream、SocketOutputStream(ps:网络通信时传输数据)
PrintStream :打印输出字节数据。
PrintWriter : 打印输出文本数据。
10.线程常用方法:start、sleep、notify、wake、join作用等。同步锁的作用。
Synchronized,lock,run线程体方法
Thread类作为线程的基类,提供了一系列方法,主要有:
Thread.sleep(long):强制线程睡眠一段时间。
Thread.activeCount():获取当前程序中存活的线程数。
thread.start():启动一个线程。
Thread.currentThread():获取当前正在运行的线程。
thread.getThreadGroup():获取线程所在线程组。
thread.getName():获取线程的名字。
thread.getPriority():获取线程的优先级。
thread.setName(name):设置线程的名字。
thread.setPriority(priority):设置线程的优先级。
thread.isAlive():判断线程是否还存活着。
thread.isDaemon():判断线程是否是守护线程。
thread.setDaemon(true):将指定线程设置为守护线程。
thread.join():在当前线程中加入指定线程,使得这个指定线程等待当前线程,并在当前线程结束前结束。
thread.yield():使得当前线程退让出CPU资源,把CPU调度机会分配给同样线程优先级的线程。
thread.interrupt():使得指定线程中断阻塞状态,并将阻塞标志位置为true。
object.wai()、object.notify()、object.notifyAll():Object类提供的线程等待和线程唤醒方法。
run和start()
把需要处理的代码放到run()方法中,start()方法启动线程将自动调用run()方法,这个由java的内存机制规定的。并且run()方法必需是public访问权限,返回值类型为void。
关键字synchronized
该关键字用于保护共享数据,当然前提条件是要分清哪些数据是共享数据。每个对象都有一个锁标志,当一个线程访问到该对象,被Synchronized修饰的数据将被”上锁”,阻止其他线程访问。当前线程访问完这部分数据后释放锁标志,其他线程就可以访问了。
实例代码:
/**
* <p>线程基本方法(sleep、wait、notify、notifyAll、synchronized)</p>
*
* @author hanchao 2018/3/11 14:14
**/
public class ThreadWaitDemo {
private static final Logger LOGGER = Logger.getLogger(ThreadWaitDemo.class);
/**
* 现有菜品
*/
private static final Queue<String> FOOD_QUEUE = (Queue<String>) new LinkedList<String>();
/**
* <p>菜品工具类</p>
**/
public static class Foods {
private static String[] foods = new String[]{"[鱼香肉丝]", "[水煮肉片]", "[地三鲜]", "[红烧肉]", "[干煸豆角]"};
/**
* <p>随机获取一个菜名</p>
*
* @author hanchao 2018/3/11 15:46
**/
static String randomFood() {
return foods[RandomUtils.nextInt(0, foods.length)];
}
}
/**
* <p>厨房生产各种菜肴(wait、notify、synchronized)</p>
**/
static class Kitchen extends Thread {
@Override
public void run() {
while (true) {
//加锁
synchronized (FOOD_QUEUE) {
//菜架满了,厨房不必再茶菜,等着前厅通着再炒菜
//厨房的菜架能够存放菜品的最大值
int maxSize = 6;
if (maxSize == FOOD_QUEUE.size()) {
try {
LOGGER.info("厨房菜架满了,厨房不必再茶菜,等着前厅通着再炒菜,当前菜架:" + FOOD_QUEUE.toString());
FOOD_QUEUE.wait(111);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
//炒一个菜
String food = Foods.randomFood();
FOOD_QUEUE.add(food);
try {
LOGGER.info("厨房炒了一个:" + food + ",厨师歇息2分钟...当前菜架:" + FOOD_QUEUE.toString());
//抄完一个菜,歇息1分钟
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
/**
* <p>餐厅消费各种菜肴(wait、notify、synchronized)</p>
**/
static class Restaurant extends Thread {
@Override
public void run() {
while (true) {
//加锁
synchronized (FOOD_QUEUE) {
//如果生意太好,菜品供不应求,只能等待厨房做菜...
if (0 == FOOD_QUEUE.size()) {
try {
LOGGER.info("餐厅:生意太好,菜品供不应求,只能等待厨房做菜...当前菜架:" + FOOD_QUEUE.toString());
FOOD_QUEUE.wait(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else if (FOOD_QUEUE.size() > 0) {
//如果有菜,则消费菜品
//当厨房的储备菜品所剩不多时,告诉厨师开始炒菜
//当厨房还剩几个菜时,继续炒菜
int minSize = 2;
if (FOOD_QUEUE.size() <= minSize) {
FOOD_QUEUE.notify();
LOGGER.info("餐厅:厨房的储备菜品所剩不多时,厨师们该继续炒菜了...");
}
//消费菜品
String food = FOOD_QUEUE.poll();
try {
//随机一定时间吃掉一道菜
Thread.sleep(RandomUtils.nextInt(1500, 2500));
LOGGER.info("餐厅:刚刚消费了一道" + food + "...当前菜架:" + FOOD_QUEUE.toString());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
/**
* <p>线程基本方法(sleep、wait、notify、notifyAll、synchronized)</p>
**/
public static void main(String[] args) throws InterruptedException {
//通过关键字synchronized和Object的方法wait()/notify()/notifyAll()实现线程等待与唤醒
//通过object.wait(),使得对象线程进行入等待唤醒状态,并是否对象上的锁
//通过object.notify()/object.notifyALL(),唤醒此对象上等待的线程,并获得对象上的锁
//wait()/notify()/notifyAll()必须在synchronized中使用
new Kitchen().start();
//先让厨房多炒几个菜
Thread.sleep(10000);
//餐厅开始消费
new Restaurant().start();
}
}
11.socket编程:客户端、服务端发送和接受信息的函数有哪些?UDP tcp区别,Socket类和ServerSocket类区别。 UDP编程用到哪些类和方法
服务器:
/**
* 基于UDP服务器端程序的编写
*/
public static void recv() {
try {
//创建数据报套接字对象,绑定端口号为6000
DatagramSocket ds = new DatagramSocket(6000);
//构建数据包接收数据:
//创建字节数组
byte[] buf = new byte[100];
//创建数据包对象,它的长度不能超过数组的长度,我们把它设为100
DatagramPacket dp = new DatagramPacket(buf, 100);
//接收数据
ds.receive(dp);
//打印数据
//getLength方法返回实际接收数;getData方法返回数据,返回格式为字节数组
System.out.println(new String(buf, 0, dp.getLength()));
//给客户端答复
String str = "Welcome you!";
//getAddress()、getPort()方法,可获得发送数据时的ip地址、端口号
DatagramPacket dpSend = new DatagramPacket(
str.getBytes(),
str.length(),
dp.getAddress(),
dp.getPort());
ds.send(dpSend);
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
客户端:
/**
* 基于UDP客户端程序的编写
*/
public static void send() {
try {
//创建一个数据报对象。
DatagramSocket ds = new DatagramSocket();
//要发送的数据
String str = "Hello,this is zhangsan";
//构造一个发送数据包:
//InetAddress.getByName("localhost"):获得本地ip地址
//端口号指定为6000
DatagramPacket dp = new DatagramPacket(
str.getBytes(),
str.length(),
InetAddress.getByName("localhost"),
6000);
//发送数据包
ds.send(dp);
//创建字节数组
byte[] buf = new byte[100];
//构建接收数据的数据包
DatagramPacket dpRecv = new DatagramPacket(buf, 100);
//接收数据
ds.receive(dpRecv);
//打印数据
System.out.println(new String(buf, 0, dpRecv.getLength()));
//关闭数据报套接字
ds.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
12.JDBC:
驱动加载语句Class.forName()、连接语句Connection getConnection(“jdbc:mysql//locaohhost:3306?databasename”,username,passwod)、查询和执行。PreparedStatement类的作用,与Statement比较有什么优点?防止sql注入?
参数化、+连接:
- 加载驱动包
Class.forName("com.mysql.jdbc.Driver") ; // 加载驱动
- 建立连接
Connection con = DriverManager.getConnection(“jdbc:mysql//locaohhost:3306?databasename”,username,passwod)
- 创建sql语句对象
Statement stmt = con.createStatement();
- 创建sql语句
String sql = "insert into test values(seq_qid.nextval,'1212','a',20,'男')";
String sql2 = "delete from test where qname = '1212'";
String sql3 = "update test set qname='1212' where qid='10005'";
String sql4 = "select * from test";
- 执行sql语句
//executeUpdate //增删改
int result = stmt.executeUpdate(sql); //返回受影响行
//executeQuery //查
//ResultSet rs = stmt.executeQuery(sql4); //返回找到的数据
Statement 和 PreparedStatement之间的关系和区别.
关系:PreparedStatement继承自Statement,都是接口
区别:PreparedStatement可以使用占位符,是预编译的,批处理比Statement效率高
为什么使用 PreparedStatement?
在使用 PreparedStatement之前我们来看一下使用Statement的一个缺点
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;
public class exercises5 {
public static void main(String[] args) throws Exception{
Class.forName("com.mysql.jdbc.Driver");
Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/epet?characterEncoding=utf8","root","");
Scanner input=new Scanner(System.in);
System.out.println("请输入用户名:");
String name=input.next();
System.out.println("请输入密码:");
String pass=input.next();
String sql="select * from master where `name`=? and password=?";
PreparedStatement ps=conn.prepareStatement(sql);
ps.setString(1,name);
ps.setString(2,pass);
ResultSet rs=ps.executeQuery();
System.out.println(sql);
if(rs.next()){
System.out.println("登录成功,欢迎你!");
}else{
System.out.println("登录失败!");
}
}
}
如果输入正确,输出登陆成功,否则输出登录失败。
但是我们输入了精心设计的内容,即时姓名和密码都是错误的,仍然可以显示登录成功
这是因为在使用Statement接口方法时我们需要进行sql语句的拼接,我们这样拼接不仅麻烦而且很容易出错。这就是网上典型的SQL注入攻击
这个时候使用PreparedStatement接口就不存在这个问题了
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Scanner;
public class exercises5 {
public static void main(String[] args) throws Exception{
Class.forName("com.mysql.jdbc.Driver");
Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/epet?characterEncoding=utf8","root","");
Scanner input=new Scanner(System.in);
System.out.println("请输入用户名:");
String name=input.next();
System.out.println("请输入密码:");
String pass=input.next();
String sql="select * from master where `name`=? and password=?";
PreparedStatement ps=conn.prepareStatement(sql);
ps.setString(1,name);
ps.setString(2,pass);
System.out.println(sql);
if(ps.execute()) System.out.println("登录成功,欢迎你!");
else System.out.println("登录失败!");
}
}
由此我们可以总结出 PreparedStatement相对于Statement的优点
- 提高了代码的可读性和可维护性
- 提高了sql语句执行性能
- 提高了安全性
13.package import class类,public主类/非主类的含义和书写次序。
package语句、import语句、class语句
java 应用程序是有若干类和接口组成的,为了使Java 应用程序能够
运行,至少要有一个类含有main()主方法,因为main()主方法是java
应用程序的入口点,java应用程序就是从这里开始运行的,我们把含
有main()主方法的类称为java应用程序的主类。
14.正则表达式:电话号码:手机、固话、数字串取出、分割的正则式。Split, \d, \w +*?
1.固定电话
regularEx= "^(\\+\\d{2}-)?0\\d{2,3}-\\d{7,8}$" //代表国际固定电话
(\\d{2}-)?
\\d{2} 代表匹配任意两个数字,- 是分隔符, ?代表匹配前面的子表达式零次或者一次,要匹配?字符,请使用\?,(\\d{2}-)? 代表 匹配前两个数字,允许匹配不上。这里用俩匹配国家代码 例如:+86-
-(\\+\\d{2}-)?
代表示例:+86- 没有分隔符的话,就是(\\d{2})?
0\\d{2,3}-\\d{7,8}
代表示例:010-54646464 010-8656444 ,以0开头,后面任意两位或者三位数字 比如区号0215, 接着分隔符-,然后为任意7位或者8位数字。
2.手机号
regularEx= "^(\\+\\d{2}-)?(\\d{2,3}-)?([1][3,4,5,7,8][0-9]\\d{8})$"
表示手机号,+ 之后为任意两位数字 ,?代表?前的括号内的表达式可选,允许匹配一次或者零次,分隔符-,接着任意匹配两位或者三位数字,即手机号的区号,允许匹配一次或者零次,即区号可填可不填,分隔符 – ,接着手机号格式。
([1][3,4,5,7,8][0-9]\\d{8})
第一位必须是数字1,第二位可以是3,4,5,6,7,8中的任意一个数字,,[0-9]其实等同于\\d,也可表示为([1][3,4,5,7,8]\\d{9})
15.JDK包含了JDK和JRE的含义,编译和运行都需要这2个包吗?
java软件包中主要有两部分:jdk,jre。
前者就是开发java程序是所用的JDK,
jre是java runtime envirment的简称,包括java runtime environment 和java plug-in两部分。jre是用来运行、测试和传输java应用程序,它包括java虚拟机、java开发平台核心类和一些支持文件,他不包含开发工具编译器、调试器和其他工具(存在于jdk中)。因此开发java程序不仅要jdk,还有jre.jdk —java development kit,java开发包。
jre —java runtime environment java运行环境。
编译 JDK 运行 JRE
16.java的四种权限,及访问权限。Public protected 友好 private,访问规则
private (私有的):
1、用 private 关键字修饰的 成员变量 和 方法 称为 私有变量 和 私有方法 ;
2、当类在同一个包中时,私有变量 和 私有方法 只能在自己类中调用,另外一个类中是不能调用的 ;
public (共有的):
1、用 public 关键字修饰的 成员变量 和 方法 称为 共有变量 和 共有方法 ;
2、当类在同一个包中时,共有变量 和 共有方法 不仅可以在自己类中调用,也可以在另外一个类中调用 ;
protected(受保护的) :
1、用 protected 关键字修饰的 成员变量 和 方法 称为 受保护的变量 和 受保护的方法 ;
2、当类在同一个包中时,受保护的变量 和 受保护的方法 不仅可以在自己类中调用,也可以在另外一个类中调用 ;
友好的 (默认权限):
1、不用 private、public、protected 关键字修饰的 成员变量 和 方法 称为 友好变量 和 友好方法 ;
2、当类在同一个包中时,友好变量 和 友好方法 不仅可以在自己类中调用,也可以在另外一个类中调用 ;
1、当某个类中使用友好类创建对象时,要保证他们在同一个包中;
2、不能使用 private、protected 关键字修饰类 ;
3、访问权限修饰符按访问权限从高到低的排序是:public、protected、友好的、private ;
17.对象变量、类变量、对象方法(所有)、类方法(类变量)的互访规则。构造函数(所有)
18.重载:条件(形参 个数类型不同);重写:条件(函数原型完全一致,目的是多态和回调;
- 方法重载:在一个类中可以有多个方法具有相同的名字,但这些方法的参数必须不同。
- 方法重写:是指子类中定义了一个方法,这个方法的类型(返回值类型)和父类方法的类型(返回值类型)一致或者是父类的方法类型的子类型,并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。
19.接口:成员有哪2种 ;
抽象类:(new? 错误),抽象方法。
20.数组:不规则数据,列如何访问?
public class Main {
public static void main(String args[]) {
final int MAX = 10;
int [][] arrs = new int[MAX + 1][]; //分配一个具有所含行数的数组
for (int n = 0; n <= MAX; n++) //分配每一行
arrs[n] = new int[n + 1];
//给数组赋值
for (int n = 0; n < arrs.length; n++)
for (int k = 0; k < arrs[n].length; k++){
int lotteryArrs = 1;
arrs[n][k] = lotteryArrs;
}
//遍历数组
for (int[] row : arrs){
for (int arr : row)
System.out.print(arr + " ");
System.out.println();
}
}
}
21.Java:单继承,多接口; 模式对话框、JFrame显示哪个方法,
.visible(),执行之后窗体才可显示,一般放在最后
22.try-catch书写,算术异常,数组异常,书上例子
public static void main(String[] args) {
int n,m,t;
try{
t = 9999;
m = Integer.parseInt("8888");
n = Integer.parseInt("12s3a");
n = 100;
System.out.print("我没有机会输出。");
}catch(NumberFormatException e){
System.out.print("发生异常。");
n = 123;
}
}
- 看看输出什么?
分析:数组并没有给赋值,所以都为 null ,这时候就报 空指针异常,被 catch 捕获(此时返回3),但 finally 最后还是要执行的,所以 返回 4
public class TryCatchExercise01 {
public static int method() {
try {
String[] names = new String[3];//String[]数组
if (names[1].equals("tom")) {//NullPointerException
System.out.println(names[1]);
} else {
names[3] = "xdr";
}
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {//捕获
return 3;
} finally { //必须执行
return 4; //返回4
}
}
public static void main(String[] args) {
System.out.println(method()); //4
}
}
常见异常:
java.lang.NullPointerException(空指针异常) 调用了未经初始化的对象或者是不存在的对象
经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等。对数组操作中出现空指针,即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的,所以还需要对每个元素都进行初始化(如果要调用的话)。
java.lang.ClassNotFoundException 指定的类不存在
这里主要考虑一下类的名称和路径是否正确即可,通常都是程序试图通过字符串来加载某个类时可能引发 异常比如:调用Class.forName();
或者调用ClassLoad的finaSystemClass();或者LoadClass();
java.lang.NumberFormatException 字符串转换为数字异常
当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常.如现在讲字符型的数据“123456”转换为数值型数据时,是允许的。
但是如果字符型数据中包含了非数字型的字符,如123#56,此时转换为数值型时就会出现异常。系统就会捕捉到这个异常,并进行处理.
java.lang.IndexOutOfBoundsException 数组下标越界异常
查看调用的数组或者字符串的下标值是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。
java.lang.IllegalArgumentException 方法的参数错误
比如g.setColor(int red,int green,int blue)这个方法中的三个值,如果有超过255的也会出现这个异常,因此一旦发现这个异常,我们要做的,就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
java.lang.IllegalAccessException 没有访问权限
当应用程序要调用一个类,但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常
java.lang.ArithmeticException 数学运算异常
当算术运算中出现了除以零这样的运算就会出这样的异常。
java.lang.ClassCastException 数据类型转换异常
当试图将对某个对象强制执行向下转型,但该对象又不可转换又不可转换为其子类的实例时将引发该异常,如下列代码。
Object obj = new Integer(0);
String str = obj;
java.lang.FileNotFoundException 文件未找到异常
当程序试图打开一个不存在的文件进行读写时将会引发该异常。该异常由FileInputStream,FileOutputStream,RandomAccessFile的构造器声明抛出
即使被操作的文件存在,但是由于某些原因不可访问,比如打开一个只读文件进行写入,这些构造方法仍然会引发异常
java.lang.ArrayStoreException 数组存储异常
当试图将类型不兼容类型的对象存入一个Object[]数组时将引发异常
Object[] obj = new String[3];
obj[0] = new Integer(0);
java.lang.NoSuchMethodException 方法不存在异常
当程序试图通过反射来创建对象,访问(修改或读取)某个方法,但是该方法不存在就会引发异常
java.lang.NoSuchFiledException 方法不存在异常
当程序试图通过反射来创建对象,访问(修改或读取)某个filed,但是该filed不存在就会引发异常
java.lang.EOFException 文件已结束异常
当程序在输入的过程中遇到文件或流的结尾时,引发异常。因此该异常用于检查是否达到文件或流的结尾
java.lang.InstantiationException 实例化异常
当试图通过Class的newInstance()方法创建某个类的实例,但程序无法通过该构造器来创建该对象时引发Class对象表示一个抽象类,接口,数组类,基本类型
该Class表示的类没有对应的构造器
java.lang.InterruptedException 被中止异常
当某个线程处于长时间的等待、休眠或其他暂停状态,而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
java.lang.CloneNotSupportedException 不支持克隆异常
当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。
java.lang.OutOfMemoryException 内存不足错误
当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
java.lang.NoClassDefFoundException 未找到类定义错误
当Java虚拟机或者类装载器试图实例化某个类,而找不到该类的定义时抛出该错误。
违背安全原则异常:SecturityException
操作数据库异常:SQLException
输入输出异常:IOException
通信异常:SocketException
22.模式匹配(正则表达式)子串匹配、完全匹配
一、Pattern
Pattern compile(String regex):
regex正则表达式,该方法是将给定的正则表达式编译并赋予给Pattern类
public static Pattern compile(String regex) {
return new Pattern(regex, 0);
}
split():拆分字符串
Pattern.split() 将字符串从正则表达式匹配的地方分开
String str = "name:'Jack',age:18,sex=M,height:180cm,weight:60kg";
// compile()
Pattern p = Pattern.compile("\\d");
// split()
String[] arr1 = p.split(str);
matcher():匹配字符串或者返回Matcher实例
Pattern.matcher():或返回一个Matcher实例;
Pattern.matcher():对整个字符串进行匹配,若整个字符串都匹配,返回true;
Pattern.matcher(String regex,CharSequence input)
regex 正则表达式
input 待匹配的字符串
// matcher()
System.out.println(Pattern.matches("\\d+", "123456")); // true
System.out.println(Pattern.matches("\\d+", "aa123456")); // false,需要匹配到所有字符串才能返回true,这里aa不能匹配到
二、Matcher类
Matcher 对象是对输入字符串进行解释和匹配操作的引擎,与Pattern 类一样,Matcher 也没有公共构造方法;
实例:
public static void main(String[] args) {
Pattern p;
Matcher m;
String s1 = "0A1A2A3A4A5A6A7A8A9";
p = Pattern.compile("\\dA\\d");
m = p.matcher(s1);
while(m.find()) {
String str = m.group();
System.out.print("从"+m.start()+"到"+m.end()+"匹配的字符串");
System.out.println(str);
}
m = p.matcher("9A00A3");
if(m.matches()) {
String str = m.group();
System.out.println(str);
}else{
System.out.println("不完全匹配");
}
}
23.数据库编程
懒得找了,随便贴一个代码
import java.sql.*;
public class Demo {
private static final String DBDRIVER = "com.mysql.cj.jdbc.Driver";
private static final String DBURL = "jdbc:mysql://localhost:3306/myemployees?useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "********";
public static void main(String[] args) throws Exception {
Class.forName(DBDRIVER);
Connection conn = DriverManager.getConnection(DBURL,USER,PASSWORD);
Statement st = conn.createStatement();
String sql = "select * from departments";
ResultSet res = st.executeQuery(sql);
while(res.next()) {
int depID = res.getInt("department_id");
String depName = res.getString("department_name");
int magID = res.getInt("manager_id");
int locID = res.getInt("location_id");
System.out.println("DepID is:" + depID + ",depName is:" + depName + ",magID is:" + magID + ",locID is:" + locID);
}
sql = "UPDATE departments SET manager_id = 201 WHERE department_id = 10";
int len = st.executeUpdate(sql);
st.close();
conn.close();
}
}
import java.sql.*;
public class mysql {
public static void main(String[] args) throws Exception{
Class.forName("com.mysql.jdbc.Driver"); //加载驱动
Connection con = null;
try{
String username = "wxk";
String password = "1213";
con = DriverManager.getConnection("jdbc:mysql://localhost:3036?databasename",username,password);//建立连接
Statement st = con.createStatement();//创建statement对象
ResultSet rs = st.executeQuery("Select * From student");//执行操作(增删改查)
while(rs.next()) { //处理结果
System.out.printf("学号:%s\t",rs.getString(1));
System.out.printf("姓名:%4s\t",rs.getString(2));
System.out.printf("成绩:%6.2f\t",rs.getDouble(3));
System.out.println();
}
}catch(SQLException e){
e.printStackTrace();
}finally{
con.close(); //关闭连接
}
}
}
24.图形 : 点、线、圆形、矩形; 继承派生 点距离,圆距离,
abstract class Point{
int x;
int y;
public abstract double area();
public abstract double distance(Point p);
public Point(int x,int y){
this.x=x;
this.y=y;
}
}
class Circle extends Point{
private double r;
public Circle(double r,int x,int y){
super(x,y);
this.r=r;
}
public double area(){
return Math.PI*r*r;
}
public double distance(Point p) {
return Math.sqrt(Math.pow(p.x-this.x,2)+Math.pow(p.y-this.y,2));
}
}
class Rectangle extends Point{
private double width,height;
public Rectangle(double w,double h,int x,int y){
super(x,y);
width=w;
height=h;
}
@Override
public double area() {
return width*height ;
}
@Override
public double distance(Point p) {
return Math.sqrt(Math.pow(p.x-this.x,2)+Math.pow(p.y-this.y,2));
}
}
public class _point {
public static void main(String[] args) {
Circle c1=new Circle(2,0,0);
Circle c2=new Circle(3,3,4);
Rectangle R1=new Rectangle(5,3,0,0);
System.out.println("c1圆的面积:"+c1.area());
System.out.println("c2圆的面积:"+c2.area());
System.out.println("R1矩形的面积:"+R1.area());
System.out.println("c1圆和c2圆的圆心距离:"+c1.distance(c2));
}
}
25.split分割函数、
1)文件读写: BufferReadr:读取 readline()
2)行àsplit分割,正则表达式,à单词,
3)算术运算 1+1= 2+3=
package com.imooc.regex;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 读取本地的html文件
* @author Administrator
*
*/
public class RegexSample {
public static void main(String[] args) {
StringBuilder content = new StringBuilder(); // StringBuilder用来存放文件的内容
try {
// FileInputStream文件输入流,是二进制流
FileInputStream fis = new FileInputStream("E:\\jee-eclipse-workspace\\regex\\WebContent\\sample.html");
InputStreamReader isr = new InputStreamReader(fis,"UTF-8"); // 将二进制流转换成可读的字符串流
BufferedReader bufferedReader = new BufferedReader(isr); //引入缓冲机制,提升效率;
String lineText = "";
while((lineText = bufferedReader.readLine()) != null) {
//System.out.println(lineText);
content.append(lineText);
}
bufferedReader.close();
System.out.println(content);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 1.在Java中创建Pattern对象即正则表达式对象;;;;;表达式分组除了让正则表达式可读性提升外,一个
// 重要作用就是:在Java中可以将分组的信息单独提取,即可以单独地提取第一个分组得到中文,可以单独地提取第二个分组得到英文
Pattern p = Pattern.compile("<li>([\\u4e00-\\u9fa5]{2,10})([A-Za-z]+)</li>");
// 2.匹配正则表达式;;;;;调用正则表达式对象的match()方法对原始字符串进行匹配,会返回一个Matcher匹配器对象;
Matcher m = p.matcher(content);
// 3.查找匹配的结果,find()方法:在原始字符串中进行查找,将符合要求的结果进行提取;如果有匹配的返回true,没有匹配的返回false,
// 如果原字符串有多个匹配的结果(或称如果原字符串有多个符合规则的子串),可以使用循环进行依次地匹配获取;
while(m.find()) {
System.out.println(m.group(0)); // group(0):代表上面整个正则表达式对应的结果;group(0)是一定存在的,代表完整匹配信息
// 如果正则表达式中没有采取表达式分组,group(1)和group(2)是没有的,运行m.group(1)和m.group(2)的时候就会报错;
//System.out.println(m.group(1)); // group(1):代表第一个分组的内容;
//System.out.println(m.group(2)); // group(2):代表第二个分组的内容;
String chs = m.group(1);
String eng = m.group(2);
System.out.println(chs+"-"+eng);
}
}
}
算术运算:
import java.io.*;
public class write {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("1.txt");
FileWriter fw = new FileWriter("2.txt");
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw);
int sum=0;
String str=null;
while((str=br.readLine())!=null){
bw.write(str);
String[] s = str.split("[\\s+=]+");
sum = Integer.parseInt(s[0]) + Integer.parseInt(s[1]);
bw.write(" "+String.valueOf(sum));
bw.newLine();
}
bw.close();
br.close();
}
}
26.多线程 : thread类 Runnable接口实现。Run方法体中写程序或调用方法实现功能。同步synchronized修饰成程序块或方法,或者用锁机制。
线程1、线程2:保证线程1输出后线程2才输出,后面继续保持这个规则;12 12 12 输出n次数,over
public class _Thread {
public static int s=0;
public static void main(String[] args) {
final Object lock = new Object();
Thread aThread = new Thread(new Runnable(){
public void run(){
for(int i=0;i<10;i++){
synchronized(lock){
if(s%2==0&&s<10){
System.out.println("1");
s++;
}else{
try{
lock.notify();
lock.wait();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
}
});
Thread bThread = new Thread(new Runnable(){
public void run(){
for(int i=0;i<10;i++){
synchronized(lock){
if(s%2==1){
System.out.println("2");
s++;
}else{
try{
lock.notify();
lock.wait();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
}
});
aThread.start();
bThread.start();
}
}
lock:
//package six_6;
import java.util.concurrent.locks.ReentrantLock;
public class lock {
private static int state = 0;
public static void main(String[] args) {
final ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(new Runnable(){
public void run(){
while(state < 10){
try{
lock.lock();
if(state%2 == 0){
System.out.print("1");
state++;
}
}finally{
lock.unlock();
}
}
}
});
Thread t2 = new Thread(new Runnable(){
public void run() {
while(state<10) {
try{
lock.lock();
if(state%2==1){
System.out.print(" 2 ");
state++;
}
}finally{
lock.unlock();
}
}
}
});
t1.start();
t2.start();
}
}