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; /* 案例: 演示内部类入门. 概述: 所谓的内部类指的是类里边还有一个类, 里边那个类叫: 内部类, 外边那个类, 叫外部类. 分 ...
随机推荐
- Dubbo 就是靠它崭露头角！(身为开源框架很重要的一点)
Hola,我是 yes. 经过了 RPC 核心和 Dubbo 微内核两篇文章后,今天终于要稍稍深入一波 Dubbo 了. 作为一个通用的 RPC 框架,性能是很重要的一环,而易用性和扩展性也极为重要. ...
- LeetCode700 二叉搜索树中搜索
给定二叉搜索树(BST)的根节点和一个值. 你需要在BST中找到节点值等于给定值的节点. 返回以该节点为根的子树. 如果节点不存在,则返回 NULL. 例如, 给定二叉搜索树: 4 / \ 2 7 / ...
- 【Flutter】可滚动组件之GridView
前言 GridView可以构建一个二维网格列表.需要关注的是gridDelegate参数,类型是SliverGridDelegate,它的作用是控制GridView子组件如何排列(layout).Sl ...
- python学习笔记 | PyCharm创建文件时自动添加头文件
File Settings Editor File and Code Templates Python Script 然后在右边的框中写入信息就可以啦: # -*- coding: utf-8 -*- ...
- 记一道C语言编程题（C语言学习笔记）
题目如下 解答如下 #include <stdio.h> #include<math.h> double Mysqrt(double n) { return sqrt(n); ...
- webapi Swagger 配置 services.BuildServiceProvider() 报警 ASP0000 问题处理
问题起源 网上的常见配置 Swagger 配置 在Startup类的 ConfigureServices 使用 services.BuildServiceProvider() ,其中有段代码如下: v ...
- Spring Bean详解
Spring Bean 在Spring的应用中,Spring IoC容器可以创建.装配和配置应用组件对象,这里的组件对象称为Bean. Bean的配置 Spring可以看作一个大型工厂,用于生产和管理 ...
- 低功耗降线性稳压器，24V转5V降压芯片
PW2330开发了一种高效率的同步降压DC-DC变换器3A输出电流.PW2330在4.5V到30V的宽输入电压范围内工作集成主开关和同步开关,具有非常低的RDS(ON)以最小化传导 损失.PW2330 ...
- JDBC代码的优化
JDBC代码简化以及PreparedStatement和Statement接口 抽取 JDBC的Bug sql语句可以拼接导致登录功能中如果用户名或者密码中出现'or'2'='2则一定可以登录的bug ...
- JS中常用的工具类
一.日期工具类 /** * 日期时间工具类 * @type {{dateFormat}} */ var DateTime = function () { var patterns = { PATTER ...