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的优点

  1. 提高了代码的可读性和可维护性
  2. 提高了sql语句执行性能
  3. 提高了安全性

 

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;
        }
    }

 

  1. 看看输出什么?

分析:数组并没有给赋值,所以都为 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();
    }
}

 

版权声明:本文为24原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/wxk1213/p/16913603.html