open(“请求情势,什么是反光

普普通通状态便是是当下类,private属性或措施也是不能够访问的,你须要设置压制权限setAccessible(true)来取得private的访问权。但说实话,这一度磨损了面向对象的规则,

2) 网络编制程序

目标:使网络中的总计机能够拓展通讯
一定网络中的一台微型总结机 InetAddress 数据的传导

TCP是Tranfer Control Protocol的简称,
是一种面向连接的保管保障传输的商谈
UDP是User Datagram Protocol的简称,是一种无连接的不可信赖协议。
传输的数码遭到限制 最大64K (QQ离线)

Socket——> 套接字
网络上的四个程序通过二个双向的报道连接完成数据的调换,
以此双向链路的一端称为一个Socket。
Socket常常用来贯彻客户方和服务方的连年。
Socket是TCP/IP协议的三个十一分流行的编制程序界面,
三个Socket由3个IP地址和三个端口号唯一明确

  在运营时判断任意三个类所持有的积极分子变量和措施

5. 种类化与反系列化

持久化:把内部存款和储蓄器中的对象 数据 保存在介质[文件,数据库] 中去
系列化: 把java对象 存在文件 中 但不是不管三七二十一对象都能够种类化
设若三个目的要力所能及体系化 那么那个指标的类 必须可系列化
可类别化 的类 必须要完结2个 Serializable 接口

种类化->ObjectOutputStream 对象存储到文件中
反体系化->ObjectInputStream 文件去读出来变成对象
静态属性不会类别化到文件中

 1 package com.asd.tzy;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectInputStream;
 8 import java.io.ObjectOutputStream;
 9 import java.io.Serializable;
10 
11 public class ObjectInputOutputDemo {
12 
13     public static void main(String[] args) throws IOException {
14         Stduent st = new Stduent("张三", 30);
15         FileOutputStream fos = new FileOutputStream("d:\\tzy.txt");
16         ObjectOutputStream oos = new ObjectOutputStream(fos);
17         oos.writeObject(st);//把对象序列化到制定文件输出流中
18 //         java.io.NotSerializableException
19         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\tzy.txt"));
20         try {
21             Stduent stu = (Stduent) ois.readObject();
22             System.out.println(stu);
23         } catch (ClassNotFoundException e) {
24             e.printStackTrace();
25         }finally{
26             ois.close();
27         }
28     }
29 
30 }
31 
32 class Stduent implements Serializable{
33     /**
34      * 
35      */
36     private static final long serialVersionUID = 7425793184115828439L;
37     private String name;
38     private int age;
39     private String address;
40     public Stduent(String name, int age) {
41         super();
42         this.name = name;
43         this.age = age;
44     }
45     public String getName() {
46         return name;
47     }
48     public void setName(String name) {
49         this.name = name;
50     }
51     public int getAge() {
52         return age;
53     }
54     public void setAge(int age) {
55         this.age = age;
56     }
57     @Override
58     public String toString() {
59         return "Stduent [name=" + name + ", age=" + age + "]";
60     }
61     
62 }

2) java怎么落到实处四线程

先是种方法:
a:写多个类 extends Thread
b:重写run() 方法
c:创设线程类对象,调用对象的 start()方法
第3中方法:
a:写贰个类 达成Runable 接口
b:实现Runable 接口中run() 方法
c:创立该类对象
d:再成立两个 Thread类的靶子,传递一个兑现Runnable接口类的对象
e:再调用 Thread类的对象 的
start()方法(因为只有线程Thread有start方法

在Thread类中能够:
this.getName()来获得线程的称谓
在非Thread类中得以:
Thread.currentThread().getName() 来获取当前正值周转线程的称号

因而反射获取并调用方法

1)ajax 的核心目的是XMLHttpRequest

XMLHttpRequest存在浏览器端,分化的浏览器 创立情势各异
日前可比主流浏览器内核:v/p

火狐内核 :火狐 google..
window.XMLHttpRequest
IE内核 : IE6 -IE11 360 遨游
Window.ActiveXObject

卖票Thread

2)java.io.File 类

File 构造方法

       File f=new File("文件绝对路径");
       File f=new File("文件父级文件夹路径","文件名");
       File f=new File(File dir,"文件名");
       File f=new File(URL url);

     f.exists();判断文件是否存在      
     f.createNewFile(); 创建文件
     f.mkdir();  创建文件夹

     listFiles();
      listFiles(FileFilter filter)  

InputStream抽象类

2)XMLHttpRequest 对象中的方法

a: 客户端与劳动器端建立连接
open(“请求格局[get|post]”,”请求路径”,是或不是异步 [true|false]);
b:
监听服务器状态onreadystatechange,钦赐回调函数(当状态只要爆发变化,就调用那个回调函数)

状态 readyState(属性)
0 连接还未建立达成
1 早已建立连接 请求未加载
2 正在加载
3 请求已经加载成功 正在相互之间中
4 完结交互

c: send();发送请求
d: 达成交互 服务器响应状态 status(属性):

200 服务器端成功拍卖了请求
400 服务器端处理退步
404 服务器端找不到拍卖请求的地方
500 服务器端内部错误

e:服务器回调回来的值:
XMLHttpRequest对象的习性responseText

  使用interrupt方法中断线程。

1)用法:

  • 1:引入 jquery.xxxx.js
    jquery.1.xx.js 出色的包容性
    jquery.2.xx.js 帮忙IE8以上的本子 firefox2.0
  • 2:初始化方法

       $(document).ready(function(){
       }); 

可以简写 $(function(){}); 与 window.load=function(){}类似

  将数据开始展览packet包的卷入,必要求钦赐指标地
地址和端口

1)名词解释

  • I/o : Input/OutPut 输入/输出
  • 流 : 具有发生多少的数据源对象 或许具有接收数据的客户端对象
  • I/O流 : 站在程序的角度
    用来发出多少的数据源对象 输入流;
    有接收数据的客户端对象 输出流
  • 为什么要选择 I/O流
    因为电脑cpu 不能够平昔读取硬盘的上的数量
    计算机要开始展览读写多少必须要透过I/o流来操作
  • java中的I/O ->java.Io
  • java中的文件操作
  • InputStream 抽象的类 输入流
    OutputStream 抽象的类 输出流

  将socket关闭

4) 八线程安全题材(synchronized)

Java程序能够让十二线程来还要推行,假诺四线程要访问共同的数额,可能会造成数据
的差异的标题,所以要做线程的同步难点。
线程的一道就是让同叁个岁月点唯有一个线程可以访问共享的财富.

随便走访文件的行为看似存储在文件系统中的一个特大型byte数组。存在指向该隐含数组的光标或索引,称为文件指针

2.ajax(Asynchronous JavaScript and XML)

异步的JavaScript and XML技术
不刷新整个页面,仅仅局地刷新 让客户端与劳动器端实行通讯
它不是四个新技巧,只是两种技术的结缘

  BufferedInputStream和BuffOutputStream

3) I/O流分类

  1. 基于方向划分 : 输入、输出流
  2. 依照操作字节数来分:
    字节流 遵照1个字节二个字节操作 只操作三个字节(8bit)

输入字节流 InputStream 用于读取字节流的抽象类 常见子类
FileInputStream 输出字节流 OutputStream 写入字节流的抽象类 常见子类
FileOutputStream

字符流 依照多少个字节操作(16bit)

输入字符流 Reader用于读取字符流的抽象类
常见子类 InputStreamReader,FileReader
输出字符流 Writer写入字符流的抽象类
常见子类 OutputStreamWriter,FileWriter

  1. 可以操作Java的数据类型,是与机械和工具非亲非故的操作流
    DataInputStream , DataOutputStream
  2. 卷入流 对基本流举行添加缓存作用的流

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

  类是程序的一局部,每种类都有贰个Class对象。换言之,每当编写并且编写翻译一个新类,就会时有产生与之对应的三个Class对象。

3.query 轻量级 javaScript 框架

写的少做的多,优异的兼容性
强大的挑三拣四器 dom 操作

获伏贴前类证明的有着Field

1)内部类

  1. 常常的内部类 (成员内部类 )
    在二个类的类体里面表明的二个类
  2. 静态内部类
    在三个类的类体里面申明的二个类 加上static 修饰符
  3. 匿名内部类

    “字节流”用来读写伍个人二进制的字节;(mp5,MP3,图片摄像等多媒体文件)

3) 线程中常见方法:

  • boolean isAlive() 判断线程是还是不是处于活动状态(就绪)
    叁个线程类对象 在start()以前 没有处在活动状态
    在start()之后 run() 运营成功此前 都处于 活动状态
    run()运转达成今后 没有处于活动状态
  • join() 合并线程
  • yield() 让出 cpu 的使用权
  • sleep(long millis) 让日前线程休眠钦命的时间 微秒数
    sleep 但不会放出cpu的使用权 也不自由占用的能源
  • interrupt() 中断线程。
  • 线程的先行级 暗许值是 5 范围 0-9 值越大 越优先
    getPriority() 再次回到线程的先期级。
    setPriority(int newPriority) 更改线程的优先级。
    先行级 越高 只是越有机会取得cpu的使用权 并不是肯定先运转
  • stop();让线程消亡
  • wait();让日前线程暂停实施,进入等待队列,供给notify()或noyifyAll()唤醒才能进来就绪状态
  • notify();唤醒等待队列中的贰个线程
  • notifyAll();唤醒等待队列中的所无线程

    使用start()方法运营二个线程后,系统为该线程分配了除CPU外的所需能源,使该线程处于就绪状态。此外,假如有个别线程执行了yield()方法,那么该线程会被近期

1)线程和进度有怎么样分裂?

  • 经过它是程序的一次运营,所以它会有单独的内部存款和储蓄器空间
    线程是经过的一条实施的端倪,该进程的享无线程都共享
    进程的内存,没有独立的内存空间
  • 二个进程分成多条线程,同时执行叫做四线程

      态,也说不定处于终止状态

2)选择器

a. id 选择器
         $("#id名")  
b. 类选择器
          $(".类名")   
          <p class="p">a1 </p>  
          <p class="p">a2 </p>  
          <p class="p">a3 </p> 
           $(".p").each(function(){
           });  
 c:标签选择器   
           $("标签名")    $("div") 

合计概念

5) 同步的艺术:

  • synchronized修饰方法 同步方法
    同权且间只好有一个线程能够访问该形式
  • synchronized 代码块
    Synchronized(共享能源的对象){}
    同一时半刻间只好有二个线程能够访问该对象
  • 一个可重入的排外锁类 ReentrantLock
    Lock();unlock();注意要用try-catch-finally来处理,制止死锁
  • volatile 特殊的品类变量来达到同步的指标
  • ThreadLocal
 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class FileInputStreamOutputStreamDemo {
10 
11     public static void main(String[] args) {
12         try {
13             FilecopyUtil.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
14         } catch (IOException e) {
15             e.printStackTrace();
16         }
17     }
18 
19 }
20 
21 class FilecopyUtil{
22     public static void copyFile(File src,File dst) throws IOException{
23         FileInputStream fis = new FileInputStream(src);
24         FileOutputStream fos = new FileOutputStream(dst);
25         
26 
27         int count=0;
28         int len = 0;//*****为什么需要这个变量****
29         //因为下面的read(buf)是将文件以8位二进制形式(也就是1b即一字节)装入byte数组作为一个元素.那么当数组读到最后一次时肯定时读不满的,
30         //故要将最后一次装入的---元素的个数---统计出来。
31         byte [] buf = new byte[1024];//创建一个1kb大小的缓冲区,用来存放输入流中的字符数
32         long t1 = System.currentTimeMillis();
33         // int read()   从此输入流中读取一个数据字节。 
34         // int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 
35         // int read(byte[] b, int off, int len)  从此输入流中将最多 len 个字节的数据读入一个 byte 数组中 
36         
37         // void write(int b) 将指定字节写入此文件输出流。 
38         // void write(byte[] b)  将 b.length 个字节从指定 byte 数组写入此文件输出流中。
39         //write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
40         while((len=fis.read(buf))!=-1){
41             fos.write(buf, 0, len);
42             count++;
43         }
44         fos.close();
45         fis.close();
46         long t2 = System.currentTimeMillis();
47         System.out.println("复制完成花费:"+(t2-t1)+"毫秒,读了"+count+"次");
48     }
49     
50 }

9.不常用知识点

转换流的面世有利于了对文本的读写,它在字符流和字节流之间架起了一座桥梁,使本来非亲非故联的二种流操作能够举行转载,进步了程序的油滑。

1) java 成立对象的两种艺术

  1. new 类的构造器
  2. 反系列化
    第1类必须实现 可序化接口 Serializable
    先实行 类别化 在进展 反体系化
  3. 仿造 类对象要 克隆 类必须实现可克隆接口 Cloneable 接口
  4. 反射

死锁

8.设计格局之二

工厂形式:依据陈设动态爆发一组类中有个别类的实例
一般而言这一组类有联袂的父类或落到实处了扳平的接口
配置:key——>value
key值保持不变,value依据实际情形改变 value=xxx(key)
父类(接口)对象= Class.forName(value).newIntance();

何谓种类化。把写入的编码格式内容还原成对象称之为反种类化

4.javai/o

  XML文书档案必须有根成分

6. java多线程

次第-》总括机的指令集合 静态的定义
进程-》程序的三次运营 动态的概念,有独立的内部存款和储蓄器空间
线程-》进程的1回运维 能够分为若干条分支同时举办
每一条分支正是三个线程 , 线程是比进度更小的概念

四线程:二个历程分成多条线索同时举办 那些进度正是十六线程
java程序中 main 方法 jvm会自动给她分配2个线程 常常那个线程
都叫做 主线程

 1 package com.abc.tzy;
 2 
 3 public class BankDemo {
 4     public static void main(String[] args) {
 5         Bank bank = new Bank();
 6         BankThread p1 = new BankThread(bank, "取钱人1");
 7         p1.start();// 柜台取钱
 8         BankThread p2 = new BankThread(bank, "取钱人2");
 9         p2.start();// ATM取钱
10 
11     }
12 }
13 
14 class BankThread extends Thread {
15     private Bank bank = null;
16 
17     public BankThread(Bank bank, String name) {
18         super(name);
19         this.bank = bank;
20     }
21 
22     @Override
23     public void run() {
24             System.out.println(this.getName()+"取钱:" + bank.getMoney(300));
25     }
26 
27 }
28 
29 class Bank {
30     private int money = 500;
31 
32     // 取钱的方法,返回取钱的数目
33     // 当一个线程去调用同步方法的时候,这个线程就获取了当前对象的锁。
34     // 其他线程当调用同步方法的时候,只能等待,因为无法获取对象的锁。
35     // 只有等第一个线程释放对象的锁方可进入.
36     //this 位置上可以换成任何对象,获取哪个对象的锁不影响
37     public /* synchronized */ int getMoney(int number) {
38         synchronized (this) {
39             if (number < 0) {
40                 return -1;
41             } else if (money < 0) {
42                 return -2;
43             } else if (money < number) {
44                 return -3;
45             } else {
46                 try {
47                     // static void sleep(long millis)
48                     // 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
49                     Thread.sleep(1000);// 模拟取钱的时间
50                 } catch (InterruptedException e) {
51                     e.printStackTrace();
52                 }
53                 money -= number;
54                 System.out.println("余额:" + money);
55             }
56             return number;
57         }
58     }
59 }

1.数据结构

先后=数据结构+算法

  • 栈:后进先出,线性结构 入栈:push 出栈:pop
    要是已知入栈顺序是abcd,那么他的出栈顺序大概有很各类abcd(立时进马上出)
  • 队列:先进先出,线性结构
  • 树:有且唯有3个根节点,各个节点也仅有贰个父节点,每一个节点能够有三个子节点(
    链式结构)
    树的归类:
    不变数树 严节数树
    二叉树:各个节点最大有多个子节点的平稳数树
    满二叉树:如果二个二叉树层级是K,树的节点数是2^K-1
    一心二叉树:
    二叉树的遍历:
    1)先序遍历(深度遍历):根节点,左子树,右子树
    2)中序遍历: 左子树,根节点,右子树
    3)后序遍历: 左子树,右子树,根节点
    其他已知先中序或中后序就足以明显二叉树的布局。
    事例:二叉树的中序遍历为:BADC,先序遍历为ABCD。求后序遍历结果?
    BDCA

  Object obj = field.get(Object obj);

7.java反射(java.lang.reflect)

次第3般原理:Java创制对象——>知道类的源码——>调用构造、属性、方法
反射原理
:没有源码,只有字节码——>反射类属性、方法和父类完成的接口——>调用方法、构造
反射 就是把三个类 用其它的类来表示 ;

获取类的字节码:
- 类路径(包名+类名).class     ( Class c=包名+类名.class;)
- Class.forName("类路径");
- 通过类的对象  .getClass();

获取父类:Class suoerc=c.getSupperclass();
获取实现的接口:Class[] interfaces=c.getInterfaces();

获取类的属性(Filed(java.lang.reflect)):
Filed[] fs=c.getFilelds();获取public 属性(自身与父类继承过来的)
     Filed[] fs=c.getDeclaredFields();获取自身所有的属性

获取类的方法(Method(java.lang.reflect)):
Method[] ms=c.getDeclaredMethods();获取自身所有的方法
Method[] ms2=c.getMethods();获取public 方法(自身与父类,父类的父类继承过来的)

获取类的构造方法(Constructor (java.lang.reflect)):
Constructor[] crs=c.getConstructors() ;

       Student stu = new
Student(“zhangsan”,20);

3)ajax的操作步骤

  1. 创建 XMLHttpRequest 对象
  2. 树立连接 对象.open()
  3. 派遣监听函数 对象.onreadystatechange=回调函数名
  4. 发送请求 对象.send()
  5. 写监听函数 回调函数()
    看清服务器连接的气象xhr.readyState
    判定服务器响应状态 xhr.status

extends—>Thread

  端口号用来表示该处理器上的应用程序,代表此应用程序逻辑地址。

万一选拔反射,先取得Class对象。

图片 1图片 2

IP地址

    线程处于创制状态时,可通过Thread类的点子来安装线程种种品质,如线程的优先级(setPriority)、线程名(setName)和线程的种类(setDaemon)等。

  ISO8859-1:拉丁码表,澳洲码。用二个字节的八个人代表

图片 3图片 4

 1 package com.abc.tzy;
 2 
 3 public class RunnableDemo {
 4 public static void main(String[] args) {
 5     HelloRunnable helloRunnable = new HelloRunnable();
 6     Thread t1 = new Thread(helloRunnable,"A");
 7     t1.start();
 8     Thread t2 = new Thread(helloRunnable,"B");
 9     t2.start();
10 }
11 }
12 //避免单继承的局限,一个类可以实现多个接口,但只能继承一个类
13 //适合资源的共享
14 class HelloRunnable implements Runnable{
15 
16     @Override
17     public void run() {
18         for (int i = 0; i < 5; i++) { 
19             //static Thread     currentThread() 返回对当前正在执行的线程对象的引用。 
20             System.out.println(Thread.currentThread().getName()+":"+i);
21         }
22     }
23 }

    数据输入输出流允许应用程序读写基本Java数据类型。应用程序能够选取数据输出流写入稍后由数量输入流读取。读写顺序要保持一致。

字节流复制图片

通过反射实例化对象

  常用构造:FileOutStream(String
filepath)  FileOutStream(File fileObj)  FileOutStream(String
filepath,boolean append)

反射入门

 

  IP地址由三十四个人2进制组成,占四个字节,常用十进制的格式表示,

      当线程执行了有个别对象的wait()方法时,线程会被置入该目的的等待集(Wait
Pool)中,知道执行了该对象的notify()方法,wait()/notify()方法的推行供给线程首先获得到该对象的锁

ObjectInputStream/ObjectOutputStream

  Outputstream是概念了字节输出流的抽象类

 Java.lang.reflect库

  根成分的甘休标记放在别的具有因素的了断标记之后。

File没有提供格局从文件读取或向文件储存消息。

 ByteArrayInputStream/OutputStream

RandomAccessFile读写对象

  反射的的概念是有smith一九八三年第3遍提议的,zhuy首借使指程序能够访问、检查和测试和改动它自己情状或行为的一种能力。

对此联合,一般而言在java代码中要求形成多少个操作:

图片 5图片 6

同台爆发死锁的来由

        <para>Hello,tom<para>

更换流对钦定编码文件读写

  Field.set(Object obj,Object value)

  安装在磁盘上的一段指令集合,它是静态的概念。

图片 7图片 8

构造方法:BufferedReader(Reader
inputStream)  BufferedReader(Reader inputStream,int bufSize)

图片 9图片 10

怎么是线程:

  网络中每台主机都必须有3个唯一的IP地址。

File测试

  Field类:代表类的分子变量(成员变量也称为类的品质)。

 XML定义

  例如:192.168.0.5

  该类全体办法再次来到void值,在失误意况下抛IOException分外

常用的过滤流BufferedInputStream和BuffOutputStream,DataInputStream和DataOutputStream

    “字符流”用来读写15位二进制字符;(文本文件)

    ByteArratInputStream(byte array[])

  各样抽象类都有六个有血有肉的子类,这么些子类对两样的外设进行处理,例如磁盘文件,互联网连接,甚至是内部存款和储蓄器缓冲区。

 1 package com.abc.tzy;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.File;
 6 import java.io.FileInputStream;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class BufferedInputStreamOutputStreamDemo {
11 
12     public static void main(String[] args) {
13         try {
14             FilecopyUtil1.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
15         } catch (IOException e) {
16             e.printStackTrace();
17         }
18     }
19 
20 }
21 
22 class FilecopyUtil1 {
23     public static void copyFile(File src, File dst) throws IOException {
24         FileInputStream fis = new FileInputStream(src);
25         FileOutputStream fos = new FileOutputStream(dst);
26         BufferedInputStream bis = new BufferedInputStream(fis);
27         BufferedOutputStream bos = new BufferedOutputStream(fos);
28         int data = 0;
29         long time1 = System.currentTimeMillis();
30         while ((data = bis.read()) != -1) {
31             bos.write(data);
32         }
33         bos.close();
34         bis.close();
35         long time2 = System.currentTimeMillis();
36         System.out.println("复制完成,共花费"+(time2-time1)+"毫秒");
37     }
38 }

  端口号使用2个13人的数字来代表,它的界定是0~65535,1024以下的端口号保留给预订义的服务。例如http使用80端口。

  Class.getConstructor(new Class[]{}).newInstance(new Object[]{})

      数据–>提供数据写入到缓存区
(
FileOutputStream)–>将数据以字节写入到文件中–>文件

缓冲字符流复制文件

    “节点流”用于直接操作指标设备的流。例如:磁盘或一块内部存款和储蓄器区域

    ContentHandler是JAVA类包中一个奇特的SAX接口

写入隐含数组末尾之后的出口操作造成该数组扩张。

  Java中各种对象都有三个内置锁。

    ContentHander接口常用方法:

 U路虎极光L右二种办法能够访问Internet上财富

  互连网种类结构定义总结机设备和别的装备如何连接在一道以多变七个同意用户共享音信和能源的通讯系统。

转换流是指将字节流与字符流之间的转移。

  流按其流向分为“输入流”和“输出流”

  国标化协会IOS于1976年提议“开放系统互连参考模型”,即闻明的OSI模型。OSI模型有限支撑了各种设备生产厂家的成品格外新。

怎么要用反射机制?直接创制对象不就足以了么?那就事关到了动态和静态的定义?

  同步这么些访问财富的代码,使用synchronized关键字来修饰方法或代码块。当synchronized方法执行完或爆发尤其时,会自行释放锁。

为什么须要共同

  把竞争访问的财富标识为private。

假设任意走访文件以读取/写入方式开创,则输出操作也可用;输出操作从文件指针开首写入字节,随着对字节的写入而前移此文件指针

    在文书档案内每3个XML成分接受解析的前后触发成分事件

流时一个很形象的定义,当程序供给读取数据的时候,就会打开四个朝着数据源的流,那几个数据源能够是文本,内部存储器,或是互连网连接。类似的,当程序须要写入数据的时候,就会开启

  常用接口:ContentHandler 接口

  举例:

  方便互联网故障排错

  总括机互联网,正是把分布在不一样地理区域的电脑与特其余外部设备通信线路互联成二个范围大,功用强的网络种类,从而使广大的微处理器能够一本万利地互动传送细心,共享硬件、

卖票Runnable

哪些是程序:

  Object obj = method.invoke(Object obj,Object…args);

流的定义和分类

XML文书档案结构

    就算一切符合规律,服务器接受请求。并获得3个新的绑定到不相同端口地址的套接字。

  创立TCP服务器的步调

  软件、数据音信等财富。

  FileOutStream代表能向文件写入字节的OutputStream类

  在运维时塑造任意二个类的靶子

    创建SAX解析器

  Socket是一连运维在互连网上的五个程序间的双向通许的端点。

 

BufferedReader和BufferedWriter

Writer是概念流式字符输出的抽象类:该类的主意都回去void值并在阴差阳错条件下抛出IOException相当

    对IO流实行读写操作,实现与客户端的互交。

    对文书档案举办剖析,将每一种事件发送给事件处理程序

 FileReader和FileWriter

 

字符流复制文件

  在XML中,空格会被保存,文书档案中的空格不会被删节

因而持续Thread类创造线程

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class FileInputStreamOutputStreamDemo {
10 
11     public static void main(String[] args) {
12         try {
13             FilecopyUtil.copyFile(new File("D:\\oo\\photo02.jpg"), new File("D:\\oo\\photo01.jpg"));
14         } catch (IOException e) {
15             e.printStackTrace();
16         }
17     }
18 
19 }
20 
21 class FilecopyUtil{
22     public static void copyFile(File src,File dst) throws IOException{
23         FileInputStream fis = new FileInputStream(src);
24         FileOutputStream fos = new FileOutputStream(dst);
25         long t1 = System.currentTimeMillis();
26         int data = -1;
27         int count=0;
28         while((data=fis.read())!=-1){
29             fos.write(data);
30             count++;
31         }
32         fos.close();
33         fis.close();
34         long t2 = System.currentTimeMillis();
35         System.out.println("复制完成花费:"+(t2-t1)+"毫秒,读了"+count+"次");
36     }
37     
38 }

  Method[] arrMethod = classType.getMethode(String
name,Class<?>…parameterTypes);

    在JAVA语言中采纳new操作符创立三个线程后,该线程仅仅是三个空对象,它拥有了线程的某些表征,但此刻系统尚未为其分配财富,这时的线程处于成立状态。

  XML的性质以名值对艺术结合,值需加引号

体系化的对象必须达成Serializable接口

  XML成分:成分的宗旨结构由
初步标记,数据内容,结束标记组成

  Method[] arrMethods = classType.getDeclaredMethodes();

案例

要素(element)起首与截至、文书档案截止等地方时通报事件处理函数,由事件处理函数做相应动作,然后继续同样的围观,直至文书档案甘休。

FileReader类表示可以读取文件内容的Reader类

  Class<T>:表示3个正值周转的Java应用程序中的类和接口,是Reflection的来源

 网络基础知识

  阻塞状态(Blocked)

  通过socket服务的send方法将该包发出。

File类及采纳
一个File类的指标,表示了磁盘上的文书或目录。

图片 11图片 12

输入操作从文件指针起始读取字节,随着对字节的读取而前移此文件指针

 

  调用wait()方法能够使调用该办法的线程释放共享能源的锁,然后从运转情况退出,进入等待列队,直到被再度提示。

      其分析进程:1:satrt document 2:start
element:doc.. 3:start:element:para.. 4:characters:Hello… 5:end
element:para… 6:end element:doc 7:end document

  线程同步是为了防患多少个线程访问3个数码对象时,对数据造成破坏

  Unicode:国际标准码,融合了七种文字。全部文字都用1个字节来代表,Java语言使用的正是Unicode

    创制二个Socket对象

线程情势

  使用stop方法强行终止线程(那么些措施不引进使用,因为stop和suspend、resume一样,也说不定发生不可预期的结果)。

  运转状态(Running)

 通过反射获取并调用属性

该文件指针能够透过getFilePointer方法读取,通过seek方法设置

    须要运用已经存在的节点流来构造,提供带缓冲区的读写,升高了读写的作用

  要求取钱进度中不可能出现财富竞争:比如400元被取出五遍、银行卡的账目无法小于0等.

 URL类

  静态编写翻译:在编写翻译时规定项目,绑定队形,即因此。

电脑网络

 

  建立DatagramSocket对象。要监听3个端口。

OSI模型分层的益处

图片 13图片 14

  流按数量传输单位分为“字节流”和“字符流”

八线程的风味:

  通过数据包dp的格局getData(),getAddredss(),getPort()等方式获得包中的钦赐新闻。

  ByteArrayInputStream是把字节数组当李松益的输入流

获得U索罗德L对象的品质  

  使用Socket进行互连网通讯的进度

1个通往目标地的流。那时候你就足以想像数据好像在那中间流动一样。

  <传输协议>://<主机名>:<端口号>/<文件名>#<引用>

图片 15图片 16

  Java提供了叁个相当重要的措施巧妙的解决线程间的通讯难点。那1个主意分别是:wait()、notify()、notifyAll()。(Object类)

UPAJEROL是联合营源定位器的简称,它代表Internet上某些财富的地址。通过U奔驰M级L大家得以访问internet上的种种互联网能源,比如大规模的www,FPT站点。浏览器通过分析给定的

  所谓的socket平常也称为“套接字”,用于描述IP地址和端口,是一个通讯链句柄。应用程序常常通过“套接字”向网络发出请求或许应答网络请求。。

  XML中的注释:<!–this is
comment–>

    将事件处理程序分配到解析器

获得当前类注解的钦点的Field

字符流层次结构的顶层是里德r和Writer抽象类

    关闭IO流和Socket

  Field[] arrField = classType.getDeclaredFields();

Socket

      void
endDocument()//文书档案解析甘休的拍卖

  不用过多考虑情理接口等这一个物理层的东西

UPAJEROL网页下载图片

  在运维时判断任意二个对象所属的类

始建发送端

图片 17图片 18

  某银行卡帐号上有500元现金。一人拿着存折去取钱,同时另壹位拿着卡去ATM机上取钱,各自取400元。

      <doc>

图片 19图片 20

  全部的XML成分都不可能不有关闭标签

为了表示U酷威L,java.net包中达成了类U汉兰达L。大家得以由此上边包车型客车构造方法来起头化三个USportageL对象  

  为电脑网络中开始展览数据交流而树立的条条框框、标准或预定的聚集。

  SAX便是一个接口,也是3个软件包。作为接口,SAX是事件驱动型XML解析的三个标准接口,对文书档案进行每一种扫描,当扫描到文书档案(document)起头、

ObjectOutputStream和ObjectInputStream分别与FileOutStream和FileInputStream一起使用,能够为应用程序提供对目的的持久储存。大家把对象以某种特定拿到编码格式写入

收获当前类以及超类内定的public Field

  通信的多头都有Socket,数据在多个Socket之间通过IO来拓展传输。

 1 package com.asd.tzy;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.IOException;
 5 import java.io.RandomAccessFile;
 6 import java.util.Scanner;
 7 
 8 public class RandomAccessFileDemo {
 9     public static void main(String[] args) throws IOException {
10         Person[] persons = { new Person("zhangsan", 90), new Person("justin", 30), new Person("bush", 88),
11                 new Person("lisi", 20) };
12         RandomAccessFile randomAccessFile = new RandomAccessFile("d:\\tzy.txt", "rw");// r只读// rw可读可写
13         //写入数据到RandomAccessFile
14         for (int i = 0; i < persons.length; i++) {
15             randomAccessFile.writeChars(persons[i].getName());
16             randomAccessFile.writeInt(persons[i].getAge());//按4个字节写入数字
17         }
18         //读取指定位置上的Person对象
19         Scanner sc = new Scanner(System.in);
20         System.out.println("读取第几个Person对象数据");
21         int num = sc.nextInt();
22         //使用seek方法来操作存取位置
23         randomAccessFile.seek((num-1)*Person.size());//跳过多少字节读
24         Person person = new Person();
25         person.setName(readName(randomAccessFile));
26         person.setAge(randomAccessFile.readInt());
27         System.out.println("姓名:"+person.getName()+";年龄:"+person.getAge());
28         randomAccessFile.close();
29         
30     }
31     private static String readName(RandomAccessFile randomAccessFile) throws IOException{
32         char [] name = new char[15];
33         for (int i = 0; i < name.length; i++) {
34             name[i]=randomAccessFile.readChar();
35         }
36         return new String(name).replace("\u0000", "");
37     }
38 }
39 
40 class Person {
41     private String name;
42     private int age;
43 
44     public Person(String name, int age) {
45         StringBuilder builder = null;
46         if (name != null) {
47             builder = new StringBuilder(name);// 默认为16长度+传入字符串长度的字符串
48 
49         } else {
50             builder = new StringBuilder(15);// 制定为15长度的字符串
51         }
52         builder.setLength(15);// 固定长度15个字符,占了30个字节的大小
53         this.name = builder.toString();
54         this.age = age;
55     }
56 
57     public Person() {
58         super();
59     }
60 
61     public String getName() {
62         return name;
63     }
64 
65     public void setName(String name) {
66         this.name = name;
67     }
68 
69     public int getAge() {
70         return age;
71     }
72 
73     public void setAge(int age) {
74         this.age = age;
75     }
76 
77     // 每个对象所占的字节数
78     public static int size() {
79         return 34;
80     }
81 }

  XML标签对大小写敏感

  锁被保释。释放锁是指持锁线程退出了synchronized同步方法或代码块.

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 import java.io.InputStreamReader;
10 import java.io.ObjectInputStream;
11 import java.io.ObjectOutputStream;
12 import java.io.OutputStreamWriter;
13 import java.io.Serializable;
14 
15 public class InputOutputStreamReaderWriterDemo {
16 
17     public static void main(String[] args) throws IOException {
18         FileOutputStream fos = new FileOutputStream("d:\\tzy.txt");
19         OutputStreamWriter oos = new OutputStreamWriter(fos, "utf-8");
20         BufferedWriter osw = new BufferedWriter(oos);
21         osw.write("我是谁");//在utf-8里中文占3个字节 如果直接用FileReader读,那么用的是默认编码读的是2个字节,所以读出来是乱码
22         osw.newLine();//换行
23         osw.write("我时你");
24         osw.flush();//
25         osw.close();
26         BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:\\tzy.txt"), "utf-8"));
27         String line = null;
28         while((line=br.readLine())!=null){
29             System.out.println(line);
30         }
31     }
32 
33 }

    客户和服务器通过读、写套接字进行广播发表。

    该接口封装了一部分对事件处理的方法,当XML解析器起首解析XML输入文书档案时,它会遭逢一些特殊的轩然大波,比如文档的上马与结束、成分的启幕和终止、顶尖

图片 21图片 22

Java.lang包下

过滤流Data

席卷其访问修饰符、父类、达成的接口、属性和格局的兼具音讯,并可在运作时创立对象、修改属性(蕴涵个人的)、调用方法(包含个人的)。

  兑现Runnable借口的类必须借助Thread类才能创设线程。通过Runnable接口创立线程分为两步:

获得当前类以及超类的public
Field

 

 

  ASCLL:United States行业内部音信调换码。用二个字节的八人能够表示

是W3C的引荐标准。

  分裂厂商生产的配备都能够互相协作。 

  选择退出标志,使线程不荒谬退出,也正是当run方法成功后线程终止,推荐应用。

  文件和目录类      ||                ||

 1 package com.abc.tzy;
 2 
 3 import java.lang.reflect.Array;
 4 
 5 public class ArrayDemo {
 6     public static void main(String[] args) throws Exception {
 7         //创建一个一维数组(String)
 8         Class<?> classType = Class.forName("java.lang.String");
 9         //static Object         newInstance(Class<?> componentType, int length) 
10         //创建一个具有指定的组件类型和长度的新数组。 (Array)
11         Object array = Array.newInstance(classType, 5);
12         //static void             set(Object array, int index, Object value) 
13         //将指定数组对象中索引组件的值设置为指定的新值。 
14         Array.set(array, 3, "abc");
15         //static Object get(Object array, int index) 
16         //返回指定数组对象中索引组件的值。 
17         //System.out.println(Array.get(array, 5));
18         // java.lang.ArrayIndexOutOfBoundsException
19         System.out.println(Array.get(array, 3));//abc
20         
21         //创建一个二维数组(3行3列)
22         //static Object newInstance(Class<?> componentType, int... dimensions) 
23         //创建一个具有指定的组件类型和维度的新数组。 
24         int [] dimens={3,3};
25         Object array1 = Array.newInstance(int.class, dimens);
26         Object arrayobj = Array.get(array1, 2);//获取第三行(就是一个一维数组)
27         //static void setInt(Object array, int index, int i) 
28         //将指定数组对象中索引组件的值设置为指定的 int 值。 (基本数据类型方法相似)
29         Array.setInt(arrayobj, 2, 10);//给指定数组位置的元素赋新值
30         int [] [] arr = (int[][]) array1;
31         for (int[] is : arr) {
32             for (int i : is) {
33                 System.out.print(i+"\t");
34             }
35             System.out.println();
36         }
37         //0       0      0    
38         //0    0    0    
39         //0    0    10    
40 
41     }
42 }
 1 package com.abc.tzy;
 2 
 3 import java.io.DataInputStream;
 4 import java.io.DataOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class DataInputOutputStreamDemo {
11     public static void main(String[] args) throws IOException {
12         String name = "zhangsan";
13         int age = 10;
14         boolean flag = true;
15         char sex = '男';
16         double money = 100.56;
17         DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:\\b.txt"));
18         dos.writeUTF(name);
19         dos.writeInt(age);
20         dos.writeBoolean(flag);
21         dos.writeChar(sex);
22         dos.writeDouble(money);
23         dos.close();
24         
25         DataInputStream dis = new DataInputStream(new FileInputStream("d:\\b.txt"));
26         //读写顺序必须一致
27         System.out.println(dis.readUTF());
28         System.out.println(dis.readInt());
29         System.out.println(dis.readBoolean());
30         System.out.println(dis.readChar());
31         System.out.println(dis.readDouble());
32         
33     }
34 }

  SAX(Simple API For
XML)是二个共用的遵照事件的XML文书档案解析标准,能够透过3个粗略的、快速的艺术来对XML文书档案进行拍卖,和DOM相比较它所占有的

  调用notifyAll()方法能够使拥有正在等候列队中同一共享财富的线程从等待状态退出,进入可运维情状,此时,优先级最高的百般线程恐怕会初叶执行。

ByteArrayInput/OutputStream

  与人的生老病死一样,线程野同样要经历新建、就绪、运转(活动)、阻塞和逝世各种不一致的境况。那多样状态都得以因此Thread类中的方法进行支配。

      java.io

    线程在run()方法执行达成后进入过逝情状。其它,假诺线程执行了interrupt()或stop()方法,那么它也会以老大退出的办法进入身故情状。  

  该模型把电脑网络分成物理层、数据链路层、网络层、传输层、会话层、表示层、应用层等七层

字节流提供处理任何项目输入输出操作的够用效能,但无法直接操作Unicode字符(比如中文2字节),因此需求字符流

    从Socket中获取IO流

  得到3个指标的锁也叫做获取锁、锁定指标、在对象上锁定或在指标上协助实行。当程序运维到synchronized同步方法或代码块时该对象锁才起效果。

构造方法:File里德r(String
file帕特h)  FileReader(File fileObj)

  它是运维中的程序,是动态的概念。各种过程都有独立的能源空间。

  同一进度中的多个线程之间能够并发执行。CPU会轻易抽出事件,让我们的主次一会做那件事情,一会做另一件工作。

    ByteArrayOutStream(int
numBytes)创造3个新的byte数组输出流,具有制定大小的缓冲区(字节为单位)

图片 23图片 24

反射成立数组

SAX解析器

 

    从Socket中获取IO流

  如今相比较流行的网络编制程序模型是客户机/服务器通讯方式(C/S架构:客户机下面要安装客户端 
        B/S架构:只要有浏览器就足以了,不需求设置客户端)

  DataInputStream和DataOutputStream

  正是“最大限度地接纳CPU资源”,当某一线程的处理不要求占用CPU而只和I/O等财富打交道时,让急需占用CPU能源的别的线程有机遇获取CPU能源。

JAVA运转系统在众多方面注重于线程,全部的类库设计都考虑到三多线程。JAVA是纯面向对象语言,JAVA的线程模型也是面向对象的。

递归打字与印刷文件夹及文件

因此除非万不得已,请尽量少用。

反射概述

得到Class对象的法门有种种

创立并运维线程

过滤流(filtered
Stream)仅仅是为底层透明地提供扩充成效的输入流(输出流)的卷入。那么些流一般由普通类的法子(即过滤流的三个父类)访问。

  它的症结是对质量有震慑。使用反射基本上是一种解释操作,这类操作总是慢于直接实施的同等操作。

那种动态获取的音信以及动态调用对象的格局的意义称为Java语言的反射机制。

图片 25图片 26

 1 package com.abc.tzy;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 
 8 public class ByteArrayInputStreamOutputStreamDemo {
 9 public static void main(String[] args) throws IOException {
10     String str = "hello,shanghai";
11     ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());
12     int data = 0;
13     while((data=bis.read())!=-1){
14         System.out.println((char)data);
15     }
16     System.out.println("******");
17     ByteArrayOutputStream bos = new ByteArrayOutputStream();//默认32位长度
18     bos.write(97);
19     bos.write(65);
20     bos.write("hello,world".getBytes());
21     byte[] buff = bos.toByteArray();
22     for (byte b : buff) {
23         System.out.println((char)b);
24     }
25     System.out.println("********");
26     FileOutputStream fos = new FileOutputStream("d://aa.txt",false);//false不覆盖
27     bos.writeTo(fos);//把ByteArrayOutputStream内部缓冲区的数据写到对应文件输出流中
28     fos.close();
29     
30 }
31 }

  通过Thread类的start方法运营线程

  http://www.comcat.com:80/Gamelan/network.html\#BOTTOM

 1 package com.abc.tzy;
 2 
 3 public class SharedDataThreadDemo {
 4 public static void main(String[] args) {
 5     TicketThread s1 = new TicketThread("一号窗口");
 6     s1.start();
 7     TicketThread s2 = new TicketThread("二号窗口");
 8     s2.start();
 9 }
10 }
11 
12 
13 class TicketThread extends Thread{
14     private static int ticket = 5;//加上static变成静态变量就可以实现卖五张
15     public TicketThread(String name){
16         super(name);
17     }
18     @Override
19     public void run() {
20         while(true){
21             System.out.println(this.getName()+":"+(ticket--));
22             if(ticket<1){
23                 break;
24             }
25         }
26     }
27 }

  超过5/10SAX会发生以下项目标事件

  GB2312:中中原人民共和国的华语编码表

    在任元数据一般由单独的多少来处理

  将socket关闭

    /   |   \

    创制1个ServerSocket对象

哪些是八线程:

    一个正值周转的线程因一些原因不能够继续运营时,就进来阻塞状态。这一个缘故不外乎:

Java反射机制主要提供了以下职能

Class类与java.lang.reflect类库一起对反射的定义实行支持。

      文件–>从文件中得到输入字节(FileInputStream)–>扩大字节缓冲区效率(BufferedInputStream)–>数据

  Thread类的子类可间接实例化,但在子类中务必覆盖run方法才能真的运维线程的代码。

从根本上说,那就是二十三十二线程编制程序的指标。

反射总结

XML的语法规则

  创设DatagramSocket对象。
该断点建立,系统会轻易分配2个端口。要是不想随机配置,能够手动钦点。

 1 package com.abc.tzy;
 2 
 3 public class SharedDataThreadDemo {
 4 public static void main(String[] args) {
 5     TicketRunnable run = new TicketRunnable();
 6     Thread t1 = new Thread(run, "一号窗口");
 7     t1.start();
 8     Thread t2 = new Thread(run, "二号窗口");
 9     t2.start();
10     
11 }
12 }
13 
14 //不需要设置静态变量就可以数据共享
15 class TicketRunnable implements Runnable{
16     private int ticket = 5;
17     @Override
18     public void run() {
19         while(true){
20             System.out.println(Thread.currentThread().getName()+":"+(ticket--));
21             if(ticket<1){
22                 break;
23             }
24         }
25     }
26 }

  ByteArrayOutStream是把字节数组当作指标的输出源

 

图片 27图片 28

XML指可扩大标记语言,适合Wed传输,类似HTML,差异的是它的统一筹划大旨是传输数据,而非突显数据。(不是展现数据)

 

  2个对象唯有二个锁。所以,假诺二个线程得到该锁,就从未有过别的线程能够拿走锁,知道第1个线程释放锁。那也意味任何别的线程都不可能进来synchronized方法或代码块,知道该

  在运作时调用任意3个指标的法门

    创制达成Runnable接口的类的实例。

字节流中的数据都以字符时,转成字符流操作更搞笑。

      当执行了某些线程对象的sleep()等堵塞类型的措施时,该线程对象会被置入2个打断集(Blocked
Pool)内,等待超时而自动复苏。

系统能源更少

  XML申明:<?xml version=”1.0″
standalone=”yes” encoding=”UTF-8″?>

  当二个线程已收获了对象1的锁,同时又想得到对象2的锁。而那时另二个线程当前已有所了目的二的锁,而又想赢得对象1的锁。那种互相等待对方释放锁的经过,会促成死锁。

 1 package com.asd.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 public class CopyDirDemo {
10 
11     public static void main(String[] args) {
12         try {
13             CopyDirUtil.copyDir(new File("D:\\xmind"), new File("D:\\xmind2"));
14             System.out.println("拷贝成功");
15         } catch (IOException e) {
16             e.printStackTrace();
17         }
18     }
19 
20 }
21 
22 class CopyDirUtil{
23     public static void copyDir(File src,File dst) throws IOException{
24         dst.mkdirs();//d:\\zz\\bb创建目标文件夹
25         if(src!=null){
26             File[] files = src.listFiles();//遍历源文件夹中的所有文件或目录
27             for (File f : files) {
28                 if(f.isFile()){
29                     //是文件就复制
30                     FileInputStream fis = new FileInputStream(f);
31                     FileOutputStream fos = new FileOutputStream(dst.getAbsolutePath()+"\\"+f.getName());
32                     byte [] buff = new byte[1024*1024];//1M
33                     int len = 0 ;//保存的时读到的字节个数
34                     while((len=fis.read(buff))!=-1){
35                         fos.write(buff,0,len);
36                     }
37                     fos.close();
38                     fis.close();
39                 }else{
40                     copyDir(f,new File(dst.getAbsolutePath()+"\\"+f.getName()));
41                 }
42             }
43         }
44     }
45 }

  UTF-8:最多用二个字节来表示三个字符。

 

劳动者消费者

  透过socket的receive方法将数据存入数据包中。

  GBK:中中原人民共和国的国语编码表升级,融合了越来越多的汉语文字标记。

获取当前类注明的兼具Method

    剥夺CPU能源,重新进入就绪状态。

图片 29图片 30

互联网编制程序的指标

  因特网上的IP地址具有环球唯一性。

图片 31图片 32

    创造一个Thread类对象,将率先步实例化获得的Runnable对象作为参数字传送入Thread类的构造方法。

构造方法:File(String
directoryPath)  文件所在路径  File(String directory帕特h,String
filename)  文件所在路径,文件名 File(File dirObj,String filename)   
  文件所在路径封装,文件名

  网络通许其实指的正是Socket间的简报。

      void
startDocument()//文书档案解析开首的拍卖

    对IO流举行读写操作,完毕与服务器的相互。

网络种类结构

字节流–数组–读取与读出-内部存储器解析

 

  TCP是一种面向连接的保险保障传输的情商。通过TCP协议传输,获得的是多少个一一的无差错的数据流

 线程通讯

  另三个正是找到主机后

  UDP是一种无连接的商议,每一种数据包都以叁个独门的音信,包含总体的源地址或目标地址,它在互联网上以任何恐怕的不二法门传往指标地,因而能还是无法达到指标地,

联手和锁

Reader是定义Java的流式字符输入格局的抽象类

 1 package com.ab.tzy;
 2 
 3 public class ClassDemo {
 4 public static void main(String[] args) {
 5     // 对像名.getClass()
 6     // Class<?> getClass() 返回此 Object 的运行时类。 
 7     Employee employee = new Employee("zhangsan",15);
 8     Class<?> classType = employee.getClass();
 9     //String getName() 以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。 
10     System.out.println(classType.getName());//com.ab.tzy.Employee
11     //Class<? super T> getSuperclass() 返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。 
12     System.out.println(classType.getSuperclass().getName());//java.lang.Object
13     
14     //类名.class
15     Class<?> classType1 = Employee.class;
16     System.out.println(classType1.getName());//com.ab.tzy.Employee
17     System.out.println(classType1.getSuperclass().getName());//java.lang.Object
18     
19     //使用Class.forName();
20     //static Class<?> forName(String className)  返回与带有给定字符串名的类或接口相关联的 Class 对象。 
21     try {
22         Class<?> classType2=Class.forName("com.ab.tzy.Employee");
23         System.out.println(classType2.getName());//com.ab.tzy.Employee
24         System.out.println(classType2.getSuperclass().getName());//java.lang.Object
25     } catch (ClassNotFoundException e) {
26         e.printStackTrace();
27     }
28     //获取基本数据类型的Class对象
29     Class<?> classType3 = int.class;
30     System.out.println(classType3.getName());//int
31     //System.out.println(classType3.getSuperclass().getName());
32     // java.lang.NullPointerException
33     //通过基本数据类型的包装类来获取对应的基本数据类型所对应的Class对象
34     
35     //static Class<Integer> TYPE  表示基本类型 int 的 Class 实例。 (基本数据类型包装类都有该属性)
36     Class<?> classType4 = Integer.TYPE;
37     System.out.println(classType4.getName());//int
38     //System.out.println(classType4.getSuperclass().getName());
39     // java.lang.NullPointerException
40     
41     Class<?> classType5 = Integer.class;
42     System.out.println(classType5.getName());//java.lang.Integer
43     System.out.println(classType5.getSuperclass().getName());//java.lang.Number(除了character都是)
44     Class<?> classType6 = String.class;
45     System.out.println(classType6.getName());//java.lang.String
46     System.out.println(classType6.getSuperclass().getName());//java.lang.Object
47     Class<?> classType7 = Character.class;
48     System.out.println(classType7.getName());//java.lang.Character
49     System.out.println(classType7.getSuperclass().getName());//java.lang.Object
50     
51 }
52 }
53 
54 
55 class Employee{
56     private String name;
57     private int age;
58     public Employee(String name, int age) {
59         super();
60         this.name = name;
61         this.age = age;
62     }
63     public String getName() {
64         return name;
65     }
66     public void setName(String name) {
67         this.name = name;
68     }
69     public int getAge() {
70         return age;
71     }
72     public void setAge(int age) {
73         this.age = age;
74     }
75     
76 }

      void characters(char[] ch,
int start,int lenght)//具体在某一节点中的拍卖

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 public class IteratorDirDemo {
 8     public static void main(String[] args) {
 9         IteratorUtil.IteratorDir(new File("d:\\qq"));
10     }
11 
12 }
13 
14 class IteratorUtil{
15     private static int level = 0;//层级数
16     public static void IteratorDir(File file){
17         if(file!=null){
18             //找出递归的出口
19             //假设是文件或者时空文件夹
20             if(file.isFile()||file.listFiles().length==0){
21                 return;
22             }else{
23                 File[] files = file.listFiles();
24                 //要求时先输出文件夹再输出文件
25                  files = sort(files);
26                  for (File f : files) {
27                      //这是一个动态字符串
28                     StringBuilder sb = new StringBuilder();
29                     if(f.isFile()){
30                         sb.append(getTab(level));
31                         sb.append(f.getName());
32                     }else{
33                         sb.append(getTab(level));
34                         sb.append(f.getName());
35                         sb.append("\\");
36                     }
37                     System.out.println(sb.toString());
38                     //加入是文件夹
39                     if(f.isDirectory()){
40                         level++;//进入目录遍历,层级+1;
41                         IteratorDir(f);//递归调用遍历目录的方法
42                         level--;//目录层级减一,退回上一级目录继续打印输出
43                     }
44                 }
45                 
46             }
47         }
48     }
49     /**
50      * 对File类型的数组进行先目录后文件的排列
51      * @param files
52      * @return
53      */
54     private static File[] sort(File[] files){
55         List<File> fList = new ArrayList<File>();
56         //先存放文件夹
57         for (File f : files) {
58             if(f.isDirectory()){
59                 fList.add(f);
60             }
61         }
62         //再存放文件
63         for (File f : files) {
64             if(f.isFile()){
65                 fList.add(f);
66             }
67         }
68         //<T> T[]  toArray(T[] a) 按适当顺序(从第一个到最后一个元素)
69         //返回包含此列表中所有元素的数组;返回数组的运行时类型是指定数组的运行时类型。 (ArrayList)
70         return fList.toArray(new File[fList.size()]);
71     }
72     //根据层级数来得到\t的个数
73     private static String getTab(int level){
74         StringBuilder sb = new StringBuilder();
75         for (int i = 0; i < level; i++) {
76             sb.append("\t");
77         }
78         return sb.toString();
79     }
80 }

SAX解析器API

计算:输入流其实正是文本读入内部存款和储蓄器的桥接,输出流就是内存读出到文件的桥接.

  1 package com.abc.tzy;
  2 
  3 import java.util.LinkedList;
  4 
  5 public class ProductorConsumerDemo {
  6 
  7     public static void main(String[] args) {
  8 
  9         Basket basket = new Basket();
 10         Productor productor = new Productor(basket);
 11         Consumer consumer = new Consumer(basket);
 12         productor.start();
 13         consumer.start();
 14     }
 15 
 16 }
 17 class Productor extends Thread{
 18     private Basket basket = null;
 19 
 20     public Productor(Basket basket) {
 21         super();
 22         this.basket = basket;
 23     }
 24     @Override
 25     public void run() {
 26         basket.pushApple();
 27     }
 28 }
 29 class Consumer extends Thread{
 30     private Basket basket = null;
 31 
 32     public Consumer(Basket basket) {
 33         super();
 34         this.basket = basket;
 35     }
 36     @Override
 37     public void run() {
 38         basket.popApple();
 39     }
 40 }
 41 //篮子类
 42 class Basket{
 43     private LinkedList<Apple> basket = new LinkedList<Apple>();
 44     //放4轮苹果
 45     public synchronized void pushApple(){
 46         for (int i = 0; i < 20; i++) {
 47             Apple apple = new Apple(i);
 48             push(apple);
 49         }
 50     }
 51     //吃4轮苹果
 52         public synchronized void popApple(){
 53             for (int i = 0; i < 20; i++) {
 54                 pop();
 55             }
 56         }
 57     //向篮子放苹果
 58     private void push(Apple apple){
 59         if(basket.size()==5){
 60             try {
 61                 wait();
 62             } catch (InterruptedException e) {
 63                 e.printStackTrace();
 64             }//等待并释放当前对象的锁
 65         }
 66         try {
 67             Thread.sleep(500);
 68         } catch (InterruptedException e) {
 69             e.printStackTrace();
 70         }
 71         basket.addFirst(apple);
 72         System.out.println("存放"+apple.toString());
 73         notify();//通知消费者来消费
 74     }
 75     //向篮子取苹果
 76         private void pop(){
 77             //当篮子中苹果数为0的时候就等待并通知生产者来生产
 78             if(basket.size()==0){
 79                 try {
 80                     wait();
 81                 } catch (InterruptedException e) {
 82                     e.printStackTrace();
 83                 }//等待并释放当前对象的锁
 84             }
 85             try {
 86                 Thread.sleep(500);
 87             } catch (InterruptedException e) {
 88                 e.printStackTrace();
 89             }
 90             Apple apple = basket.removeFirst();
 91             System.out.println("吃掉"+apple.toString());
 92             notify();//通知消费者来消费
 93         }
 94     
 95 }
 96 //苹果类
 97 class Apple{
 98     private int id;
 99     public Apple(int id){
100         this.id=id;
101     }
102     @Override
103     public String toString() {
104         return "苹果 :" + (id+1)+"号";
105     }
106     
107 }

 基于UDP协议的Socket编程

  解析步骤:

    客户程序依照服务器程序所在的主机名和端口号发出连接请求。

  叁个程序完结四个代码同时交替运维就供给发出多个线程。

Outputstream抽象类

  1 package com.abc.tzy;
  2 
  3 import java.lang.reflect.Field;
  4 import java.lang.reflect.InvocationTargetException;
  5 import java.lang.reflect.Method;
  6 
  7 public class ReflectionDemo {
  8     public static void main(String[] args) {
  9         // 2生成一个学生对象(被赋值的哪个对象,源对象)
 10         Student stu = new Student(1, "张三", 30);
 11         try {
 12             Student copystu = (Student) ObjectCopyUtil.copyObj(stu);
 13             System.out.println("复制对象成功");
 14             System.out.println(copystu);
 15         } catch (InstantiationException e) {
 16             e.printStackTrace();
 17         } catch (IllegalAccessException e) {
 18             e.printStackTrace();
 19         } catch (NoSuchMethodException e) {
 20             e.printStackTrace();
 21         } catch (SecurityException e) {
 22             e.printStackTrace();
 23         } catch (IllegalArgumentException e) {
 24             e.printStackTrace();
 25         } catch (InvocationTargetException e) {
 26             e.printStackTrace();
 27         }
 28     }
 29 }
 30 
 31 //复制对象成功
 32 //Student [id=1, name=张三, age=30]
 33 
 34 
 35 /**
 36  * 这是一个Copy对象的工具类,内部提供了一个Copy对象的方法,接受源对象
 37  * 
 38  * @author Administrator
 39  *
 40  */
 41 class ObjectCopyUtil {
 42     public static Object copyObj(Object obj) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
 43         // 3获取Student对象所对应类型的Class对象(也就是Student这个类所对应的Class对象)
 44         Class<?> classType = obj.getClass();
 45         // 4通过Class对象的newInstance方法构建一个目标对象。
 46         Object objRes = classType.newInstance();
 47         // 5获取Class对象的set和get方法
 48         Field[] fields = classType.getDeclaredFields();
 49         for (Field field : fields) {
 50             
 51             // 得到属性所对应的get和set方法
 52             // String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。
 53             // String substring(int beginIndex, int endIndex)
 54             // 返回一个新字符串,它是此字符串的一个子字符串。
 55             // String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 56             // String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
 57             String getMethodName = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);// 拼接getId
 58             String setMethodName = "set" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);// 拼接SetId
 59             //调用源对象的get方法获取属性值
 60             Method getMethod = classType.getDeclaredMethod(getMethodName, new Class[]{});//方法名 参数
 61             Object value = getMethod.invoke(obj, new Object[]{});
 62             //调用源对象的set方法给属性赋值
 63             // Class<?> getType()  返回一个 Class 对象,它标识了此 Field 对象所表示字段的声明类型。 
 64             Method setMethod = classType.getDeclaredMethod(setMethodName, new Class[]{field.getType()});//参数类型就是属性的类型
 65             setMethod.invoke(objRes, new Object[]{value});
 66             /*
 67             //方法二:
 68             field.setAccessible(true);
 69             // Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。 
 70             Object value1 = field.get(obj);
 71             // void set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 
 72             field.set(objRes, value1);
 73             */
 74         }
 75         return objRes;
 76     }
 77 }
 78 
 79 // 1申明一个学生类
 80 class Student {
 81     private int id;
 82     private String name;
 83     private int age;
 84 
 85     public Student(int id, String name, int age) {
 86         super();
 87         this.id = id;
 88         this.name = name;
 89         this.age = age;
 90     }
 91 
 92     public int getId() {
 93         return id;
 94     }
 95 
 96     public void setId(int id) {
 97         this.id = id;
 98     }
 99 
100     public String getName() {
101         return name;
102     }
103 
104     public void setName(String name) {
105         this.name = name;
106     }
107 
108     public int getAge() {
109         return age;
110     }
111 
112     public void setAge(int age) {
113         this.age = age;
114     }
115 
116     public Student() {
117         super();
118     }
119 
120     @Override
121     public String toString() {
122         return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
123     }
124 
125 }
 1 package com.abc.tzy;
 2 
 3 public class DieThreadDemo {
 4 public static void main(String[] args) {
 5     Example ex = new Example();
 6     DieThread1 die1 = new DieThread1(ex);
 7     die1.start();
 8     DieThread2 die2 = new DieThread2(ex);
 9     die2.start();
10 }
11 }
12 
13 class DieThread1 extends Thread{
14     private Example example = null;
15 
16     public DieThread1(Example example) {
17         super();
18         this.example = example;
19     }
20     @Override
21     public void run() {
22         example.method1();
23     }
24 }
25 class DieThread2 extends Thread{
26     private Example example = null;
27 
28     public DieThread2(Example example) {
29         super();
30         this.example = example;
31     }
32     @Override
33     public void run() {
34         example.method2();
35     }
36 }
37 
38 
39 class Example{
40     private Object obj1 = new Object();
41     private Object obj2 = new Object();
42     public void method1(){
43         synchronized (obj1){
44             try {
45                 Thread.sleep(1000);
46             } catch (InterruptedException e) {
47                 e.printStackTrace();
48             }
49             synchronized (obj2){
50                 System.out.println("method1");
51             }
52         }
53     }
54     public void method2(){
55         synchronized (obj2){
56             try {
57                 Thread.sleep(1000);
58             } catch (InterruptedException e) {
59                 e.printStackTrace();
60             }
61             synchronized (obj1){
62                 System.out.println("method2");
63             }
64         }
65     }
66 }

    调用accept()方法接受客户端请求

图片 33图片 34

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 import java.net.SocketException;
 8 
 9 public class UDPDemo2 {
10 public static void main(String[] args) throws IOException {
11     DatagramSocket socket = new DatagramSocket(8000);
12     byte [] buff = new byte[100];
13     DatagramPacket packet = new DatagramPacket(buff, 100);
14     socket.receive(packet);//接受传来的数据包
15     System.out.println(new String(packet.getData()));
16     String str = "me too!";
17     DatagramPacket packet2 = new DatagramPacket(str.getBytes(), 0, str.length(), packet.getAddress(), packet.getPort());
18     socket.send(packet2);
19     socket.close();
20 }
21 }

UDPDemo2 先启动

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 import java.net.SocketException;
 8 import java.net.UnknownHostException;
 9 
10 public class UDPDemo1 {
11 
12     public static void main(String[] args) throws IOException {
13         DatagramSocket socket = new DatagramSocket();
14         String str = "i love you!";
15         //把数据进行封装,封装到数据报 包中;
16         DatagramPacket packet = new DatagramPacket(str.getBytes(), 0, str.length(), InetAddress.getByName("localhost"), 8000);
17         socket.send(packet);//发送
18         byte [] buff = new byte[100];
19         DatagramPacket packet2 = new DatagramPacket(buff, 100);
20         socket.receive(packet2);
21         System.out.println(new String(packet2.getData()));
22         socket.close();
23     }
24 
25 }

UDPDemo1后启动

  Field[] arrFields = classType.getFields();

 通过反射动态获取Field的值

经过反射赋值对象

日常情形大家通过new
Object来生成贰个类的实例,但有时大家无奈直接new,只可以通过反射动态变化。

流的归类:

Class对象是Reflection传说出自。要想操纵类中的属性和措施,都必须从获得Class对象开端

端口号

  怎样可信赖高效的拓展数量传输。

  字节流类以InputStream和OutputStream为顶层类。它们都以抽象类。

  Method[] arrMethods = classType.getMethodes();

  一句话,反射机制的长处正是能够实现动态创造对象和编写翻译,显示出一点都不小的灵活性,特点是在J2EE的支付中。

  1个主次能够包蕴一个或三个线程。

  常用构造: FileInputstream(String
filepath)  FileInputStream(File fileObj)

      void startElement(String
uri,String localName,String qName,Attributes
atts)//ElementNode开首的拍卖

 boolean equals(Object obj)
          比较此 URL 是否等于另一个对象。
 String getAuthority()
          获取此 URL 的授权部分。
 Object getContent()
          获取此 URL 的内容。
 Object getContent(Class[] classes)
          获取此 URL 的内容。
 int getDefaultPort()
          获取与此 URL 关联协议的默认端口号。
 String getFile()
          获取此 URL 的文件名。
 String getHost()
          获取此 URL 的主机名(如果适用)。
 String getPath()
          获取此 URL 的路径部分。
 int getPort()
          获取此 URL 的端口号。
 String getProtocol()
          获取此 URL 的协议名称。
 String getQuery()
          获取此 URL 的查询部分。
 String getRef()
          获取此 URL 的锚点(也称为“引用”)。
 String getUserInfo()
          获取此 URL 的 userInfo 部分。
 int hashCode()
          创建一个适合哈希表索引的整数。
 URLConnection openConnection()
          返回一个 URLConnection 对象,它表示到 URL 所引用的远程对象的连接。
 URLConnection openConnection(Proxy proxy)
          与 openConnection() 类似,所不同是连接通过指定的代理建立;不支持代理方式的协议处理程序将忽略该代理参数并建立正常的连接。
 InputStream openStream()
          打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream
 boolean sameFile(URL other)
          比较两个 URL,不包括片段部分。
protected
 void
set(String protocol, String host,
int port, String file, String ref)

          设置 URL 的字段。
protected
 void
set(String protocol, String host,
int port, String authority, String userInfo, String path, String query, String ref)

          设置 URL 的指定的 8 个字段。
static void setURLStreamHandlerFactory(URLStreamHandlerFactory fac)
          设置应用程序的 URLStreamHandlerFactory
 String toExternalForm()
          构造此 URL 的字符串表示形式。
 String toString()
          构造此 URL 的字符串表示形式。
 URI toURI()
          返回与此 URL 等效的 URI

  InputStream是概念了字节输入流的抽象类

  IP地址;端口号;传输协议

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.ServerSocket;
 5 import java.net.Socket;
 6 
 7 public class ChatServer {
 8 
 9     public static void main(String[] args) throws IOException {
10         ServerSocket serverSocket = new ServerSocket(9999);
11         int number = 1;//保存客户端个数
12         while(true){
13             Socket socket = serverSocket.accept();
14             System.out.println("客户端"+number+"连接成功");
15             //服务端开启一个独立的线程来对客户端进行读写操作
16             new Thread(new ServerStream(socket, number)).start();;
17             number++;
18         }
19     }
20 
21 }

服务器端

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.io.PrintWriter;
 7 import java.net.Socket;
 8 
 9 public class ServerStream implements Runnable {
10     private Socket socket = null;
11     private int number;
12     
13     public ServerStream(Socket socket, int number) {
14         super();
15         this.socket = socket;
16         this.number = number;
17     }
18 
19     @Override
20     public void run() {
21         try {
22             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
23             PrintWriter pw  = new PrintWriter(socket.getOutputStream(),true);
24             while(true){
25                 String line = br.readLine();
26                 System.out.println("客户端"+number+":"+line);
27                 pw.println(line.toUpperCase());
28                 if(line.trim().equals("bye")){
29                     System.out.println("客户端:"+number+"断开连接");
30                     break;
31                 }
32             }
33             br.close();
34             pw.close();
35         } catch (IOException e) {
36             e.printStackTrace();
37         }
38         
39     }
40 
41 
42 }

服务器读写

 1 package com.asd.tzy;
 2 
 3 import java.io.IOException;
 4 import java.net.Socket;
 5 import java.net.UnknownHostException;
 6 
 7 public class ChatClient {
 8 
 9     public static void main(String[] args) throws UnknownHostException, IOException {
10         Socket socket = new Socket("127.0.0.1", 9999);
11         new Thread(new ClirentOutputStream(socket)).start();
12         new Thread(new ClientInputStream(socket)).start();
13     
14     }
15 
16 }

客户端

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.io.PrintWriter;
 7 import java.net.Socket;
 8 
 9 public class ClirentOutputStream implements Runnable{
10     private Socket socket = null;
11     
12     public ClirentOutputStream(Socket socket) {
13         super();
14         this.socket = socket;
15     }
16 
17     @Override
18     public void run() {
19         try {
20             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
21             PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
22             while(true){
23                 String line = br.readLine();
24                 pw.println(line);
25                 if(line.trim().equals("bye")){
26                     break;
27                 }
28             }
29             br.close();
30             pw.close();
31             socket.close();
32         } catch (IOException e) {
33             e.printStackTrace();
34         }
35     }
36 
37 
38 
39 }

客户端读

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 import java.net.Socket;
 7 import java.net.SocketException;
 8 
 9 public class ClientInputStream implements Runnable {
10 private Socket socket = null;
11 
12     public ClientInputStream(Socket socket) {
13     super();
14     this.socket = socket;
15 }
16 
17     @Override
18     public void run() {
19         try {
20             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
21             while(true){
22                 try {
23                     String line = br.readLine();
24                     System.out.println(line);
25                 } catch (SocketException e) {
26                     break;
27                 }
28             }
29             br.close();
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33     }
34 
35 }

客户端写

  Method[] arrMethod = classType.getDeclaredMethode(String
name,Class<?>…parameterTypes);

File类间接处理文件和文件系统。比如删除文件,获取文件长度大小等音讯。

  流按功用分为“节点流”和“过滤流”

  字节流类用于向字节流读写八位二进制的字节。一般的,字节流类主要用以读写诸如图片或然声音等的二进制数据。

      <doc>

因此反射动态运维钦点Method

  四个构造方法:

过滤字节流FilterInputStream和FilterOutputStream.构造方法:FilterOutStream(OutputStream
os)         FilterInputStream(InputStream is)

    Field[] arrFields = classType.getDeclaredFields();

  JAVA反射机制是运作情状中,对于随意1个类,都能够领略这些类的保有属性和办法;对于随意1个对象,都能都调用它的任性三个艺术;

    创设事件处理程序(即编写ContentHandler的贯彻类,一般持续自DefaultHandler类,选用adapter格局)

  Array类:提供了动态创立数组,以及走访数组的因素的静态方法。

  Constructor类:代表类的社团方法.

图片 35图片 36

  XML必须正确嵌套

implements–>Runnable

  调用notify()方法能够唤起等待队列中首先个等待同一共享能源的线程,并使该线程退出等待队列,进入可运营态。

    在文书档案的开端和停止时接触文档处监护人件

  当程序运营到非静态的synchronized同步方法上时,自动获取与正在实践代码类的此时此刻实例(this实例)有关的锁;当程序运转到synchronized同步代码块时,自动获取锁定目标的锁。

图片 37图片 38

线程状态:

XML提供联合的法门来描述和交流独立于应用程序或供应商的结构化数据。XML标签没有被预订义,开发者必要活动定义标签。XML被设计为保有自己描述性,

  二十四线程则指的是在单个程序中能够而且运营多少个不等的线程执行不一的职分。

  互连网编制程序的目标就是指间接或简介地通过网络协议与此外电脑举行广播发表。网络编制程序中有五个第3的题材,一个是怎么样准确的平素互联网上的一台或多台主机,

线程模型

线程同步

得到当前类以及超类钦赐的public
Method

实例化带参构造函数的目的

图片 39图片 40

  1 package com.ab.tzy;
  2 
  3 import java.lang.reflect.Constructor;
  4 import java.lang.reflect.Field;
  5 import java.lang.reflect.Method;
  6 
  7 public class ReflectionAPIDemo {
  8     public static void main(String[] args) throws Exception {
  9         // 获取Employee这个类所关联的Class对象
 10         Class<?> classType = Class.forName("com.ab.tzy.Employee");
 11         // 通过反射机制来构造一个Employee的实例对象
 12         // T newInstance() 创建此 Class 对象所表示的类的一个新实例。 (Class)
 13         Object newInstance = classType.newInstance();
 14         Employee employee = (Employee) newInstance;
 15         // java.lang.InstantiationException默认调用无参构造方法,如果雇员类里面没有无参就会包实例化异常
 16         System.out.println(employee);// Employee [name=null, age=0]
 17 
 18         // 调用指定的构造方法来构造对象(无参构造方法)
 19         // Constructor<T> getConstructor(Class<?>... parameterTypes)
 20         // 返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。 (Class)
 21         Constructor<?> constructor = classType.getConstructor(new Class[] {});
 22         // T newInstance(Object... initargs)
 23         // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
 24         // (Constructor)
 25         Object newInstance2 = constructor.newInstance(new Object[] {});
 26         Employee employee2 = (Employee) newInstance2;
 27         System.out.println(employee2);// Employee [name=null, age=0]
 28 
 29         // 调用指定的构造方法来构造对象(无参构造方法)
 30         // Constructor<T> getConstructor(Class<?>... parameterTypes)
 31         // 返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。 (Class)
 32         Constructor<?> constructor3 = classType.getConstructor(new Class[] {String.class,int.class});
 33         // T newInstance(Object... initargs)
 34         // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。
 35         // (Constructor)
 36         Object newInstance3 = constructor3.newInstance(new Object[] {"张三",30});
 37         Employee employee3 = (Employee) newInstance3;
 38         System.out.println(employee3);// Employee [name=张三, age=30]
 39 
 40         //获取Class对象所指定的所有方法,包括私有的
 41         // Method[] getDeclaredMethods() 返回 Method 对象的一个数组,
 42         // 这些对象反映此 Class 对象表示的类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。 (Class)
 43         // Method[] getMethods() 返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象
 44         //所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法。  (Class)
 45         System.out.println("*****");
 46         Method[] methods = classType.getDeclaredMethods();
 47         for (Method method : methods) {
 48              //String getName()  以 String 形式返回此 Method 对象表示的方法名称。 
 49             //int getModifiers() 以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符。 
 50             // Class<?> getReturnType()  返回一个 Class 对象,该对象描述了此 Method 对象所表示的方法的正式返回类型。 
 51             System.out.println(method.getName()+"--"+method.getModifiers()+"--"+method.getReturnType());
 52         }
 53                 /*
 54                 toString--1--class java.lang.String
 55                 getName--1--class java.lang.String
 56                 setName--1--void
 57                 eat--2--class java.lang.String
 58                 work--2--void
 59                 setAge--1--void
 60                 getAge--1--int
 61                 work1--0--void
 62                 work2--4--void
 63                 */
 64         System.out.println("*****");
 65         
 66         //获取Class对象所指定的方法,包括私有
 67         // Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
 68         //返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 (Class)
 69         //获取Class对象所指定的方法,不包括私有
 70         // Method getMethod(String name, Class<?>... parameterTypes) 
 71         //返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。 (Class)
 72         Method method = classType.getMethod("toString", new Class[]{});
 73         //String toString()    返回描述此 Method 的字符串。 (Method)
 74         System.out.println(method);
 75         //public java.lang.String com.ab.tzy.Employee.toString()
 76         //String getName() 以 String 形式返回此 Method 对象表示的方法名称。 (Method)
 77         System.out.println(method.getName());//toString
 78         Object desc = method.invoke(employee3, new Object[]{});
 79         System.out.println(desc);//Employee [name=张三, age=30]
 80         //方法的调用
 81         // Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
 82         //返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 (Class)
 83         Method method1 = classType.getDeclaredMethod("eat", new Class[]{String.class});
 84         // Object invoke(Object obj, Object... args) 
 85         //对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 (Method)
 86         System.out.println(method1.getName());//eat
 87          //void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值。
 88         //(method父类AccessibleObject的方法)
 89         method1.setAccessible(true);
 90         Object desc1 = method1.invoke(employee3, new Object[]{"拉拉"});
 91         System.out.println(desc1);//拉拉
 92         //java.lang.IllegalAccessException非法访问异常  必须要调用一个权限方法设置
 93         
 94         
 95         //获取Class对象所指定的属性,包括私有的
 96         Field field = classType.getDeclaredField("name");
 97         //void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值。
 98         //(field父类AccessibleObject的方法和method共同的父类)
 99         field.setAccessible(true);
100         // void set(Object obj, Object value) 
101         //将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 (Field)
102         field.set(employee3, "李四");
103         // String toString() 返回一个描述此 Field 的字符串。 (Field)
104         System.out.println(field);//private java.lang.String com.ab.tzy.Employee.name
105         // Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。 (Field)
106         System.out.println(field.get(employee3));//李四
107         // Field getDeclaredField(String name) 
108         //返回一个 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 (Class)
109         
110         // Field[] getDeclaredFields() 
111         //返回 Field 对象的一个数组,这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 (Class)
112         
113         //  Field getField(String name) 返回一个 Field 对象,它反映此 Class 对象所表
114         //示的类或接口的指定公共成员字段。 (Class)
115         
116         // Field[] getFields()  返回一个包含某些 Field 对象的数组,这些对象反映此 Class 对象所表
117         //示的类或接口的所有可访问公共字段。 (Class)
118         
119     }
120 }
121 
122 class Employee {
123     private String name;
124     private int age;
125 
126     public Employee() {
127         super();
128     }
129 
130     public Employee(String name, int age) {
131         super();
132         this.name = name;
133         this.age = age;
134     }
135 
136     public String getName() {
137         return name;
138     }
139 
140     public void setName(String name) {
141         this.name = name;
142     }
143 
144     public int getAge() {
145         return age;
146     }
147 
148     public void setAge(int age) {
149         this.age = age;
150     }
151 
152     @Override
153     public String toString() {
154         return "Employee [name=" + name + ", age=" + age + "]";
155     }
156     private String eat(String s){
157         return s;
158     }
159     private void work(){
160         System.out.println("我要工作---私有");
161     }
162     void work1(){
163         System.out.println("我要工作---默认");
164     }
165     protected  void work2(){
166         System.out.println("我要工作---保护");
167     }
168 }

取稳当前类注脚的钦点的Method

辅助对专断走访文件的读写和写入

经过落实Runnable接口创立线程

实例化无参构造函数的靶子,三种方法:

  简单的话,反射机制指的是先后在运营时亦可获得自小编的新闻。在JAVA中,只要给定类的名字,那么就足以由此反射机制来博取类的享有音信。

    图片 41

  Class类没有国有的构造方法。Class对象实际加载类时由JAVA虚拟机以及经过类加载器中的方法自动构造的,由此无法显得地宣称二个Class对象

图片 42图片 43

过滤流Buffered

构造方法:FileWriter(String
filePath)  FileWriter(String filePath,boolean
append)  FileWriter(File fileObj)

BufferedWriter通过缓冲输出提供品质

由此反射动态设定菲尔德的值

得到当前类以及超类的public
Method

  创制TCP客户端步骤

    ByteArrayInputStream(byte array[],int start,int numBytes)

 1 package com.abc.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileFilter;
 5 import java.io.FilenameFilter;
 6 import java.io.IOException;
 7 
 8 public class FileDemo {
 9     public static void main(String[] args) throws IOException {
10         File file = new File("d:\\qq");// "d:/qq"
11         // File getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
12         System.out.println(file.getAbsolutePath());// d:\qq
13         // String getParent() 返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null
14         System.out.println(file.getParent());// d:\
15         // boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
16         System.out.println(file.isDirectory());// true
17         // boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
18         System.out.println(file.isFile());// false
19         // boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
20         System.out.println(file.exists());// true
21         // boolean delete() 删除此抽象路径名表示的文件或目录。
22         System.out.println(file.delete());// false
23         File myFile = new File("d:\\zhangsan");
24         // boolean mkdir() 创建此抽象路径名指定的目录。
25         System.out.println(myFile.mkdir());// 没有时true 有了就是false
26         File myFile2 = new File("d:/zhangsan/tzy.txt");
27         // boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
28         System.out.println(myFile2.createNewFile());// 没有时true 有了就是false
29         // String[] list() 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。
30         /*
31         String[] files = file.list();
32         for (String f : files) {
33             System.out.println(f);
34         }
35         System.out.println("*************");
36         */
37         // String[] list(FilenameFilter filter)
38         // 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
39         /*
40         String[] list = file.list(new FilenameFilter() {
41 
42             @Override
43             public boolean accept(File dir, String name) {
44                 // boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 (String)
45                 return name.endsWith(".exe");
46             }
47         });
48         for (String f : list) {
49             System.out.println(f);
50         }
51         */
52         //File[] listFiles()  返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。
53         /*
54         File[] listFiles = file.listFiles();
55         for (File f : listFiles) {
56             // String getName() 返回由此抽象路径名表示的文件或目录的名称。 
57             //long length()  返回由此抽象路径名表示的文件的长度。 
58             System.out.println(f.getName()+"---"+f.length());
59         }
60         */
61         //public interface FileFilter用于抽象路径名的过滤器。
62         //File[] listFiles(FilenameFilter filter)  返回抽象路径名数组,
63         //这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
64          /*
65         File[] listFiles = file.listFiles(new FilenameFilter() {
66             
67             @Override
68             public boolean accept(File dir, String name) {
69                 return name.endsWith(".exe");
70             }
71         });
72          for (File f : listFiles) {
73              System.out.println(f.getName()+"---"+f.length());
74         }
75         */
76         //File[] listFiles(FileFilter filter) 
77         //返回抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
78         File[] listFiles = file.listFiles(new FileFilter() {
79             
80             @Override
81             public boolean accept(File pathname) {
82                 return pathname.getName().endsWith(".exe");
83             }
84         });
85          for (File f : listFiles) {
86              System.out.println(f.getName()+"---"+f.length());
87         }
88     }
89 }

  到达目标地的风浪以及内容的不易都是不可能被保证的。

向来不艺术能收获当前类的超类的private方法和天性,你必须通过getSuperclass()找到超类以往再去品味获得

      void endElement(String
uri,String localName,String qName)//ElementNode停止的处理

    ByteArrayOutStream()成立三个新的byte数组输出流

  Field[] arrField = classType.getField();

  XML根成分定义:XML文书档案的树形结构须要必须有二个根成分。根成分的起首标记要放在全数其余成分初步标记此前,

IO(Input/Output)是总计机输入/输出的接口。JAVA的宗旨库java.io提供了全方面包车型地铁IO接口,包蕴:文件系统的操作,文件读写,标准配备出口等等

  线程,又称之为轻量级进度,是程序执行流的矮小单元,是程序中1个单纯的顺序控制流程。线程是经过中的三个事例,是被系统独立调度和分担的中坚单位。

 Reader和Writer抽象类

  File InputStream Reader

  FileInputStream类表示能从文件读取字节的InputStream类

应用字节流复制一个文件夹

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.io.PrintWriter;
 9 import java.net.ServerSocket;
10 import java.net.Socket;
11 
12 public class TCPServer {
13 
14     public static void main(String[] args) throws IOException {
15         // 创建一个ServerSocket对象(服务器)
16         ServerSocket serverSocket = new ServerSocket(8888);
17         // 调用accept()方法来接受客户端的请求;
18         // Socket accept() 侦听并接受到此套接字的连接。
19         Socket socket = serverSocket.accept();
20         // InetAddress getInetAddress() 返回套接字连接的地址。
21         // String getHostAddress() 返回 IP 地址字符串(以文本表现形式)。
22         // String getHostName() 获取此 IP 地址的主机名
23         System.out.println("主机名" + socket.getInetAddress().getHostName() + "IP地址"
24                 + socket.getInetAddress().getHostAddress() + "连接成功");
25         // 获取socket对象的输入输出流
26         // InputStream getInputStream() 返回此套接字的输入流。
27         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
28         //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
29         PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
30         String line = null;
31         //读取客户端传过来的数据
32         while ((line = br.readLine()) != null) {
33             if (line.trim().equals("over")) {
34                 break;
35             } else {
36                 System.out.println(line);
37                 //bw.write(line.toUpperCase());//转换成大写的传给客户端
38                 //bw.newLine();
39                 //bw.flush();
40                 pw.println(line.toUpperCase());
41             }
42         }
43         //bw.close();
44         pw.close();
45         br.close();
46         socket.close();
47         System.out.println("主机名" + socket.getInetAddress().getHostName() + "IP地址"
48                 + socket.getInetAddress().getHostAddress() + "连接断开");
49     }
50 
51 }

TCPServer

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.net.Socket;
 9 import java.net.UnknownHostException;
10 
11 public class TCPClient {
12 
13     public static void main(String[] args) throws UnknownHostException, IOException {
14         Socket socket = new Socket("localhost", 8888);
15         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
16         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
17         BufferedReader br1 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
18         while(true){
19             String line = br.readLine();//获取键盘输入的字符串
20             bw.write(line);
21             bw.newLine();//要加换行 服务器才知道读了一行
22             bw.flush();
23             if(line.trim().equals("over")){
24                 break;
25             }
26             System.out.println(br1.readLine());//获取服务端传来的大写字符串
27         }
28         br1.close();
29         bw.close();
30         br.close();
31         socket.close();
32     }
33 
34 }

TCPClient

 

      字节流读写类  字符流读写类

    客户进度向服务器进程发生要求某种服务的请求,服务器进程响应该请求。平常,四个服务器进度会同时为八个客户进程服务

 1 package com.asd.tzy;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.FileWriter;
 8 import java.io.IOException;
 9 
10 public class BufferedReaderWriterDemo {
11 
12     public static void main(String[] args) throws IOException {
13         FileReader fr = new FileReader("d:\\tzy.txt");
14         BufferedReader br = new BufferedReader(fr);
15         FileWriter fw = new FileWriter("d:\\tzy2.txt");
16         BufferedWriter bw = new BufferedWriter(fw);
17         String line = null;
18         while((line=br.readLine())!=null){
19             System.out.println(line);
20             bw.write(line);
21             bw.newLine();//使文件换行
22             bw.flush();
23         }
24         bw.close();
25         br.close();
26     }
27 
28 }

比方采取非暗中同意编码保存文件也许读取文件时,须要动用转换流,因为字节流的重载构造方法中右制定编码格式的参数,而FileReader和FileWriter是暗许编码的公文文件。

常见的传输协议

    JAVA运维种类经过调度选中1个介乎就绪状态的线程,使其占用CPU并转为运维状态。此时,系统真正执行线程的run()方法。

怎么是反射?

 RandomAccessFile随机访问文件

 多线程Socket

       Class.forName(“com.mysql.jdbc.Driver.class”).newInstance();

这几个类提供的方法和InputStream及OutputStream类的方法一致

FileWriter表示可以写文件的Writer类

  谢世情状(Dead)

Java.lang.reflect包下:

哪些是进程:

体系化及反种类化对象

U宝马X3L能够在互连网上摸索相应的公文或别的能源。

创造接受端

  设备能够小心于某一层的功能,如交流机工作在其次层,路由器工作在第叁层。

  clazz.getConstructor(Class<?>…parameterTyprs).newInstance(Object…initargs)

IO框架

 

UKugaL的着力构造由5有个别构成:

  普通JAVA类如一而再自Thread类,就变成一个线程类,并可经过此类的start方法来运营线程,执行线程代码。

  多少个构造方法,每一个都急需1个字节数组提供数据源

    元素中的字符数据等事件。当碰着那个事件时,XML解析器会调用ContentHandler接口中相应的主意来响应事件

    关闭IO流和Socket

    ||  OutputStream  Writer  

TCP/IP是一组用于落到实处网络互联的通讯协议。Internet互联网种类结构以TCP/IP为宗旨。基于TCP/IP的参考模型将协商分成八个层次,它们各自是接口层、网络层、传输层、和应用层。

  线程的联合署名是保证二十多线程安全访问竞争能源的一种手段。

四线程的目标:

图片 44图片 45

 1 package com.asd.tzy;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileReader;
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 
 8 public class FileReaderWriterDemo {
 9 
10     public static void main(String[] args) throws IOException {
11         FileReader fr = new FileReader("d:\\tzy.txt");
12         FileWriter fw = new FileWriter("d:\\tzy1.txt");
13         char[] buff = new char[100];
14         int len = 0;//实际读取的字符个数
15         while((len=fr.read(buff))!=-1){
16             fw.write(buff,0,len);
17         }
18         fw.close();//如果不关闭 那么缓冲区文件不会被读出来,可以使用fw.flush()强制清空缓存区
19         fr.close();
20     }
21 
22 }

  对应的类-InetAddress

  线程本人不具有系统财富,与同属贰个经过的其他线程共享所在进度所兼有的能源。

    “过滤流”时对3个已存在的流的连日和打包,通过对数码开始展览处理,为顺序提供功用强大、灵活的读写作用。

  动态编写翻译:运维时规定项目,绑定对象。动态编写翻译最大限度发挥了java的左右逢原,展示了多态的应用,用以下跌类之间的耦合性。

  Class.newInstance();

      当多少个线程试图跻身有些同步区域(synchronized)时,没能进入该联合区域的线程会被置入锁定集(Lock
Pool),知道得到该联合区域的锁,进入就绪状态。

  Method类:代表类的不二法门。

悬停线程的两种方法:

BufferedReader通过缓冲输入升高质量

构造方法:BufferedWriter(Writer
outputStream)  BufferedWriter(Writer outputStream,int bufSize)

  就绪状态(Runnable)

 1 package com.abc.tzy;
 2 
 3 public class HelloThreadDemo {
 4 public static void main(String[] args) {
 5     Thread thread1 = new HelloThread("a");
 6     //void setName(String name) 改变线程名称,使之与参数 name 相同。 
 7     //thread1.setName("线程1");
 8     thread1.start();
 9     Thread thread2 = new HelloThread();
10     thread2.setName("线程2");
11     thread2.start();
12 }
13 }
14 
15 
16 class HelloThread extends Thread{
17     public HelloThread(String name){
18         super(name);
19     }
20     public HelloThread(){
21         super();
22     }
23     @Override
24     public void run() {
25         for (int i = 0; i < 5; i++) {
26             // String getName()  返回该线程的名称。 
27             System.out.println(this.getName()+":"+i);
28         }
29     }
30 }

 过滤流介绍

InputStream和Outputstream**

File类提供了与平台毫无干系的法子来对磁盘上的公文或目录进行操作。

图片 46图片 47

 1 package com.asd.tzy;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.InputStream;
 7 import java.io.OutputStream;
 8 import java.net.MalformedURLException;
 9 import java.net.URL;
10 import java.net.URLConnection;
11 
12 public class URLDemo {
13 
14     public static void main(String[] args) {
15         try {
16             DownloadUtil.download("http://scimg.jb51.net/allimg/121209/2-1212091UH0339.jpg", "my.jpg", "d:\\abcimage");
17         } catch (IOException e) {
18             e.printStackTrace();
19         }
20     }
21 
22 }
23 
24 
25 class DownloadUtil{
26     public static void download(String urlString,String fileName,String savePath) throws IOException{
27         URL url = new URL(urlString);
28         //URLConnection conn = url.openConnection();
29         //InputStream is = conn.getInputStream();
30         InputStream is = url.openStream();
31         byte[] buff = new byte[1024];
32         int len = 0;
33         File file = new File(savePath);
34         if(!file.exists()){
35             file.mkdirs();
36         }
37         OutputStream os = new FileOutputStream(file.getAbsolutePath()+"\\"+fileName);
38         while((len=is.read(buff))!=-1){
39             os.write(buff, 0, len);
40         }
41         //施放资源
42         os.close();
43         is.close();
44     }
45 }

大规模的编码表:

      能够经过Thread类的isAlive方法来判断线程是或不是处在就绪/运市价况:当线程处于就绪/运维处境时,isAlive重返true,当isAlive重返false时,恐怕线程处于阻塞状

看一下需要:

互连网通训要素

    服务器程序将几个套接字绑定到贰个一定的端口,并由此此套接字等待和监听客户的连日请求。

图片 48图片 49

  新建状态(New Thread)

线程的生命周期

图片 50图片 51

反射常用

 InputStreamReader,OutputStreamWrite