JAVA学习io,net,线程

方法覆盖复习：修饰符(相同或更宽)，返回值（相同或是父类返回类型的子类型），方法
名相同，参数列表相同，抛出的异常（不能抛出比父类方法更多的异常）
反射： java.lang.Class
        java.lang.reflect.Field
        java.lang.reflect.Method
        java.lang.reflect.Constructor
        java.lang.reflect.Array
//                   1.得到类对象
                     Class c = Class.forName("Student");
//                   2.通过类对象产生对象（调用无参的构造方法）
                     //Object obj = c.newInstance();
                     2.a 通过类对象找到相应的Constructor对象
//
                     Constructor cons =c.getConstructor(String.class,int.class);
                     2.b 通过Constructor对象得到对象
//
                     Object obj = cons.newInstance("zhangsan",20);
                     System.out.println(obj);
//                   3.通过类对象找到相应的Method对象
                     Method m1 = c.getDeclaredMethod("getAge");
//                   4.调用对象的方法。
                     Object age = m1.invoke(obj);
                     System.out.println(age);
                     Method m2 = c.getDeclaredMethod("study", String.class);
                     m2.invoke(obj, "corejava");
标注：
@Override   标注     给编译器看
@SuppressWarnings("unused")
@SuppressWarnings("unchecked")
@Deprecated过时，不推荐使用。。不删除是为了向后兼容
定义自己的标注：
  public @interface 标注名称{
           类型    属性（）        default    默认值;
}
元数据：数据的数据
元标注：标注的标注
@Author(@Name(first=”Tony”,last=”Tan”))
标注属性类型 只能是8种基本类型，String.枚举类型，Class,注释标注类型，对应的一维
数组
import java.lang.annotation.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
@Retention(value=RUNTIME)//这样设置才能使用反射方式探查出来
@Target(value=)
public @interface Test {
                    String value()   default "No Parameter";
}
1定义注释：MyTest         String author String date
import java.lang.annotation.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static java.lang.annotation.ElementType.METHOD;
@Retention(value=RUNTIME)
@Target(value=)
public @interface MyTest {
                    String author() default "itemMgr";
                    String date() default "2009-2-16";
}
2写一个类，使用MyTest注释                @MyTest(author="itemMgr",date="2009-2-10")
3通过反射调用某人写的方法；
          Class c = Class.forName("Util");
          Object obj = c.newInstance();
          //得到所有方法
          Method[] mm = c.getDeclaredMethods();
          for(Method m:mm){
          //判断方法是否有Test注释
          boolean b = m.isAnnotationPresent(Test.class);
          if(b){
           //得到注释
          Test t = m.getAnnotation(Test.class);
          //通过注释得到注释中的属性
          String param = t.value();
          //调用方法
          m.invoke(obj, param);
                                         }
这里实现了类似Junit的测试框架。当标注为test before after 等等，会相应调用方法
来测试类
线程：宏观上并行，微观上串行
第一种方式：extends Thread 继承   覆盖run()方法 .start()启动一个线程
currentThread() 当前线程
优先级只是一个参考。不要使用优先级来控制线程
第二种 方法：implements Runnable接口。实现run()方法
Thread(Runnable)
eclipse常用快捷键：
syso main   Alt+/ 主方法，打印语句
ctrl+1  错误提示操作
ctrl+/ 注释
ctrl+d删一行
ctrl+-> <- 切换编辑工作区
加载配置文件：java.util.Properties
          .load(InputStream)
          .getProperty(String key)
反射：
          File[] fs = cz.getDeclaredFields();
          for(Field f:fs){//得到属性名字          根据完全封装规范转换得到 get/set 方法名：
                     String attributeName = f.getName();
                       char c = attributeName.charAt(0);//获得属性第一个字母
                     c -= 32; //转成大写
          String mn = “set”+c+attributeName.substring(1);//构造 get/set 方法名
          }
线程三要素：cpu data ,code
产生线程的方式：a             extends Thread   覆盖 run 方法调用 Thread 的 start()
                  b    implements Runnable 接口，实现 run()方法
                     new Thread(runImpl) .start();
Thread.sleep()进入休眠
Thread.currentThread()当前执行线程
中断：work(){
          while(true){
                     if(flag == false){
                                throw new InterruptedException()
                     }
                     run
          }
}
try{
work()
}cathc(IterruptedException){}
同步代码块
public void run(){
while(tickets > 1){
synchronized(obj){
if(tickets<=1) break;
tickets --;
System.out.println(Thread.currentThread()+" : "+tickets);
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}}}}
synchronized 修饰方法 代码块
// synchronized 修饰静态方法，锁对象是类对象
会造成死锁
新特性：java.util.concurrent.locks
接口 Lock
    public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
java.util.concurrent.atomic 原子操作
volatile 只能修饰实例变量。同步范围仅仅是变量级的
volatile boolean flag = false;
while(true){
             if(falg){
                        throws new InterruptedException()
             }
             work();
}
public void start(){
             flag = false;
}
public void cancel(){
             flag = true;
}
notify() notiyfAll() wait() 在 synchonized()代码中。
  synchronized(this){
  try {
notifyAll();
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread.yield();//?该方法不一定能调用成功暂停当前正在执行的线程对象，并执行其他线程。其
它线程可能是当前线程
高级特性
executor 接口执行已提交的 Runnable 任务的对象。此接口提供一种将任务提交与每个任务将如何运行
的机制（包括线程使用的细节、调度等）分离开来的方法。通常使用 Executor 而不是显式地创建线程。例
如，可能会使用以下方法，而不是为一组任务中的每个任务调用 new
Thread(new(RunnableTask())).start()：
  Executor executor = anExecutor;
  executor.execute(new RunnableTask1());
  executor.execute(new RunnableTask2());
接口回调： 调用接口中的方法实际上调用的是实现者的方法
线程池           ExecutorService
ExecutorService exec =Executors.newFixedThreadPool(2);
exec.submit(new ThreadA());
exec.submit(new ThreadB());
exec.shutdown();
Callable Future
1线程，三要素
2.如何产生线程
3synchronized
4wait.notify
Lock ReadWriteLock -> synchronzied
Executor/ExecutorService -> Thread
Callable/Future -> Runnable
Condition.await -> wait
Condition.signal ->notify
Io流      File
File f = new File("a.txt");
System.out.println(f.exists());//判断一文件是否存在
if(!f.exists()){
boolean b = f.createNewFile();//创建文件
System.out.println(b);
}
System.out.println(f.delete());//删除文件，成功 true
System.out.println(f.getAbsolutePath());//获得绝对路径
System.out.println(f.getPath());
System.out.println(File.separator);
System.out.println(f.isFile());
System.out.println(f.isDirectory());
System.out.println(f.isAbsolute());
//创建目录
File f = new File("dir");
System.out.println(f.mkdir());
针对FileFilter接口编程。（当接口没有给出实现时，都是需要用户自己实现接口或者用
匿名内部类）
class MyFilter implements FileFilter{
            public boolean accept(File pathname) {
                      String name = pathname.getName().trim();
                      if(name.endsWith(".txt"))
                      return true;
                      return false;}}
Input Stream & Output Stream
Byte Stream & Char Stream
Node Stream & Wrapper Stream
InputStream    读入 read()     读一个字节
read(byte[] b) b 是一个缓冲
byte[] buf = new byte[5];
while(true){
int len =in.read(buf,1,3);
if(len == -1) break;
System.out.println(len);
System.out.println(Arrays.toString(buf));
}
in.close();
OutputStream     写入write() 写入一个字节
包装流： DataInputStream DataOutputStream         中有一次性写读Int ,Short,Long.Double
等包装类型
            BufferedOutputStream BufferedInputStream 记得写入时要flush
byte[] b = new byte[100];一次性读 100 个字节
int len = 0;//是否读到文件末尾。。注意                          in = read(byte[])方法
while((len=in.read(b))!=-1){
}
in.close();


PipedOutputStream pout       = new PipedOutputStream();
PipedInputStream pin = new PipedInputStream();      连接管道流
pout.connect(pin);
ObjectInputStream & ObjectOutputStream 对象流
Serizlizable序列化接口。。可将一个对象写入文件或在网络上传输
序列化文件以 ACED 开头
序列化可以给一个对象加上标识（序列号）                          当修改对象类时，只要序列号一样，在文件
和网络上就能找到该对象。
transient    表此属性不序列，是一个临时属性                     8 大基本类型都实现了序列化接口
在序列化类中有引用类型，也需要保存时都要序列化
Serialiver 命令，可查看序列化                序列化不可在后面追加。因为在一个文件中 ACED 只能
出现一次
要追加只好读出来再追加后写进去
字节流完
字符流：Reader         Writer
        InputStreamReader      包装类，包装字节流 桥转换：字节流转换成字符流
     桥转换过程中可设定编码
           BufferedReader readLine()
           PrintWriter
           StringReader
           FileReader 直接读文件，不用桥转换
           BufferedWriter
           RandomAccessFile 随机访问文件
System.setOut(new PrintStream("a.txt"));//不输出在控制台，而输出到文件
System.out.println("Hello World");
System.out.println(System.out.getClass());
//InputStream in = System.in;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
while(true){
String s = br.readLine();
if(s.equals("exit")) break;
System.out.println(s);
}
JAVA图形界面
JFC Swing   AWT事件处理
Creating GUI    1:choosing A Container
          (JFrame Jdialog,JApplent,JPanel) JtabbedPane
               2:choosing A layout Manager
               3:Adding Components in the Containter
               4:Creating Event Handlers
事件监听原理：
import java.util.*;
public class TestGirl {
public static void main(String[] args) {
Girl g = new Girl("秋香");
Boy1 boy1 = new Boy1("xiegy");
g.addEmotionListener(boy1);
Boy2 boy2 = new Boy2("zhaojun");
g.addEmotionListener(boy2);
g.fire();
}
}
interface EmotionListener {
void whatCanIDoWhenGirlHappy(EmotionEvent e);
void whatCanIDoWhenGirlSad(EmotionEvent e);
}
//
////事件对象封装事件源
//class EmotionEvent{
// private Object source;//事件源
// public EmotionEvent(Object source){
// this.source = source;
// }
// public Object getSource() {
// return source;
// }
//
//}
//事件对象封装事件源
class EmotionEvent extends EventObject{
public EmotionEvent(Object source) {
super(source);
}
}
//事件源
class Girl {
private String name;
private List<EmotionListener> listeners = new
ArrayList<EmotionListener>();
public void addEmotionListener(EmotionListener listener){
listeners.add(listener);
}
public void removeEmotionListener(EmotionListener listener){
listeners.remove(listener);
}
public void fire(){
for(int i=1;i<=5;i++){
System.out.println("Day"+i);
if(i%2 == 0){
System.out.println(name+"说：今天
心情不好！");
for(EmotionListener e:listeners){
//所谓事件源向监听者发
出消息，即通过事件对象封装事件源
//然后以事件对象为参数
调用监听者的相应方法
EmotionEvent event =
new EmotionEvent(this);
e.whatCanIDoWhenGirlSad(event);
}
}else{
System.out.println(name+"说：今天
天气好，心情好！");
for(EmotionListener e:listeners){
EmotionEvent event =
new EmotionEvent(this);
e.whatCanIDoWhenGirlHappy(event);
}
}
}
}
public Girl(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
//事件处理者
class Boy1 implements EmotionListener {
private String name;
public Boy1(String name) {
this.name = name;
}
@Override
public void whatCanIDoWhenGirlHappy(EmotionEvent e) {
Girl g = (Girl)e.getSource();
System.out.println(name + "对"+g.getName()+"说：你开心我也挺开
心！");
}
@Override
public void whatCanIDoWhenGirlSad(EmotionEvent e) {
Girl g = (Girl)e.getSource();
System.out.println(name + "对"+g.getName()+"说：你EmotionEvent不
开心我也不开心！");
}
}
class Boy2 implements EmotionListener {
private String name;
public Boy2(String name) {
this.name = name;
}
@Override
public void whatCanIDoWhenGirlHappy(EmotionEvent e) {
Girl g = (Girl)e.getSource();
System.out.println(name + "对"+g.getName()+"说：你开心我倒不开
心！");
}
@Override
public void whatCanIDoWhenGirlSad(EmotionEvent e) {
Girl g = (Girl)e.getSource();
System.out.println(name + "对"+g.getName()+"说：你不开心我也开
心！");
}
}
private class MyActionListener implements ActionListener{
@Override
public void actionPerformed(ActionEvent e){
jta.append(jtf.getText()+”\n”);
jtf.setText();
}
}
private class MyKeyListener extends KeyAdapter{
@Override
public void KeyPressed(KeyEvent e){
if(e.getKeyCode() == KeyEvent.VK_ENTER){
jta.append(jtf.getText()+”\n”);
jtf.setText();
}
}
Java net 网络编程
端口0～65535
0～1024系统保留端口
IPV4 192.168.0.23 按位与
主机地址：0.0.1.23
网络地址：192.168.0.0
子网掩码：255.255.254.0
public class TcpServer {
public static void main(String[] args) {
ServerSocket ss = null;
try {
//1.得到ServerSocket
ss = new ServerSocket(8888);
System.out.println("Server start
...");
//2.等待客户端连接
Socket s = ss.accept();
//3.从Socket中得到输入输出流
InputStream in =
s.getInputStream();
DataInputStream din = new
DataInputStream(in);
String text = din.readUTF();
System.out.println("Server
Receive"+text);
OutputStream out =
s.getOutputStream();
DataOutputStream dout = new
DataOutputStream(out);
dout.writeUTF("你好，客户端");
dout.close();
din.close();
} catch (IOException e) {
e.printStackTrace();
}finally{
try{ss.close();}catch(IOException
e){e.printStackTrace();}
}
}
}
import java.io.*;
import java.net.*;
public class TcpClient {
public static void main(String[] args) {
Socket s = null;
try {
s= new Socket("localhost",8888);
OutputStream out =
s.getOutputStream();
DataOutputStream dout = new
DataOutputStream(out);
dout.writeUTF("你好，服务器");
InputStream in =
s.getInputStream();
DataInputStream din = new
DataInputStream(in);
String text = din.readUTF();
System.out.println("Client
Receive:"+text);
din.close();
dout.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}