JAVA复习_java的总复习-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_52401342/article/details/127983125

JAVA复习

一、选择20题30分判断15题15分
二、简单编程复杂编程

一、选择20题30分判断15题15分

1.java.exe java.exe javap.exe javadoc.exe的含义和用法；

javac.exe 是编译程序，用于编译.java文件
java.exe 是执行程序，用于执行编译好的.class文件
javadoc.exe 是JAVA文档工具，用于生成Java说明文档
jdb.exe 是调试器，用于调试JAVA代码
javaprof.exe 是剖析工具
javap反汇编

1.java 的反汇编命令是（）。A.javap B.javac C.jdb D.java
正确答案：A Javap 命令是 java 反汇编命令，javac 命令是 java 语言编译器，jdb 是基于文本和命令行的调试工具，java 命令是 Java 解释器。

2.java的输入和输出：scanner：hasNext(),nextInt(),…;print println printf(“%d”,10)的类对象和方法

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() 输入字符串(以空格作为分隔符

#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（区别） (常量池)，stringbuffer的定义；2个类的区别和转换方法。区别。赋值或定义方法s1=“abcd”;s2=“abcd”;s3=new String(“abcd”);s4=new String(“abcd”);s1，s2，s3在栈中，“abcd”在常量池， new String在堆。

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

str="Hello";
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.setCharAt(index ,char);//将index位置的字符变为新的char
 
5.反转     sb.reverse();//将sb倒序


6. getChars(int srcBegin,int srcEnd,char[] ch,int chBegin)
//将StringBuffer缓冲区中的指定数据存储到指定数组中

4.a和A、0的ascii码值多少97 65 48

5.数组的length是方法还是属性（是属性） a.length a[i].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

6.final的字义是终极，修饰类\方法\变量,及含义，。

final类
final修饰的类不能被继承，即不能有子类。当子类继承父类时，将可以直接访问到父类内部数据，这可能会导致一些安全问题。为了保证一个类不可被继承，可以使用final来修饰类。

final方法
final修饰的方法不可被重写，如果不希望子类重写父类的某个方法，则使用final修饰该方法
注：final修饰的方法不能被重写，能被重载。

final变量
final修饰的变量一旦获得了初始值就不可被改变，final修饰的变量必须由程序员显示地指定初始值，系统不会对final成员进行隐式初始化。

final修饰的类变量和实例变量能指定初始值的地方如下：
（1）final类变量（static修饰的变量）：
在静态初始化块中指定初始值
声明该变量时指定初始值
注：以上两个只需满足其中之一，不能同时指定

（2）final实例变量
在非静态初始化块中指定初始值
声明该实例变量时指定初始值
构造器中指定初始值
注：以上三个只需满足其中之一，不能同时指定

7.Swing界面问题：布局方式有哪些，默认布局FlowLayout；Border，Grid，Card，null含义。键盘时间ctrl/Shift+F/N如何判断及实现???

通过监听来实现：keyListener，addActionListener

****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.java的读写方式：IO流式读写

下面哪个流类属于面向字符的输入流（D）。
A、BufferedInputStream B、FileInputStream
C、ObjectInputStream D、InputStreamReader

InputStream和OutputStream是字节流，Reader和Writer是字符流。基础类是FileInputStrean和FileReader
BufferReader、BufferInputStream、DataXXXX、ObjectXXX是高级类，必须通过基础类才能访问到文件，不能直接访问文件。
readline（）；writer，newline。

字节流：操作的数据单元是8位的字节。InputStream、OutputStream作为抽象基类。
字符流：操作的数据单元是字符。以Writer、Reader作为抽象基类。字节流可以处理所有数据文件，若处理的是纯文本数据，建议使用字符流。

基于磁盘文件：FileInputStream、FileOutputSteam、FileReader、FileWriter
基于内存：ByteArrayInputStream ByteArrayOutputStream（ps:字节数组都是在内存中产生）
基于网络：SocketInputStream、SocketOutputStream（ps:网络通信时传输数据）
PrintStream：打印输出字节数据。 PrintWriter ：打印输出文本数据。

10.线程常用方法：start、sleep、notify、wake、join作用等。同步锁的作用。

以下哪个方法用于定义线程的执行体？C
A、 start() B、init() C、run() D、synchronized()
以下哪个关键字可以用来对对象加互斥锁？B
A、transient B、synchronized C、 serialize D、static

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修饰的数据将被"上锁"，阻止其他线程访问。当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。
售票代码

package cn.ahut.cs.mainapp.chapter10;
class Ticket implements Runnable{//Runnable实现类
	private int ticket=20;//一共有20张票
	public void run(){
		this.sell();
	}
	public synchronized void sell(){//线程同步
		while(true){
			if(ticket<1){//如果没有票聊，停止售票
				System.out.println("票已售完！");
				System.exit(0);
			}
			System.out.println(Thread.currentThread().getName()+"卖出第"+(ticket--)+"号票");
			
			try{
				Thread.sleep(100);
				notifyAll();//唤醒别的售票窗口
				wait();
			}catch(InterruptedException ie){
				ie.printStackTrace();
			}
		}
	}
}
public class  EXA10_1{
	public static void main(String[] args){
		Ticket t=new Ticket();
		Thread t1=new Thread(t,"卖票窗口1：");
		Thread t2=new Thread(t,"卖票窗口2：");
		Thread t3=new Thread(t,"卖票窗口3：");
		Thread t4=new Thread(t,"卖票窗口4：");
		Thread t5=new Thread(t,"卖票窗口5：");
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
	}
}

11.socket编程:客户端，服务端发送和接受信息的函数有哪些？tcp区别，socket类和ServeSocket类区别。发送方法接收方法

ServerSocket 类主要是通过（ C ）方法监听客户端的请求
A. control() B. send() C. accept() D. receive()

客户端，服务端发送和接受信息的函数有哪些：
发送方法：send
接收方法：accept
服务器：send和receive getAddress() getPort
客户端：send和receive InetAddress.getByName()

**TCP、UDP区别：
TCP面向连接可靠传输、使用流量和拥塞控制。一对一，字节流。UDP无连接，不可靠传输、不使用流量和拥塞控制，一对一一对多多对一多对多报文。

socket类和ServeSocket类区别

Socket类代表一个客户端套接字，即任何时候连接到一个远程服务器应用时构建所需的socket。现在，要实现一个服务器应用，需要不同的做法。服务器需随时待命，因为不知道客户端什么时候会发来请求，此时，我们需要使用ServerSocket，对应的是java.net.ServerSocket类。

ServerSocket与Socket不同，ServerSocket是等待客户端的请求，一旦获得一个连接请求，就创建一个Socket示例来与客户端进行通信。

UDP编程：用到哪些类和方法：

DatagramSocket()// 类用于表示发送和接收数据报包的套接字
DatagramPacket()//封装数据 
void send(DatagramPacket p)//发送数据
void close()//关闭资源
void receive(DatagramPacket p)//接收数据

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 类的作用与 Statement 比较有什么优点?
PreparedStatement 有参数 Statement 无参数一个是参数化的
Statement 用+做链接防止 sq|注入?使用加号比较危险
由此我们可以总结出 PreparedStatement相对于Statement的优点
提高了代码的可读性和可维护性
提高了sql语句执行性能
提高了安全性

13.package import class类，public主类/非主类的含义和书写次序。package语句、import语句、class语句

书写次序：Package->import->class

java 应用程序是有若干类和接口组成的，为了使Java 应用程序能够

运行，至少要有一个类含有main()主方法，因为main()主方法是java

应用程序的入口点，java应用程序就是从这里开始运行的，我们把含

有main()主方法的类称为java应用程序的主类。

14.正则表达式：电话号码：手机、固话、数字串取出、分割的正则式。Split, \d, \w +*?

下列哪个选项中的正则表达式匹配形如 0511-4405222 或 021-87888822 结构的电话号码（ A）。
A、\d{3}-\d{8}|\d{4}-\d{7}
B、[1-9]\d{5}(?!\d)
C、\d{3}-\d{8}||\d{4}-\d{7}
D、\d{4}-\d{7}

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.对象变量、类变量、对象方法（所有）、类方法（类变量）的互访规则。构造函数（所有）

下列关于修饰符混用的说法，错误的是（D ）
A.abstract 不能与 final 并列修饰同一个类
B.abstract 类中可以有非 abstract 的方法
C.普通类（非 abstract 类）中不能有 abstract 方法
D.static 方法中能处理非 static 的属性

在这里插入图片描述

18.重载：条件（形参个数类型不同）；重写：条件（函数原型完全一致，目的是多态和回调;

方法重载:在一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同。1.发生在父类与子类之间。扩展性
方法重写:是指子类中定义了一个方法，这个方法的类型(返回值类型)和父类方法的类型(返回值类型)一致或者是父类的方法类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。扩展性

19.接口：成员有哪2种；抽象类：new ？x，抽象方法

1、接口的成员
常量值和抽象方法。接口（interface）是抽象方法和常量值定义的集合。
2、接口的特点
（1）接口用 interface 来定义；
（2）接口中的所有成员变量都默认是由 public static final 修饰的；
（3）接口中的所有抽象方法都默认是由 public abstract 修饰的；
（4）接口中没有构造器，意味着接口不可以实例化；
（5）接口是采用多继承机制；
抽象方法、默认方法、静态方法、私有方法。
在这里插入图片描述

20.数组：不规则数据，列如何访问?

public class Main {
 
    public static void main(String args[]) {
        final int MAX = 10;
        int [][] arrs = new int[MAX + 1][];     //分配一个具有所含行数的数组         
       int[][] aaa={{1,2,3}{,4,5,6,7},{8,9,10,11,12}};//初始化
       
        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;
            }
 
        //1.遍历数组
        for (int[] row : arrs){
            for (int arr : row)
                System.out.print(arr + " ");
            System.out.println();
        }
      //2.遍历数组
      for(int i=0;i<a.length;i++) {
			for(int j=0;j<a[i].length;j++) {
				System.out.print(a[i][j]+" ");
			}
			System.out.println();
		}

    }
}

21.Java：单继承，多接口; 模式对话框、JFrame显示哪个方法，.setVisible(),执行之后窗体才可显示，一般放在最后。

二、简单编程复杂编程

22.图形：点、线、圆形、矩形；继承派生点距离，圆距离。

package six_6;

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

    @Override
    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_1 {
    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));
    }
}

23、split分割函数

1）文件读写： BufferReadr:读取 readline()一行
2）经过split分割，正则表达式，一个一个的单词，

package six_6;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class split_2_1 {
    public static void main(String[] args) {
        try {
            BufferedReader bf = new BufferedReader(new FileReader("e.txt"));
            String str = null;
            while ((str = bf.readLine()) != null) {
                String[] s = str.split("[\\s\\d,;.]+");
                for (int i = 0; i < s.length; i++) {
                    System.out.println(s[i]);
                }
            }
            bf.close();
        }catch (FileNotFoundException fe){
               fe.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

3）算术运算文件a（1+1= 2+3=）写到文件b（1+1= 2 2+3=5）

package six_6;

import java.io.*;

public class split_2_2 {
    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new FileReader("a.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
            int sum = 0;
            String str = null;
            while ((str = br.readLine()) != null) {
                bw.write(str);
                String[] s = str.split("[\\s+=]+");
                sum = Integer.parseInt(s[1]) + Integer.parseInt(s[2]);
                bw.write(String.valueOf(sum));
                bw.newLine();
                bw.flush();
            }
              bw.close();
             br.close();
        }catch (FileNotFoundException fe){
            fe.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

24.多线程： thread类 Runnable接口实现。Run方法体中写程序或调用方法实现功能。同步synchronized修饰成程序块或方法，或者用锁机制。

线程1、线程2：保证线程1输出后线程2才输出，后面继续保持这个规则；12 12 12 输出n次数，over
继承Thread类

public class Mythread extends Thread{
  public void run() {
       //重写
    }
}

继承接口implements Runnable
public class MyRunnable implements Runnable{
 public void run() {
       //重写
    }
    public static void main(String[] args){
     MyRunnable myRunnable = new MyRunnable();// 创建代理类对象
     Thread thread = new Thread(myRunnable,"线程1");
    }
}

synchronized的方法

package six_6;
public class TestLock {
    private static int state = 0;
    public static void main(String[] args) {
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (state <= 19) {//12输出10次
                   // 加锁
                    synchronized (this) {
                        if (state % 2 == 0) {
                            System.out.print("1");
                            state++;
                        }
                    }
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 19) {

                    synchronized (this) {
                        if (state % 2!=0) {
                            System.out.print("2" + ',');
                            state++;
                        }
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

可能出的题目
10 个线程，1-10。分别输出 1-10，如线程 1 只输出数字 1，线程 10 只输出数字 10；
要求 10 个线程分别输出数字 1-10 ，按照 1-10 的顺序输出；每个线程输出 n 次。

package hc;
public class ly {
    private static int state = 0;
    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (state <= 49) {//12345输出10次
                    // 加锁
                    synchronized (this) {
                        if (state % 5 == 0) {
                            System.out.print("1");
                            state++;
                        }
                    }
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 49) {

                    synchronized (this) {
                        if (state % 5==1) {
                            System.out.print("2");
                            state++;
                        }
                    }
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 49) {

                    synchronized (this) {
                        if (state % 5==2) {
                            System.out.print("3");
                            state++;
                        }
                    }
                }
            }
        });
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 49) {

                    synchronized (this) {
                        if (state % 5==3) {
                            System.out.print("4");
                            state++;
                        }
                    }
                }
            }
        });
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 49) {

                    synchronized (this) {
                        if (state % 5==4) {
                            System.out.print("5"+',');
                            state++;
                        }
                    }
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

在这里插入图片描述

有 A,B,C 三个线程, A 线程输出 A, B 线程输出 B, C 线程输出 C，要求：同时启动三个线
程, 按顺序输出 ABC, 循环 10 次。

package hc;
public class hccc {
    private static int state = 0;
    public static void main(String[] args) {
        //final ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (state <= 29) {//ABC输出10次
                    // 加锁
                    synchronized (this) {
                        if (state % 3 == 0) {
                            System.out.print("A");
                            state++;
                        }
                    }
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 29) {

                    synchronized (this) {
                        if (state % 3==1) {
                            System.out.print("B");
                            state++;
                        }
                    }
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void  run() {
                while (state <= 29) {

                    synchronized (this) {
                        if (state % 3==2) {
                            System.out.print("C"+" ");
                            state++;
                        }
                    }
                }
            }
        });
        t1.start();
        t2.start();
         t3.start();
    }
}

在这里插入图片描述

25.try-catch书写，算术异常，数组异常，书上例子

算术异常：
（1）空指针异常：NullPointerException
（2）除0异常：ArithmeticException
数组越界异常：IndexOutOfBoundsException
文件异常：FileNotFoundException（文件未找到异常）
数字转换字符串异常：NumberFormatException
输入格式异常：InputMismatchException

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

 public static void main(String[] args) {
        try {
            int []a=new int[10];
            Scanner scan=new Scanner(System.in);
            a[10]=123;
            int m=scan.nextInt();
        }catch (IndexOutOfBoundsException iobe){
            System.out.println("数组越界异常:"+iobe.toString());
        }
        catch (InputMismatchException ime){
            System.out.println("输入格式异常:"+ime.toString());
        }
        catch (Exception e){
            System.out.println(e.toString());
        }
    }

26.模式匹配（正则表达式）子串匹配、完全匹配

Pattern compile(String regex)：
regex正则表达式，该方法是将给定的正则表达式编译并赋予给Pattern类

// matcher()
System.out.println(Pattern.matches("\\d+", "123456"));  // true
System.out.println(Pattern.matches("\\d+", "aa123456"));  // false，需要匹配到所有字符串才能返回true,这里aa不能匹配到

在这里插入图片描述

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("不完全匹配");
        }
    }

27.数据库编程

package six_6;

import java.sql.*;

public class database7 {
    public static void main(String[] args) {
        Connection con=null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String username = "hc";
            String password = "123";
            con = DriverManager.getConnection("jdbc:mysql://localhost:3036/student?characterEncoding=UTF8", username, password);
            Statement st = con.createStatement();
            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();
        }
    }
}