Java 复习整理day10
package com.it.demo01_quickstart; /*
案例: 讲解网络编程相关概念. 网络编程简介:
概述:
网络编程也叫: 套接字编程, Socket编程, 就是用来实现 网络互联的 不同计算机上 运行的程序间 可以进行数据交互.
大白话翻译: 就是用来实现 不同电脑间 进行数据传输的. 三大要素:
IP地址:
概述:
设备在网络中的唯一标识. 192.168.37.56
组成:
网络(关)号码 + 主机地址
分类:
城域网: 1 + 3 第一段是网关号码, 后三段是主机地址.
广域网: 2 + 2 一般应用于校园网
局域网: 3 + 1
两个DOS指令:
ipconfig /all 查看IP
ping ip地址/网址 -t 测试网络连接
两个特殊的IP:
127.0.0.1 本地回环(回路)地址, 即: 代表本机.
255.255.255.255 广播地址 InetAddress类: IP地址的包装类
String形式的IP -> InetAddress类型的 IP地址对象.
public static InetAddress getByName(String ip地址/主机名); 根据字符串形式的ip(或者主机名), 获取其对应的 IP地址对象. InetAddress类型的 IP地址对象 -> String形式的IP
public String getHostAddress(); 根据IP地址对象, 获取字符串形式的IP
public String getHostName(); 根据IP地址对象, 获取字符串形式的 主机名
端口号:
概述:
程序在设备上的唯一标识.
范围:
0-65535
注意事项:
0-1023之间的端口号不要用, 因为已经被系统占用了或者用作保留端口.
协议:
概述:
就是设备间传输数据时, 需要遵守的规则, 约定.
分类:
UDP协议: //类似于: 群聊
1. 面向无连接.
2. 采用数据报包(DatagramPacket)的形式发送数据, 每个包的大小不能超过64KB.
3. 不安全(不可靠)协议.
4. 效率相对较高.
5. 不区分客户端和服务器端, 叫发送端和接收端. TCP协议: //类似于: 打电话
1. 面向有连接(三次握手)
2. 采用IO流的形式发送数据, 理论上来讲无数据大小限制.
3. 安全(可靠)协议.
4. 效率相对较低.
5. 区分客户端和服务器端. 软件结构:
常用的软件主要分为: CS结构 和 BS结构
CS结构: Client(客户端) 和 Server(服务器端)
例如: QQ, 微信, LOL 特点:
需求安装客户端, 服务器端升级的时候, 客户端同步也要升级. 好处:
1. 降低服务器压力, 因为可以把一些必要的 大的文件, 提前让用户安装.
2. 用户体验较好. 因为一些必要文件已经提前下载好了, 所以此类产品界面一般做的比较好看. 弊端:
当服务器端升级的时候, 客户端同步也要升级. BS结构: Browser(浏览器端) 和 Server(服务器端)
例如: 天猫, 京东 特点:
无需安装特定软件, 只要有一个浏览器就可以访问. 好处:
1. 更灵活, 用户无需安装特定软件, 只要有一个浏览器就可以访问.
2. 用户体验较好, 只要有一个浏览器, 就可以访问了, 无需安装其他软件,
也无需定时更新指定的客户端.
弊端:
1. 服务器压力过大, 因为浏览器端所需的所有的数据都会从 服务器端下载.
2. 需要用户记忆大量的网址...
*/
public class Demo01 {
public static void main(String[] args) { }
}
package com.it.demo02_inetaddress; import java.net.InetAddress;
import java.net.UnknownHostException; /*
案例: 演示InetAddress IP地址包装类. InetAddress类的成员方法: IP地址的包装类
String形式的IP -> InetAddress类型的 IP地址对象.
public static InetAddress getByName(String ip地址/主机名); 根据字符串形式的ip(或者主机名), 获取其对应的 IP地址对象. InetAddress类型的 IP地址对象 -> String形式的IP
public String getHostAddress(); 根据IP地址对象, 获取字符串形式的IP
public String getHostName(); 根据IP地址对象, 获取字符串形式的 主机名
*/
public class Demo01 {
public static void main(String[] args) throws UnknownHostException {
//需求1: String -> InetAddress
//根据ip地址获取, 推荐方式.
String ip = "192.168.88.5";
InetAddress inet1 = InetAddress.getByName(ip);
System.out.println(inet1); //如果是通过ip获取的 IP对象, 打印的时候只有: ip地址
System.out.println("---------------------"); //根据主机名获取, 了解.
String hostName = "HangGe";
InetAddress inet2 = InetAddress.getByName(hostName);
System.out.println(inet2); //如果是通过 主机名获取的, 打印的时候是: 主机名, ip地址.
System.out.println("---------------------"); //需求2: InetAddress -> String
System.out.println(inet1.getHostAddress()); //192.168.88.5
System.out.println(inet1.getHostName()); //HangGe }
}
package com.it.demo03_udp; import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket; /*
案例: 演示UDP协议发送和接收数据
*/
//接收端.
public class ReceiveDemo {
public static void main(String[] args) throws Exception {
//1. 创建接收端的Socket对象, 指定端口号.
DatagramSocket ds = new DatagramSocket(12345); //2. 创建DatagramPacket对象, 用来接收 发送端发过来的数据.
// 要装数据的数组 数组的可用长度
//使用这个构造方法: DatagramPacket(byte[] buf, int length)
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys, bys.length); //3. 通过接收端的Socket对象, 接收发送端发过来的数据, 并存储到 数据报包对象中.
ds.receive(dp); //4. 从数据报包对象中获取数据.
byte[] data = dp.getData(); //从数据报包对象中获取数据.
int len = dp.getLength(); //从数据报包对象中获取 具体的有效字节数.
String s = new String(data, 0, len); //5. 打印数据.
System.out.println(s); //6. 关闭接收端的Socket对象.
ds.close();
}
}
package com.it.demo03_udp; import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress; /*
案例: 演示UDP协议发送和接收数据. 补充: 网络通信的原理
网络通信也叫Socket通信, 数据在两个Socket之间通过 数据报包 或者 IO流的形式进行传输.
*/
//发送端.
public class SendDemo {
public static void main(String[] args) throws Exception {
//1. 创建发送端的Socket对象.
DatagramSocket ds = new DatagramSocket();
//2. 定义要发送的数据.
String s = "恭喜发财, 红包拿来";
byte[] bys = s.getBytes(); //3. 将要发送的数据封装到 数据报包中(DatagramPacket)中.
// 要发送的数据 数据长度 接收端的IP地址 端口号
//使用这个构造方法: DatagramPacket(byte[] buf, int length, InetAddress address, int port)
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("127.0.0.1"), 12345); //4. 通过Socket对象, 发送数据报包
ds.send(dp); //5. 关闭Socket对象.
ds.close();
}
}
package com.it.demo04_tcp_quickstart; import java.io.OutputStream;
import java.net.Socket; /*
案例: 演示TCP协议之发送数据. 步骤:
1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
3. 通过输出流, 给服务器端写数据.
4. 关闭Socket对象.
*/ //客户端
public class ClientDemo {
public static void main(String[] args) throws Exception {
//1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("192.168.88.5", 10087);
//2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
OutputStream os = socket.getOutputStream();
//3. 通过输出流, 给服务器端写数据.
os.write("Hello, TCP , 我来了!".getBytes());
//4. 关闭Socket对象.
socket.close();
}
}
package com.it.demo04_tcp_quickstart; import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 演示TCP协议之接收数据. 步骤:
1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
4. 具体接收数据的动作.
5. 打印接收到的数据.
6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
//1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
ServerSocket server = new ServerSocket(10087);
//2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
//服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
System.out.println(1);
Socket accept = server.accept();
System.out.println(2);
//3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
InputStream is = accept.getInputStream();
//4. 具体接收数据的动作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//5. 打印接收到的数据.
System.out.println(s);
//6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
accept.close();
//server.close(); 服务器端Socket对象一般不关闭.
}
}
package com.it.demo05_tcp_exercise; import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket; /*
案例: 演示TCP协议之发送数据. 步骤:
1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
3. 通过输出流, 给服务器端写数据.
4. 关闭Socket对象.
*/ //客户端
public class ClientDemo {
public static void main(String[] args) throws Exception {
//1. 创建客户端Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("192.168.88.5", 10087);
//2. 通过 Socket#getOutputStream()方法, 获取输出流, 可以往服务器端写数据.
OutputStream os = socket.getOutputStream();
//3. 通过输出流, 给服务器端写数据.
os.write("Hello, TCP , 我来了!".getBytes()); //4. 获取输出流, 可以读取服务器端写过来的数据.
InputStream is = socket.getInputStream();
//5. 具体读取数据的操作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//6. 打印读取到的数据.
System.out.println(s); //7. 关闭Socket对象.
socket.close();
}
} package com.it.demo05_tcp_exercise; import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 演示TCP协议之接收数据. 步骤:
1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
4. 具体接收数据的动作.
5. 打印接收到的数据.
6. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
//1. 创建服务器端端Socket对象(ServerSocket), 指定端口号.
ServerSocket server = new ServerSocket(10087);
//2. 通过ServerSocket#accept()方法监听客户端连接, 如果有客户端申请建立连接,
//服务器端在审核完数据之后, 回自动创建一个Socket对象, 负责和此客户端的交互.
System.out.println(1);
Socket accept = server.accept();
System.out.println(2);
//3. 通过Socket#getInnputStream()获取输入流, 可以读取客户端发过来的数据.
InputStream is = accept.getInputStream();
//4. 具体接收数据的动作.
byte[] bys = new byte[1024];
int len = is.read(bys);
String s = new String(bys, 0, len);
//5. 打印接收到的数据.
System.out.println(s); //6. 获取输出流, 可以往客户端写数据.
OutputStream os = accept.getOutputStream();
//7. 给客户端写的具体的数据(回执信息)
os.write("数据已收到!".getBytes()); //8. 关闭Socket对象, 关闭的是与客户端Socket交互的对象, 而不是ServerSocket.
accept.close();
//server.close(); 服务器端Socket对象一般不关闭.
}
}
package com.it.demo06_tcp_exercise_upload; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\绕口令.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
//分解版
/*OutputStream os = socket.getOutputStream();
//转换流: 字节流 -> 字符流
OutputStreamWriter osw = new OutputStreamWriter(os);
//字符缓冲流: 普通的字符流 -> 高效的字符流
BufferedWriter bw = new BufferedWriter(osw);*/
//合并版
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //5. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo06_tcp_exercise_upload; import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception{
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010);
// 2. 监听连接.
Socket accept = server.accept();
// 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day13_socket/data/copy1.txt"));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
// 6. 关流, 释放资源.
bw.close();
accept.close(); }
}
package com.it.demo07_tcp_exercise_upload_message; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\绕口令.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
//分解版
/*OutputStream os = socket.getOutputStream();
//转换流: 字节流 -> 字符流
OutputStreamWriter osw = new OutputStreamWriter(os);
//字符缓冲流: 普通的字符流 -> 高效的字符流
BufferedWriter bw = new BufferedWriter(osw);*/
//合并版
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
System.out.println("client: 1");
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
System.out.println("client: 2"); //5. 核心操作, 客户端上传文件完毕后, 需要给服务器端一个结束标记, 意思是说: 我传完了, 你该干嘛干嘛.
socket.shutdownOutput(); //给服务器端一个结束标记. //6. 获取输入流, 读取服务器端写过来的回执信息.
BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//7. 具体接收数据的操作
System.out.println("client: 3");
String result = br2.readLine();
System.out.println("client: 4");
//8. 打印接收到的数据.
System.out.println(result);
//9. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo07_tcp_exercise_upload_message; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010);
// 2. 监听连接.
System.out.println("server: 1");
Socket accept = server.accept();
System.out.println("server: 2");
// 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter("day13_socket/data/copy1.txt"));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
System.out.println("server: 3");
String line;
while ((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
}
System.out.println("server: 4"); //6. 获取输出流, 给客户端写回执信息.
BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); //7. 给客户端写回执信息的具体操作.
bw2.write("文件上传成功");
bw2.flush(); //8.. 关流, 释放资源.
bw.close();
accept.close(); }
}
package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件. 思路:
1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
2. 获取字符缓冲输入流对象, 管理数据源文件.
3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
4. 具体的IO流操作, 读写数据.
5. 关流, 释放资源.
*/
//客户端
public class ClientDemo {
public static void main(String[] args) throws Exception{
//1. 创建客户端的Socket对象, 指定服务器端的ip, 端口号.
Socket socket = new Socket("127.0.0.1", 10010);
//2. 获取字符缓冲输入流对象, 管理数据源文件.
BufferedReader br = new BufferedReader(new FileReader("D:\\代码打字练习词库.txt"));
//3. 通过Socket#getOutputStream()获取输出流, 可以往服务器端写数据.
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); //4. 具体的IO流操作, 读写数据.
String line;
while((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //5. 核心操作, 客户端上传文件完毕后, 需要给服务器端一个结束标记, 意思是说: 我传完了, 你该干嘛干嘛.
socket.shutdownOutput(); //给服务器端一个结束标记. //6. 获取输入流, 读取服务器端写过来的回执信息.
BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//7. 具体接收数据的操作
String result = br2.readLine();
//8. 打印接收到的数据.
System.out.println(result);
//9. 关流, 释放资源.
br.close();
socket.close();
}
} package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; /*
案例: 客户端给服务器端上传文件 思路:
1. 创建服务器端Socket对象, 指定端口号.
2. 监听连接.
3. 创建字符缓冲输出流, 关联目的地文件.
4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
5. 具体的IO流操作, 读写数据.
6. 关流, 释放资源.
*/
//服务器端
public class ServerDemo {
public static void main(String[] args) throws Exception {
// 1. 创建服务器端Socket对象, 指定端口号.
ServerSocket server = new ServerSocket(10010); //服务器端要不断的监听客户端的连接.
while(true) {
// 2. 监听连接.
Socket accept = server.accept();
//3. 如果有, 就创建一个线程, 负责和此客户端的交互.
//new Thread(Runnable接口的子类对象).start();
new Thread(new ServerThread(accept)).start();
} }
} package com.it.demo08_tcp_upload_thread; import java.io.*;
import java.net.Socket; //自定义的线程资源类, 表示具体的接收文件, 并给出回执信息的动作.
//每一个客户端的Socket对象, 都对应一个服务器端线程(即: ServerThread)
public class ServerThread implements Runnable{
//定义变量, 表示和客户单Socket通信的 Socket对象.
private Socket accept; public ServerThread(Socket accept) {
this.accept = accept;
} //具体的接收文件, 并给出回执信息的动作.
@Override
public void run() {
try {
//解决: 文件重名问题.
int count = 1;
File file = new File("day13_socket/data/copy("+ count +").txt"); //copy(1).txt
while (file.exists()) {
//走这里, 说明文件存在
count++;
file = new File("day13_socket/data/copy("+ count +").txt"); //copy(2).txt, copy(3).txt
} // 3. 创建字符缓冲输出流, 关联目的地文件.
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
// 4. 通过Socket#getInputStream(), 获取输入流, 读取客户端写过来的数据.
BufferedReader br = new BufferedReader(new InputStreamReader(accept.getInputStream()));
// 5. 具体的IO流操作, 读写数据.
String line;
while ((line = br.readLine()) != null) {
//把读取到的数据写给服务器端
bw.write(line);
bw.newLine();
bw.flush(); //刷新出 缓冲区中的数据.
} //6. 获取输出流, 给客户端写回执信息.
BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); //7. 给客户端写回执信息的具体操作.
bw2.write("文件上传成功");
bw2.flush(); //8.. 关流, 释放资源.
bw.close();
accept.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Java 复习整理day10的更多相关文章
- java 复习整理（一 java简介和基础语法）
现在公司用的是封装太多东西的平台开发,觉着之前学的东西很多都忘了,所以想好好总结回顾一下.之前总是想学很多编程语言像python.s6.node.react,但现在越来越体会到编程语言只是一个开发的工 ...
- java复习整理（六 异常处理）
一.异常简介 在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出).Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性. ...
- java 复习整理（五 类加载机制与对象初始化）
类加载机制与对象初始化 一 . 类加载机制 类加载机制是指.class文件加载到jvm并形成Class对象的机制.之后应用可对Class对象进行实例化并调用.类加载机制可在运行时动态加载外部的类, ...
- java 复习整理（四 String类详解）
String 类详解 StringBuilder与StringBuffer的功能基本相同,不同之处在于StringBuilder是非线程安全的,而StringBuffer是线程安全的,因此效率上S ...
- java 复习整理（三 修饰符）
访问控制修饰符 Java中,可以使用访问控制符来保护对类.变量.方法和构造方法的访问.Java支持4种不同的访问权限. 默认的,也称为default,在同一包内可见,不使用任何修饰符. 私有的,以pr ...
- java 复习整理（二 数据类型和几种变量）
源文件声明规则 当在一个源文件中定义多个类,并且还有import语句和package语句时,要特别注意这些规则. 一个源文件中只能有一个public类 一个源文件可以有多个非public类 源文件的名 ...
- Java 复习整理day09
package com.it.demo01_thread; /* 案例: 多线程简介. 概述: 指的是进程有多条执行路径, 统称叫: 多线程. 进程: 指的是可执行程序, 文件(例如: .exe) 大 ...
- Java 复习整理day08
package com.it.demo02_lambda; //接口, 表示动物. //public abstract class Animal { //报错, Lambda表达式只针对于接口有效 p ...
- Java 复习整理day07
package com.it.demo05_innerclass; /* 案例: 演示内部类入门. 概述: 所谓的内部类指的是类里边还有一个类, 里边那个类叫: 内部类, 外边那个类, 叫外部类. 分 ...
随机推荐
- Java Object to Class
User user = new User(username,password); //添加构成JWT的参数 JwtBuilder builder = Jwts.builder().setHeaderP ...
- go语言中运算符
Go语言学习笔记(运算符)-day01 go语言中与其他语言一样,存在多种运算符,下表列出了go语言中的运算符类型 算数运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 算数运算符 运算符 描述 ...
- 用python做youtube自动化下载器 思路
目录 0. 思路 1.准备 i.savfrom.net 2. 探索并规划获取方式 i.总览 ii. 获取该网页取到下载url的请求 iii. 在本地获取请求 iv.解析请求结果 v.解析解密后的结果 ...
- P3714 [BJOI2017]树的难题 点分治+线段树合并
题目描述 题目传送门 分析 路径问题考虑点分治 对于一个分治中心,我们可以很容易地得到从它开始的一条路径的价值和长度 问题就是如何将不同的路径合并 很显然,对于同一个子树中的所有路径,它们起始的颜色是 ...
- Flutter 基础组件：Widget简介
概念 在Flutter中几乎所有的对象都是一个Widget.与原生开发中"控件"不同的是,Flutter中的Widget的概念更广泛,它不仅可以表示UI元素,也可以表示一些功能性的 ...
- Android事件分发机制一：事件是如何到达activity的？
事件分发,真的一定从Activity开始吗? 前言 很高兴遇见你~ 事件分发,android中一个老生常谈的话题了.基本的流程我们也都知道是从Activity开始分发,但有一个关键问题是:事件是如何到 ...
- Python使用Protobuf&&如何赋值&&如何正反序列化
前言 使用protobuf主要是两个步骤,序列化和反序列化. 关于Proto有哪些数据类型,然后如何编写,此处就不赘述了,百度一下有很多. 此文主要是总结,python使用protobuf的过程,如何 ...
- 关于QTableWidget中单元格拖拽实现
无重写函数实现单元格拖拽 缺点:需要额外设置一个记录拖拽起始行的私有成员变量和拖拽列的初始QList数据成员. 优点:无需重构函数,对于QT中信号和槽的灵活运用 信号和槽 // signal void ...
- 代码审计 - BugkuCTF
extract变量覆盖: 相关函数: extract()函数:从数组中将变量导入到当前的符号表.把数组键名作为变量名,数组的键值作为变量值.但是当变量中有同名的元素时会默认覆盖掉之前的变量值. tri ...
- Apache目录详解
Apache的主要目录和配置文件理解 参考链接:http://httpd.apache.org/docs/2.4/misc/security_tips.html 一.Apache主要配置文件注释(演示 ...