一 . sleep() 和 wait() 方法的区别
1) . 来源不同
<1>sleep()来自于Thread类中,表示线程睡眠 sleep(long time):时间毫秒值
<2>wait()来自于Object类中,表示线程等待,需要被锁对象来访问
2) . 是否会释放锁
<1>sleep(long time):属于一个普通方法,调用该方法,不会去释放锁,只是导致线处于睡眠,当线程的睡眠时间到了,就继续执行线程
<2> wait():属于锁方法,被锁对象访问之后,会立即释放锁,才能够使用同步等待唤醒机制解决死锁问题,通过锁对象调用notify(),唤醒对方线程
3) . 这两个方法都会抛出异常(中断异常),都是属于本地方法,底层非Java语言实现
<1>当线程睡眠过程中,睡眠还没到,导致的睡眠状态被打断,就会出现InterruptedException
<2>当线程处于等待状态,被中断,就抛出这个异常
二 . 设计模式
结构型设计模式----代理模式 :
代理就是代理角色帮助真实角色完成一些事情.
(1)动态代理:反射中讲
(2)静态代理:通过代理角色帮助真实角色完成一些事情,真实角色只只专注于自己的事情;前提条件:
代理角色和真实角色必须是同一个接口
三 . 线程组
常用方法:
<1>ThreadGroup(String name): 构造一个新的线程组;
<2>public final ThreadGroup getThreadGroup():获取当前线程所属的线程组
<3>public final String getName():获取线程组名称
四 . 线程池
1 . 常用的线程池接口和类
<1>Executor: 线程池的顶级接口
<2>ExecutorService: 线程池接口,继承自Executor,可通过submit提交任务代码
<3>Executors: 工厂类,通过此类可以获得一个线程池
<4>通过Executors静态方法newFixedThreadPool(int nThreads)可获得固定数量线程池
<5>通过Executors静态方法newCachedThreadPool()获得动态数量线程池,不够会创建新的,没上限
2 . 常用方法
<1>Future<?> submit (Runnable task): 提交Runnable异步任务
<2> <T>Future<T> submit (Callable<T> task): 提交Callable异步任务,需执行Callable中的call方法
<3>void shutdown(): 关闭线程池
<4>Callable接口是JDK5加入,与Runnable接口类似,实现之后代表一个线程任务,Callable具有泛型
返回值,可以声明异常.
3 . Lock锁 ( 接口 )
jdk5以后提供Lock接口,比synchronized具有扩展性的功能,子实现类ReentrantLock:可重入互斥锁.
<1>public void lock()获取锁
<2>public void unlock()释放锁
处理异常: try...catch...finally(释放资源:代码一定执行/除非执行之前jvm退出了),捕获异常标准格式.
private Lock lock = new ReentrantLock(); 创建重入锁对象
@Override
public void run() {
while(true){
lock.lock(); 显示开启锁
try{
if(tickets > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+"正在出售第"+tickets--+"张票");
}
}finally {
lock.unlock(); 显示释放锁
}
4 . 线程池中7大参数
<1>private volatile int corePoolSize: 线程池中的常驻核心线程数量
<2>private volatile int maximumPoolSize: 线程池能够容纳同时执行的最大线程数,值大于等于1。
<3>private volatile long keepAliveTime: 多余的空闲线程存活时间,当存活时间达到此值时,多余
的线程会被销毁直到只剩下corePoolSize个线程为止.
<4>private final BlockingQueue<Runnable>workQueue:任务队列,被提交但尚未被执行的任务
<5>private volatile ThreadFactory: 表示生成线程池中工作线程的线程工厂,用户创建新线程,一
般用默认即可
<6>private volatile RejectedExecutionHandler handler:拒绝策略,表示当线程队列满了并且工作
线程大于等于线程池的最大显示数(maxnumPoolSize)时如何来拒绝请求执行的runnable的策略.
<7>Timeunit unit: unit是keepAliveTime存活时间的计量单位.
五 . Timer:JavaSE的定时器
java.util.Timer :JavaSE的定时器:处理一次或者重复执行的任务(TimerTask:抽象类).
1 . 构造方法
public Timer():创建一个新的定时器,不是守护线程
2 . 成员方法
<1>public void cancel():取消定时器
<2>public void schedule(TimerTask task,long delay):经过多少毫秒后执行一次定时任务
<3>public void schedule(TimerTask task,long delay,long period): 经过delay毫秒后指向定时任务,
每经过period重复执行定时任务
<4>public void schedule(TimerTask task,Date time) :在指定时间的时候(精确到毫秒)执行定时任务
<5>public abstract void run():定时器要执行的操作,此方法为TimerTask方法
注意:TimerTask:抽象类不能实例化:自定义子类或者匿名内部类.
public class TestTimer {
public static void main(String[] args) {
Timer tm = new Timer();
tm.schedule(new TimerTest(tm),2000,1000);
}
}
public class TimerTest extends TimerTask {
private Timer t;
public TimerTest(Timer t){
this.t = t;
}
@Override
public void run() {
System.out.println("执行任务...");
t.cancel();
}
}
六 . 设计模式之创建型模式
1 . 简单工厂模式
简单工厂模式:也称为"静态工厂方法模式",主要作用负责某些类的实例创建过程.
优点:通过工厂类完成各个类的对象的创建
弊端:当有新的类型增加,需要不断的修改工厂类,维护性难度大
public static Animal createAnimal(Object obj){ //向上转型:
if(obj instanceof Cat){
return new Cat() ;
}else if(obj instanceof Dog){
return new Dog() ;
}else if(obj instanceof Pig){
return new Pig() ;
}
return null ;
}
Animal animal = AnimalFactory.createAnimal(new Cat());
if(animal!=null){
animal.eat();
animal.sleep();
}
}
2 . 工厂方法模式
工厂方法模式中抽象工厂类负责定义创建对象的接口,具体对象的创建工作由继承抽象工厂的具体
类实现。
优点:具体的工厂类负责创建当前具体的实例,结构层次很清晰,有具体类/工厂类/抽象工厂(接口)
弊端:有新的类型增加,需要编写外的代码,所有代码增加,导致工作量增加了
public class FactoryMethod {
public static void main(String[] args) {
Factory factory = new DogFactory() ;
Animal animal = factory.createAnimal();
animal.eat() ;
animal.sleep() ;
factory = new CatFactory() ;
Animal animal2 = factory.createAnimal();
animal2.eat() ;
animal2.sleep() ;
}
}
public interface Factory { //抽象工厂(接口比抽象类还抽象)
Animal createAnimal() ; //抽象方法:创建动物
}
public class CatFactory implements Factory {
@Override
public Animal createAnimal() { //抽象类多态
return new Cat();
}
}
3 . 单例模式
单例:一个类的实例在内存中有且仅有一个.
分两种情况:饿汉式和懒汉式.
(1)饿汉式:永远不会出现安全问题的一种单例模式:
当类一加载,就创建了当前类对象,而且始终只有一个
<1>自定义具体类
<2>无参构造私有化,不让外界new对象
<3>在当前类成员位置创建自己本身对象
<4>当前类中提供一个对外公共静态的功能,返回值是他本身
public class Simple {
private Simple(){}
private static Simple s = new Simple();
public static Simple method(){
return s;
}
}
public class TestSimple {
public static void main(String[] args) {
Simple s1 = Simple.method();
Simple s2 = Simple.method();
System.out.println(s1 == s2); true
}
}
(2)懒汉式:可能存在多线程安全问题的一种单例模式
<1>自定义具体类
<2>无参构造私有化,不让外界new对象
<3>需要在成员位置声明当前类型的变量
<4>提供一个对外公共静态访问方法,返回值是当前类本身
public class Simple {
private Simple(){}
private static Simple s;
public static synchronized Simple method(){
if(s == null){
s = new Simple();
}
return s;
}
}
public class TestSimple {
public static void main(String[] args) {
Simple s1 = Simple.method();
Simple s2 = Simple.method();
System.out.println(s1 == s2);
}
}
七 . Runtime类
Runtime类:每个Java程序都有自己的运行环境,通过Runtime创建的实例表示:当前系统的运行环境.
原码使用的是饿汉式
public class TestRuntime {
public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();创建当前运行环境的实例
}
}
常用方法:
<1>public int availableProcessors(): 获取计算机cpu的处理器数量
<2>public Process exec(String command) throws IOException: 操作指令
<3>runtime.exec("shutdown -s -t 300") ;关机指令
八 . 递归
1 . 递归的概念
递归:方法调用方法本身的一种现象;而不是方法嵌套方法.
2 . 递归思想
<1>必须定义一个方法(函数)
<2>有一定的规律
<3>必须有出口条件(结束条件),如果没有结束条件就是死递归.
注意:构造方法不存在递归.
3 . 递归例题:求5的阶乘
public class TestDiGui {
public static void main(String[] args) {
int result = method(5);
System.out.println(result);
}
public static int method(int n){
if(n == 1){
return 1; 出口条件
}else{
return n * method(n-1);
}
}
}
九 . File类
File:描述的是一个文件/目录的抽象路径名的形式.
1 . 构造方法
<1>File(String pathname): 直接描述地址路径
<2>File(File parent, String child): 从父抽象路径名和子路径名字符串创建新的 File实例
<3>File(String parent, String child): 从父抽象路径名字符串和子路径名字符串创建新的 File实例
2 . 成员方法
<1>public boolean createNewFile() throws IOException:创建文件,如果文件不存在,就会自动创建,
创建成功,返回true
<2>public boolean mkdir():创建文件夹(目录),如果文件夹不存在,则自动创建;创建成功,返回true,否
则false;
<3>public boolean mkdirs():针对带多级目录创建;如果父目录不存在,会自动创建
<4>public boolean delete():删除文件或者目录,删除必须为空目录
<5>public boolean isDirectory(): 判断是否是文件夹
<6>public boolean isFile() :判断是否是文件
<7>public String getName():获取当前抽象路径名表示的文件或者文件夹的名称
注意:如果没有带盘符,创建的文件或者文件夹相对路径:默认在当前项目下
3 . 高级功能
<1>public File[] listFiles():获取某个目录下的所有文件以及文件夹的File数组
<2>public String[] list():返回由 File 对象表示目录中所有文件和子目录名称组成的字符串数组,如
果调用的 File 对象不是目录,则返回 null;此方法返回的数组中仅包含文件名称,而不包含路径。
<3>public String[] list(FilenameFilter filter): 该方法的作用与 list() 方法相同,不同的是返回数组中
仅包含符合 filter 过滤器的文件和目录,如果 filter 为 null,则接受所有名称.
<4>public File[] listFiles(FilenameFilter filter): 使用文件名称过滤器作为参数传递:
假设希望只列出目录下的某些文件,这就需要调用带过滤器参数的 list() 方法。首先需要创建文件
过滤器,该过滤器必须实现 FilenameFilter接口,并在 accept() 方法中指定允许的文件类型。
boolean accept(File dir,String name):是否将name文件名称添加抽象类路径名所表示的列表中,取
决于返回值 true,表示将name添加到文件过滤列表中,否则false,不添加.
public class TestFile {
public static void main(String[] args) {
File file = new File("D:\\");
File[] files = file.listFiles();
if(files != null){
for(File f : files){
if(f.isFile()){
if(f.getName().endsWith(".jpg")){
System.out.println(f.getName()+"---"+f.delete());
}
}
}
}
}
}
十 . IO 流
1. 流的分类
(1)按方向
<1>输入流:将存储设备中的内容读入到内存中
<2>输出流:将内存中的内容写入到存储设备中
(2)按单位
<1>字节流:以字节为单位,可以读写所有数据
<2>字符流:以字符为单位,只能读写文本数据
(3)按功能
<1>节点流:具有实际传输数据的读写功能
<2>过滤流:在节点流的功能之上增强功能
2. 文件输出流的创建及写数据
<1>public FileOutputStream(String name) throws FileNotFoundException:创建文件输出流
<2>public FileOutputStream(String pathname,boolean append):如果第二个参数为true,则自动在
后面追加
<3>void write(byte[] b):写入一个字节数组
<4>void write(byte[] b, int off, int len):写入字节数组的一部分
<5> void write(int b ):写入单个字节
<6>close():释放资源
3.文件输入流的创建及读数据
<1>public FileInputStream(String name) throws FileNotFoundException:创建文件字节输入流对象
<2>abstract int read():一次读取一个字节,返回的读取的字节数,如果达到文件末尾返回-1
<3>int read(byte[] b) :一次读取一个字节数组
注意:将文件内容打印在控制台: 如果文件中有中文,出现乱码,原因就是我们对读取的字节数强转为
char,一个英文对应一个字节,但是一个中文8个字节,拼接不上导致乱码.
windows操作系统中:写入数据的时候,换行符号 "\r\n"
4.异常处理
(1)throws:抛出---抛在方法声明上,谁调用这个方法,谁就是调用者,通过调用者进行处理;
(2)try...catch...finally:捕获----通过业务逻辑代码(业务层代码:service层)
(3)try...catch; try...catch...catch...catch; try...finally
try{
可能出现问题的代码;---一旦这有问题:Jvm 就会创建异常对象
} catch (异常类名 e) { //如果和当前异常类名匹配了
处理异常
System.out.println("数组角标越界了") ;
e.printStackTrace() ;//可以看到你自己写的代码哪块出错了以及底层原码
}finally{
释放资源
}
5.字节缓冲流
BufferedOutputStream:字节缓冲输出流(别名 "字节高效流");这个流仅仅是在内部提供了一个缓冲
区(字节数组),针对文件的输出并且同时写入数据使用的还是底层流OutputStream.
(1)构造方法
public BufferedOutputStream(OutputStream out):构造一个默认的缓冲区大小,通过底层流进行输.
使用字节缓冲输出流写数据:一次写1个字节数组
public class Test03 {
public static void main(String[] args) throws IOException {
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
bos.write("helloword".getBytes());
bos.close();
}
}
第四种:使用字节缓冲输入流一次读取1个字节数组
public class Test04 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("TestInt.java"));
byte[] bytes = new byte[1024];
int n = 0;
while((n = bis.read(bytes))!= -1){
System.out.println(new String(bytes,0,n));
}
bis.close();
}
}
6.合并流
SequenceInpuStream----是InputStream的子类:它这个类只能操作源文件
<1>public SequenceInputStream(InputStream s1,InputStream s2):将两个字节输入流对象指向的
文件进行合并
<2>public SequenceInputStream(Enumeration<? extends InputStream> e)
合并两个文件
public class Test05 {
public static void main(String[] args) throws IOException {
FileInputStream fis1 = new FileInputStream("GetChar.java");
FileInputStream fis2 = new FileInputStream("TestInt.java");
SequenceInputStream sis = new SequenceInputStream(fis1,fis2);将两个文件封装进去
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.java"));
byte[] bytes = new byte[1024];
int n = 0;
while((n = sis.read(bytes))!= -1){
bos.write(bytes,0,n);
bos.flush();
}
bos.close();
sis.close();
}
}
合并多个文件
public class Test05 {
public static void main(String[] args) throws IOException {
FileInputStream fis1 = new FileInputStream("GetChar.java");
FileInputStream fis2 = new FileInputStream("TestInt.java");
FileInputStream fis3 = new FileInputStream("Test03.java");
Vector<InputStream> v = new Vector<>();
v.add(fis1);
v.add(fis2);
v.add(fis3);
Enumeration<InputStream> elements = v.elements();
SequenceInputStream sis = new SequenceInputStream(elements);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.java"));
byte[] bytes = new byte[1024];
int n = 0;
while((n = sis.read(bytes))!= -1){
bos.write(bytes,0,n);
bos.flush();
}
bos.close();
sis.close();
}
}
7.Reader类
Reader:字符流,为抽象类
(1)字符输入流
<1>InputStreamReader(InputStream in) :使用平台默认的字符集进行解码,里面包装的字节流
<2>InputStreamReader(InputStream in,String charsetName):使用指定的字符集进行解码
<3>read()
<4>read(char[] chs)
public class Test06 {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");
int c = 0;
while((c = isr.read()) != -1){
System.out.print((char)c);
}
isr.close();
}
}
(2)字符输出流
<1> OutputStreamWriter(OutputStream out) :使用平台默认的编码字符集进行编码--->写入数据
<2>OutputStreamWriter(OutputStream out,String charsetName )使用指定的编码字符集进行编码
OutputStreamWriter oos = new OutputStreamWriter(new FileOutputStream("oos.txt"),"GBK") ;
oos.write("hello,字符流");
oos.close() ;
8.字符缓冲流
(1)字符缓冲输入流
<1>BufferedReader(Reader in)
<2>特有功能:String readLine() 读取一行内容.
(2)字符缓冲输出流
<1>BufferedWriter(Writer out) :提供默认缓冲区大小,默认值足够大:8192个长度(底层是一种字符数组)
<2>特有功能:public void newLine() throws IOException :写入行的分隔符号
public class Test06 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("a.txt"));//创建字符缓冲输入流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));//创建字符缓冲输出流对象
String line = null;
while((line = br.readLine())!=null){
bw.write(line);
bw.newLine();//换行
bw.flush();
}
bw.close();
br.close();
}
}
十一.Lock和synchronized的区别
(1)synchronized是一个关键字:底层实现是一些指令:监视器锁(monitor),是一种悲观锁(独占锁),当
某个线程持有这个锁的时候,其他线程访问不到;应用场景:少量同步代码使用synchronized;默认的锁
的释放是需要等待执行完毕同步方法或者同步代码块
(2)Lock是接口,基于子实现类(ReentrantLock)进行实现:可重入的互斥锁,底层实现原理采用CAS(比
较和交换)算法,本质属于乐观锁;应用场景:针对大量的同步代码使用Lock;本身就提供具体的功
能,lock()/unlock().
十二.序列化与反序列化
1.序列化
(1)序列化:就是在将Java对象变成一种流数据,他们里面的数据存储流中,就可以在网络中传输.
前提条件:实体类必须实现标记接口序列化.
(2)构造方法:public ObjectOutputStream(OutputStream out)
(3)成员方法:public final void writeObject(Object obj) throws IOException:写入一个实体对象
创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")) ;
Person p = new Person() ;
p.name = "张三" ;
p.age = 21 ;
oos.writeObject(p) ;
oos.close() ;
2.反序列化
(1)反序列化:就是将流数据(存储的一些相关的实体类数据)-----还原成Java对象
(2)构造方法:public ObjectInputStream(InputStream in):将文件中的数据进行读取
(3)成员方法:public final Object readObject()将流中的数据读取出来,解析成对象
创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt")) ;
Object object = ois.readObject();
System.out.println(object) ;
ois.close() ; 关闭资源
十三.Properties属性集合类
java.util.Propertis:属性集合类(属性列表)是一个Map,但是没有泛型,键和值都是String
1.特有功能
<1>public Object setProperty(String key,String value):添加键和值
<2>public Set<String> stringPropertyNames():获取所有键的集合
<3>public String getProperty(String key):获取键对应的值
<4>public void store(Writer writer, String comments):将属性列表中的内容保存指定的文件中
<5>public void load(Reader reader):将文件中的内容加载属性列表中
2.专属遍历方式
专属遍历方式
Properties p = new Properties();
p.setProperty("张三","23");
p.setProperty("李四","34");
p.setProperty("王五","54");
Set<String> strings = p.stringPropertyNames();
for(String key : strings){
String value = p.getProperty(key);
System.out.println(key+"-"+value);
}
3.典型功能
将属性列表中的内容保存指定文件中
public class Test03 {
public static void main(String[] args) throws IOException {
Properties p = new Properties();
p.setProperty("张三","23");
p.setProperty("李四","34");
p.setProperty("王五","54");
p.store(new FileWriter("b.txt"),"姓名列表");
}
}
将文件中内容加载进来,将属性列表中内容进行遍历
public class Test03 {
public static void main(String[] args) throws IOException {
Properties p = new Properties();
p.load(new FileReader("a.txt"));
Set<String> strings = p.stringPropertyNames();
for(String key : strings){
String value = p.getProperty(key);
System.out.println(key+ "-"+value);
}
}
}
Class c = Test01.class ; 1)获取当前类的字节码文件对象
ClassLoader classLoader = c.getClassLoader(); 2)获取类加载器
3)通过类加载获取当前src目录下面的配置文件所在的输入流对象
InputStream inputStream = classLoader.getResourceAsStream("name.properties");
创建Properties
Properties prop = new Properties() ;
prop.load(inputStream);
System.out.println(prop) ;
十四.网络编程
1.UDP协议方式发送端与接收端思路
(1)UDP发送端思路
<1>创建UDP发送端的Socket对象
<2>创建数据,并把数据打包
<3>调用Socket对象的发送方法发送数据包
<4>释放资源
public class Receive{
public static void main(String[] args) throws IOException {
1)创建接收端的Socket对象DatagramSocket
DatagramSocket ds = new DatagramSocket(10086) ;
while(true){
byte[] bytes = new byte[1024] ; 创建一个接收容器: 自定义一个缓冲区byte[]
int length = bytes.length ;
DatagramPacket dp = new DatagramPacket(bytes,length) ; 创建数据包报
ds.receive(dp); 3)接收
4)解析接收容器中的真实内容
String str = new String(dp.getData(),0,dp.getLength()) ;
String ip = dp.getAddress().getHostAddress() ;
System.out.println("data from "+ip +",content is :"+str) ;
}
ds.close() ;
}
}
(2)UDP接收端思路
<1>创建接收端的Socket对象
<2>创建一个数据包(接收容器)
<3>调用Socket对象的接收方法接收数据
<4>解析真实数据
<5>展示ip和发送的内容
public class Send{
public static void main(String[] args) throws Exception {
1)创建UDP发送端的Socket对象
DatagramSocket ds = new DatagramSocket() ;
创建一个BufferedReader流对象:键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
String line = null ;
while((line=br.readLine())!=null){
if("886".equals(line)){
break ;
}
2)创建数据报包
DatagramPacket dp = new DatagramPacket(line.getBytes(), line.getBytes().length,
InetAddress.getByName("10.12.159.190"),10086) ;
3)发送
ds.send(dp) ;
}
4)释放资源
ds.close() ;
}
}
2.TCP/IP服务器端与客户端的实现步骤
(1)TCP/IP 客户端的实现步骤
<1>创建客户端的Socket对象
<2>获取客户端所在的通道内的字节输出流OutputStream
<3>给客户端通道内的流中写入数据
<4>释放客户端的资源对象
public class Client{
public static void main(String[] args) throws IOException {
1)创建客户端的Socket对象
Socket socket = new Socket("10.12.159.190",10010) ;
2)获取客户端所在的通道内的字节输出流
OutputStream out = socket.getOutputStream();
3)写数据:给通道流中写入数据
out.write("helloworld".getBytes());
4)释放资源
socket.close() ;
}
}
(2)TCP/IP服务器端的步骤实现
<1>创建服务器端的Socket对象
<2>监听客户端的连接
<3>获取连接的客户端的通道内的输入流
<4>展示数据
<5>释放资源
public class ServerDemo {
public static void main(String[] args) throws IOException {
1)创建服务器端的Socket对象
ServerSocket ss = new ServerSocket(10010) ;
2)监听客户端的连接,一旦监听到了,就获取到客户端的Socket
Socket socket = ss.accept();
3)获取连接的客户端的通道内的输入流,读取数据
InputStream inputStream = socket.getInputStream();
4)读:一次读取一个字节数组
byte[] bytes = new byte[1024] ;
int len = inputStream.read(bytes);
String str = new String(bytes,0,len) ;
String ip = socket.getInetAddress().getHostAddress(); 获取ip地址
5)展示数据
System.out.println(ip + str);
ss.close() ; 释放资源
}
}
3.UDP和TCP的区别
(1)TCP面向连接;UDP是无连接的,即发送数据之前不需要建立连接
(2)TCP要求的系统资源较多,UDP较少
(3)TCP提供可靠的服务.通过TCP连接传送的数据不丢失,不重复,且按序到达;UDP存在安全问题
十五.throw和throws的区别
1)使用位置不同
throws:跟在方法上,可以跟多个异常类名,中间逗号隔开
throw:方法体的语句中,后面的异常对象 new XXXExeption()
2)处理方式不同
throws:它的处理交给调用者处理,谁调用这个带throws的方法,谁就需要进行处理
throw:它的处理交给方法体中逻辑语句处理;
3)是否出现异常的可能性
throws:可能出现异常
throw:表示执行某段代码一定会出现这个异常
十六.获取一个类字节码文件
<1>Object类的getClass()-->Class ---class 包名.类名
<2>任意Java类型的class属性
<3>public static Class forName(String className)
Class.forName("包名.类名") ; 第三种方式:反射中Class使用这种