JAVAday25-27

多线程

单例设计模式

保证类在内存中只有一个对象
如何保证类在内存中只有一个对象呢？
- (1)控制类的创建，不让其他类来创建本类的对象。private
- (2)在本类中定义一个本类的对象。Singleton s;
- (3)提供公共的访问方式。 public static Singleton getInstance(){return s}

饿汉式开发用

class Singleton{
	private Singleton(){}
	private static Singleton s = new Singleton();
	public static Singleton getInstance(){
		return s;
	}
	public static void print(){
		System.out.printfln("1");
	}

懒汉式面试用单例的延迟加载模式

class Singleton{
	private Singleton(){}
	private static Singleton s;
	public static Singleton getInstance(){
		if(s == null)
			s = new Singleton();
		return s;
	}
	public static void print(){
		System.out.println("1");
	}

第三种格式

class Singleton{
	private Singleton(){}
	public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
}

Runtime

Runtime类是一个单例类

Runtime r = Runtime.getRuntime();
//r.exec("shutdown -s -t 300"); //300秒后关机  -s关闭计算机 -t xxx 设置关闭前的超时为xxx秒
r.exec("shutdown -a"); //取消  -a 中止系统关闭
//在DOS控制台下输入shutdown可查看指令

Timer

计时器

public class Demo5_Timer {
			
			public static void main(String[] args) throws InterruptedException {
				Timer t = new Timer();
				t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000); //第一个参数执行任务，第二个参数执行时间，第三个参数重复执行时间
				
				while(true) {
					System.out.println(new Date());
					Thread.sleep(1000);
				}
			}
		}
		class MyTimerTask extends TimerTask {
			@Override
			public void run() {
				System.out.println("起床背英语单词");
			}
			
		}

两个线程间的通信

1.什么时候需要通信
- 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
- 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印

2.怎么通信

如果希望线程等待, 就调用wait()
如果希望唤醒等待的线程, 就调用notify();
这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

public class Demo1_Notify {
	public static void main(String[] args) {
		final Printer p = new Printer();  //在JDK8中 final系统默认加上 可以不写出
		
		new Thread() {
			public void run() {
				while(true) {
					try {
						p.print1();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				while(true) {
					try {
						p.print2();
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
				}
			}
		}.start();
	}

}

class Printer {
	private int flag = 1;
	public void print1() throws InterruptedException {							
		synchronized(this) {
			if(flag != 1) {
				this.wait();					//当前线程等待
			}
			System.out.print("a");
			System.out.print("b");
			System.out.print("c");
			System.out.print("\r\n");
			flag = 2;
			this.notify();						//随机唤醒单个等待的线程
		}
	}
	
	public void print2() throws InterruptedException {
		synchronized(this) {
			if(flag != 2) {
				this.wait();
			}
			System.out.print("1");
			System.out.print("2");
			System.out.print("\r\n");
			flag = 1;
			this.notify();
		}
	}
}

三个或三个以上间的线程通信

多个线程通信的问题

notify()方法是随机唤醒一个线程
notifyAll()方法是唤醒所有线程
JDK5之前无法唤醒指定的一个线程
如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

/*1,在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
 * 2,为什么wait方法和notify方法定义在Object这类中?
 * 	因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
 * 3,sleep方法和wait方法的区别?
 * a,sleep方法必须传入参数,参数就是时间,时间到了自动醒来
 *   wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
 * b,sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡
 * 	wait方法在同步函数或者同步代码块中,释放锁
 */ 
class Printer2 {
	private int flag = 1;
	public void print1() throws InterruptedException {							
		synchronized(this) {
			while(flag != 1) {
				this.wait();					//线程1在此等待,if语句是在哪里等待,就在哪里起来
													//while循环是循环判断,每次都会判断标记 用while不用for是为了重复判断保持123的顺序
			}
			System.out.print("a");
			System.out.print("b");
			System.out.print("c");
			System.out.print("\r\n");
			flag = 2;
			//this.notify();						//随机唤醒单个等待的线程
			this.notifyAll();
		}
	}
	
	public void print2() throws InterruptedException {
		synchronized(this) {
			while(flag != 2) {
				this.wait();					//线程2在此等待
			}
			System.out.print("1");
			System.out.print("2");
			System.out.print("\r\n");
			flag = 3;
			//this.notify();
			this.notifyAll();
		}
	}
	
	public void print3() throws InterruptedException {
		synchronized(this) {
			while(flag != 3) {
				this.wait();						
			}
			System.out.print("i");
			System.out.print("t");
			System.out.print("\r\n");
			flag = 1;
			//this.notify();
			this.notifyAll();
		}
	}
}

JDK1.5的新特性互斥锁

1.同步
- 使用ReentrantLock类的lock()和unlock()方法进行同步

2.通信

使用ReentrantLock类的newCondition()方法可以获取Condition对象
需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

	private ReentrantLock r  = new ReentrantLock();
    private Condition c1 = r.newCondition();
    private Condition c2 = r.newCondition();
    private Condition c3 = r.newCondition();
    private int flag = 1;
    public void print1() throws InterruptedException {
        r.lock();
            if (flag != 1) {
                c1.await();
            }
            System.out.print("a");
            System.out.print("b");
            System.out.print("c");
            System.out.print("\r\n");
            flag = 2;
            c2.signal();
        r.unlock();
    }

    public void print2() throws InterruptedException {
        r.lock();
            if (flag != 2) {
                c2.await();
            }
            System.out.print("1");
            System.out.print("2");
            System.out.print("\r\n");
            flag = 3;
            c3.signal();
        r.unlock();
    }

    public void print3() throws InterruptedException {
        r.lock();
            if (flag != 3) {
                c3.await();
            }
            System.out.print("i");
            System.out.print("t");
            System.out.print("\r\n");
            flag = 1;
            c1.signal();
        r.unlock();
    }

线程组的概述和使用

A:线程组概述

Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下，所有的线程都属于主线程组。
- public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
- public final String getName()//通过线程组对象获取他组的名字
我们也可以给线程设置分组
- 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
- 2,创建线程对象
- 3,Thread(ThreadGroup?group, Runnable?target, String?name)
- 4,设置整组的优先级或者守护线程
  - 线程组的好处把整个组一起设置

* 线程组的使用,默认是主线程组
* 
		MyRunnable mr = new MyRunnable();
		Thread t1 = new Thread(mr, "张三");
		Thread t2 = new Thread(mr, "李四");
		//获取线程组
		// 线程类里面的方法：public final ThreadGroup getThreadGroup()
		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();
		// 线程组里面的方法：public final String getName()
		String name1 = tg1.getName();
		String name2 = tg2.getName();
		System.out.println(name1);
		System.out.println(name2);
		// 通过结果我们知道了：线程默认情况下属于main线程组
		// 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组
		System.out.println(Thread.currentThread().getThreadGroup().getName());

	* 自己设定线程组
* 			
		// ThreadGroup(String name)
		ThreadGroup tg = new ThreadGroup("这是一个新的组");

		MyRunnable mr = new MyRunnable();
		// Thread(ThreadGroup group, Runnable target, String name)
		Thread t1 = new Thread(tg, mr, "张三");
		Thread t2 = new Thread(tg, mr, "李四");
		
		System.out.println(t1.getThreadGroup().getName());
		System.out.println(t2.getThreadGroup().getName());
		
		//通过组名称设置后台线程，表示该组的线程都是后台线程
		tg.setDaemon(true);

线程的五种状态

JAVAday25-27
//stop已经过时

线程池的概述和使用

A:线程池概述
- 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池

B:内置线程池的使用概述

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
- public static ExecutorService newFixedThreadPool(int nThreads)
- public static ExecutorService newSingleThreadExecutor()
- 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
- Future<?> submit(Runnable task)
- Future submit(Callable task)
使用步骤：
- 创建线程池对象
- 创建Runnable实例
- 提交Runnable实例
- 关闭线程池
C:案例演示
- 提交的是Runnable

  // public static ExecutorService newFixedThreadPool(int nThreads)
  ExecutorService pool = Executors.newFixedThreadPool(2);

  // 可以执行Runnable对象或者Callable对象代表的线程
  pool.submit(new MyRunnable());
  pool.submit(new MyRunnable());

  //结束线程池
  pool.shutdown();

提交的是Callable
好处和弊端
- 好处：
  - 可以有返回值
  - 可以抛出异常
- 弊端：
  - 代码比较复杂，所以一般不用


// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);

// 可以执行Runnable对象或者Callable对象代表的线程
Future<Integer> f1 = pool.submit(new MyCallable(100));
Future<Integer> f2 = pool.submit(new MyCallable(200));

// V get()
Integer i1 = f1.get();
Integer i2 = f2.get();

System.out.println(i1);
System.out.println(i2);

// 结束
pool.shutdown();

public class MyCallable implements Callable<Integer> {

	private int number;

	public MyCallable(int number) {
		this.number = number;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int x = 1; x <= number; x++) {
			sum += x;
		}
		return sum;
	}

}

设计模式

简单工厂模式概述

A:又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
B:优点
- 客户端不需要在负责对象的创建，从而明确了各个类的职责
C:缺点
- 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
D:案例演示
- 动物抽象类：public abstract Animal { public abstract void eat(); }
- 具体狗类：public class Dog extends Animal {}
- 具体猫类：public class Cat extends Animal {}
- 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

  public class AnimalFactory {
  	private AnimalFactory(){}
  
  	//public static Dog createDog() {return new Dog();}
  	//public static Cat createCat() {return new Cat();}
  
  	//改进
  	public static Animal createAnimal(String animalName) {
  		if(“dog”.equals(animalName)) {}
  		else if(“cat”.equals(animale)) {
  
  		}else {
  			return null;
  		}
  	}
  }

工厂方法模式概述

A:工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
B:优点
- 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
C:缺点
- 需要额外的编写代码，增加了工作量
D:案例演示

  动物抽象类：public abstract Animal { public abstract void eat(); }
  工厂接口：public interface Factory {public abstract Animal createAnimal();}
  具体狗类：public class Dog extends Animal {}
  具体猫类：public class Cat extends Animal {}
  开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
  狗工厂：public class DogFactory implements Factory {
  	public Animal createAnimal() {…}
          }
  猫工厂：public class CatFactory implements Factory {
  	public Animal createAnimal() {…}
          }

适配器设计模式Adapter

a.什么是适配器
- 在使用监听器的时候, 需要定义一个类事件监听器接口.
- 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
- 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.

b.适配器原理

适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

interface 和尚 {
	public void 打坐();
	public void 念经();
	public void 撞钟();
	public void 习武();
}

abstract class 天罡星 implements 和尚 {		//声明成抽象的原因是,不想让其他类创建本类对象,因为创建也没有意义,方法都是空的

	@Override
	public void 打坐() {
	}

	@Override
	public void 念经() {
	}

	@Override
	public void 撞钟() {
	}

	@Override
	public void 习武() {
	}
	
}

class 鲁智深 extends 天罡星 {
	public void 习武() {
		System.out.println("倒拔垂杨柳");
		System.out.println("拳打镇关西");
		System.out.println("大闹野猪林");
		System.out.println("......");
	}
}

模版(Template)设计模式概述和使用

A:模版设计模式概述
- 模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

B:优点和缺点

a:优点
- 使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
b:缺点
- 如果算法骨架有修改的话，则需要修改抽象类

public class Demo1_Template {

	public static void main(String[] args) {
		/*long start = System.currentTimeMillis();
		for(int i = 0; i < 1000000; i++) {
			System.out.println("x");
		}
		long end = System.currentTimeMillis();
		System.out.println(end - start);*/替换
		
		Demo d = new Demo();
		System.out.println(d.getTime());
	}

}

abstract class GetTime {
	public final long getTime() {
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		return end - start;
	}

	public abstract void code();
}

class Demo extends GetTime {

	@Override
	public void code() {
		int i = 0;
		while(i < 100000) {
			System.out.println("x");
			i++;
		}
	}
}

GUI

Graphical User Interface(图形用户接口)

如何创建一个窗口并显示

  Frame  f = new Frame(“my window”);
  f.setLayout(new FlowLayout());//设置布局管理器
  f.setSize(500,400);//设置窗体大小
  f.setLocation(300,200);//设置窗体出现在屏幕的位置
  f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png"));
  f.setVisible(true);

布局管理器

FlowLayout（流式布局管理器）
- 从左到右的顺序排列。
- Panel默认的布局管理器。
BorderLayout（边界布局管理器）
- 东，南，西，北，中
- Frame默认的布局管理器。
GridLayout（网格布局管理器）
- 规则的矩阵
CardLayout（卡片布局管理器）
- 选项卡
GridBagLayout（网格包布局管理器）
- 非规则的矩阵

窗体监听

    Frame f = new Frame("我的窗体");
    	//事件源是窗体,把监听器注册到事件源上
    	//事件对象传递给监听器
    	f.addWindowListener(new WindowAdapter() {
    	          public void windowClosing(WindowEvent e) {
    	                     //退出虚拟机,关闭窗口
    			System.exit(0);
    		}
    	});

鼠标监听

键盘监听和键盘事件

动作监听

了解

事件处理
- 事件: 用户的一个操作
- 事件源: 被操作的组件
- 监听器: 一个自定义类的对象, 实现了监听器接口, 包含事件处理方法,把监听器添加在事件源上, 当事件发生的时候虚拟机就会自动调用监听器中的事件处理方法

网络编程

网络编程概述

A:计算机网络
- 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
B:网络编程
- 就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

网络编程三要素之IP概述

每个设备在网络中的唯一标识
每台网络终端在网络中都有一个独立的地址，我们在网络中传输数据就是使用这个地址。
ipconfig：查看本机IP192.168.12.42
ping：测试连接192.168.40.62
本地回路地址：127.0.0.1 255.255.255.255是广播地址
IPv4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。
IPv6：8组，每组4个16进制数。
1a2b:0000:aaaa:0000:0000:0000:aabb:1f2f
1a2b::aaaa:0000:0000:0000:aabb:1f2f
1a2b:0000:aaaa::aabb:1f2f
1a2b:0000:aaaa::0000:aabb:1f2f
1a2b:0000:aaaa:0000::aabb:1f2f //0000可以省略但只能省略一处连续

网络编程三要素之端口号概述

每个程序在设备上的唯一标识
每个网络程序都需要绑定一个端口号，传输数据的时候除了确定发到哪台机器上，还要明确发到哪个程序。
端口号范围从0-65535
编写网络应用就需要绑定一个端口号，尽量使用1024以上的，1024以下的基本上都被系统程序占用了。
常用端口
- mysql: 3306
- oracle: 1521
- web: 80
- tomcat: 8080
- QQ: 4000
- feiQ: 2425

网络编程三要素协议

为计算机网络中进行数据交换而建立的规则、标准或约定的集合。
UDP
- 面向无连接，数据不安全，速度快。不区分客户端与服务端。
TCP
- 面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。
  - 三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

Socket通信原理

A:Socket套接字概述：
- 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
- 通信的两端都有Socket。
- 网络通信其实就是Socket间的通信。
- 数据在两个Socket间通过IO流传输。
- Socket在应用程序中创建，通过一种绑定机制与驱动程序建立关系，告诉自己所对应的IP和port。

UDP传输

1.发送Send
- 创建DatagramSocket, 随机端口号
- 创建DatagramPacket, 指定数据, 长度, 地址, 端口
- 使用DatagramSocket发送DatagramPacket
- 关闭DatagramSocket
2.接收Receive
- 创建DatagramSocket, 指定端口号
- 创建DatagramPacket, 指定数组, 长度
- 使用DatagramSocket接收DatagramPacket
- 关闭DatagramSocket
- 从DatagramPacket中获取数据
3.接收方获取ip和端口号
- String ip = packet.getAddress().getHostAddress();
- int port = packet.getPort();

UDP传输优化

接收端Receive

  DatagramSocket socket = new DatagramSocket(6666);						//创建socket相当于创建码头
  DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);		//创建packet相当于创建集装箱
  
  while(true) {
  	socket.receive(packet);												//接收货物
  	byte[] arr = packet.getData();
  	int len = packet.getLength();
  	String ip = packet.getAddress().getHostAddress();
  	System.out.println(ip + ":" + new String(arr,0,len));
  }

发送端Send

  DatagramSocket socket = new DatagramSocket();		//创建socket相当于创建码头
  Scanner sc = new Scanner(System.in);
  
  while(true) {
  	String str = sc.nextLine();
  	if("quit".equals(str))
  		break;
  	DatagramPacket packet = 							//创建packet相当于创建集装箱
  			new DatagramPacket(str.getBytes(), str.getBytes().length, InetAddress.getByName("127.0.0.1"), 6666);
  	socket.send(packet);			//发货
  }
  socket.close();

UDP传输多线程

A发送和接收在一个窗口完成

  public class Demo3_MoreThread {

  	/**
  	 * @param args
  	 */
  	public static void main(String[] args) {
  		new Receive().start();
  		
  		new Send().start();
  	}
  
  }

  class Receive extends Thread {
  	public void run() {
  		try {
  			DatagramSocket socket = new DatagramSocket(6666);					//创建socket相当于创建码头
  			DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);	//创建packet相当于创建集装箱
  			
  			while(true) {
  				socket.receive(packet);												//接收货物
  				byte[] arr = packet.getData();
  				int len = packet.getLength();
  				String ip = packet.getAddress().getHostAddress();
  				System.out.println(ip + ":" + new String(arr,0,len));
  			}
  		} catch (IOException e) {
  			
  			e.printStackTrace();
  		}
  	}
  }

  class Send extends Thread {
  	public void run() {
  		try {
  			DatagramSocket socket = new DatagramSocket();		//创建socket相当于创建码头
  			Scanner sc = new Scanner(System.in);
  			
  			while(true) {
  				String str = sc.nextLine();
  				if("quit".equals(str))
  					break;
  				DatagramPacket packet = 							//创建packet相当于创建集装箱
  						new DatagramPacket(str.getBytes(), str.getBytes().length, InetAddress.getByName("127.0.0.1"), 6666);
  				socket.send(packet);			//发货
  			}
  			socket.close();
  		}  catch (IOException e) {
  			
  			e.printStackTrace();
  		}
  	}
  }

（UDP聊天工具实现）

TCP协议代码优化

客户端

  Socket socket = new Socket("127.0.0.1", 9999);		//创建Socket指定ip地址和端口号
  InputStream is = socket.getInputStream();			//获取输入流
  OutputStream os = socket.getOutputStream();			//获取输出流
  BufferedReader br = new BufferedReader(new InputStreamReader(is));
  PrintStream ps = new PrintStream(os);
  
  System.out.println(br.readLine());
  ps.println("我想报名就业班");
  System.out.println(br.readLine());
  ps.println("爷不学了");
  socket.close();

服务端

  ServerSocket server = new ServerSocket(9999);	//创建服务器
  Socket socket = server.accept();				//接受客户端的请求
  InputStream is = socket.getInputStream();		//获取输入流
  OutputStream os = socket.getOutputStream();		//获取输出流
  
  BufferedReader br = new BufferedReader(new InputStreamReader(is));
  PrintStream ps = new PrintStream(os);
  
  ps.println("欢迎咨询");
  System.out.println(br.readLine());
  ps.println("报满了,请报下一期吧");
  System.out.println(br.readLine());
  server.close();
  socket.close();

多线程服务端

	ServerSocket server = new ServerSocket(9999);	//创建服务器
	while(true) {
		final Socket socket = server.accept();				//接受客户端的请求
		new Thread() {
			public void run() {
				try {
					BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
					PrintStream ps = new PrintStream(socket.getOutputStream());
					ps.println("欢迎咨询");
					System.out.println(br.readLine());
					ps.println("报满了,请报下一期吧");
					System.out.println(br.readLine());
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}
}

练习1：客户端向服务器写字符串(键盘录入),服务器(多线程)将字符串反转后写回,客户端再次读取到是反转后的字符串

Client：

		public static void main(String[] args) throws UnknownHostException, IOException {
		Scanner sc = new Scanner(System.in);				//创建键盘录入对象
		Socket socket = new Socket("127.0.0.1", 54321);		//创建客户端,指定ip地址和端口号
		
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));	//获取输入流
		PrintStream ps = new PrintStream(socket.getOutputStream());//获取输出流
		
		ps.println(sc.nextLine());							//将字符串写到服务器去
		System.out.println(br.readLine()); 					//将反转后的结果读出来
		
		socket.close();
	}

Server

public static void main(String[] args) throws IOException {
		ServerSocket server = new ServerSocket(54321);
		System.out.println("服务器启动,绑定54321端口");
		
		while(true) {
			final Socket socket = server.accept();					//接受客户端的请求
			
			new Thread() {											//开启一条线程
				public void run() {
					try {
						BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));	//获取输入流
						PrintStream ps = new PrintStream(socket.getOutputStream());//获取输出流
						
						String line = br.readLine();				//将客户端写过来的数据读取出来
						line = new StringBuilder(line).reverse().toString();	//链式编程
						ps.println(line);							//反转后写回去
						
						socket.close();
					} catch (IOException e) {						
						
						e.printStackTrace();
					}
				}
			}.start();
		}
	}

练习2：客户端向服务器上传文件

Client：

public static void main(String[] args) throws UnknownHostException, IOException {
		// 1.提示输入要上传的文件路径, 验证路径是否存在以及是否是文件夹
		File file = getFile();
		// 2.发送文件名到服务端
		Socket socket = new Socket("127.0.0.1", 12345);
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		PrintStream ps = new PrintStream(socket.getOutputStream());
		ps.println(file.getName());
		// 6.接收结果, 如果存在给予提示, 程序直接退出
		String result = br.readLine();						//读取存在后不存在的结果
		if("存在".equals(result)) {
			System.out.println("您上传的文件已经存在,请不要重复上传");
			socket.close();
			return;
		}
		// 7.如果不存在, 定义FileInputStream读取文件, 写出到网络
		FileInputStream fis = new FileInputStream(file);
		byte[] arr = new byte[8192];
		int len;
		
		while((len = fis.read(arr)) != -1) {
			ps.write(arr, 0, len);
		}
		
		fis.close();
		socket.close();
	}

	private static File getFile() {
		Scanner sc = new Scanner(System.in);				//创建键盘录入对象
		System.out.println("请输入一个文件路径:");
		
		while(true) {
			String line = sc.nextLine();
			File file = new File(line);
			
			if(!file.exists()) {
				System.out.println("您录入的文件路径不存在,请重新录入:");
			}else if(file.isDirectory()) {
				System.out.println("您录入的是文件夹路径,请输入一个文件路径:");
			}else {
				return file;
			}
		}
	}

Server

public static void main(String[] args) throws IOException {
		//3,建立多线程的服务器
		ServerSocket server = new ServerSocket(12345);
		System.out.println("服务器启动,绑定12345端口号");
		
		//4.读取文件名
		while(true) {
			final Socket socket = server.accept();					//接受请求
			new Thread() {
				public void run() {
					try {
						InputStream is = socket.getInputStream();
						BufferedReader br = new BufferedReader(new InputStreamReader(is));
						PrintStream ps = new PrintStream(socket.getOutputStream());
						String fileName = br.readLine();
						
						//5.判断文件是否存在, 将结果发回客户端
						File dir = new File("update");
						dir.mkdir();								//创建文件夹
						File file = new File(dir,fileName);			//封装成File对象
						
						if(file.exists()) {							//如果服务器已经存在这个文件
							ps.println("存在");						//将存在写给客户端
							socket.close();							//关闭socket
							return;
						}else {
							ps.println("不存在");
						}
						
						//8.定义FileOutputStream, 从网络读取数据, 存储到本地
						FileOutputStream fos = new FileOutputStream(file);
						byte[] arr = new byte[8192];
						int len;
						
						while((len = is.read(arr)) != -1) {
							fos.write(arr, 0, len);
						}
						
						fos.close();
						socket.close();
					} catch (IOException e) {
						
						e.printStackTrace();
					}
				}
			}.start();
		}
	}

反射

类的加载概述和加载时机

A:类的加载概述
- 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
- 加载
  - 就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
- 连接
  - 验证是否有正确的内部结构，并和其他类协调一致
  - 准备负责为类的静态成员分配内存，并设置默认初始化值
  - 解析将类的二进制数据中的符号引用替换为直接引用
- 初始化就是我们以前讲过的初始化步骤
B:加载时机
- 创建类的实例
- 访问类的静态变量，或者为静态变量赋值
- 调用类的静态方法
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类

类加载器的概述和分类

A:类加载器的概述
- 负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
B:类加载器的分类
- Bootstrap ClassLoader 根类加载器
- Extension ClassLoader 扩展类加载器
- Sysetm ClassLoader 系统类加载器
C:类加载器的作用
- Bootstrap ClassLoader 根类加载器
  - 也被称为引导类加载器，负责Java核心类的加载
  - 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
- Extension ClassLoader 扩展类加载器
  - 负责JRE的扩展目录中jar包的加载。
  - 在JDK中JRE的lib目录下ext目录
- Sysetm ClassLoader 系统类加载器
  - 负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

反射概述

A:反射概述
- JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
- 对于任意一个对象，都能够调用它的任意一个方法和属性；
- 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
- 要想解剖一个类,必须先要获取到该类的字节码文件对象。
- 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

B:三种方式

a:Object类的getClass()方法,判断两个对象是否是同一个字节码文件
b:静态属性class,锁对象
c:Class类中静态方法forName(),读取配置文件

	public static void main(String[] args) throws ClassNotFoundException {
		Class clazz1 = Class.forName("com.heima.bean.Person");
		Class clazz2 = Person.class;
		
		Person p = new Person();
		Class clazz3 = p.getClass();
		
		System.out.println(clazz1 == clazz2);
		System.out.println(clazz2 == clazz3);
	}

Class.forName()读取配置文件举例

榨汁机(Juicer)榨汁的案例

分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)

  public class Demo2_Reflect {

  	/**
  	 * 榨汁机(Juicer)榨汁的案例
  	 * 分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)
  	 * @throws Exception 
  	 */
  	public static void main(String[] args) throws Exception {
  		/*Juicer j = new Juicer();
  		//j.run(new Apple());
  		j.run(new Orange());*/
  		BufferedReader br = new BufferedReader(new FileReader("config.properties"));	//创建输入流对象,关联配置文件
  		Class<?> clazz = Class.forName(br.readLine());									//读取配置文件一行内容,获取该类的字节码对象
  		Fruit f = (Fruit) clazz.newInstance();											//通过字节码对象创建实例对象
  		Juicer j = new Juicer();
  		j.run(f);
  	}
  
  }
  interface Fruit {
  	public void squeeze();
  }
  
  class Apple implements Fruit {
  	public void squeeze() {
  		System.out.println("榨出一杯苹果汁儿");
  	}
  }
  
  class Orange implements Fruit {
  	public void squeeze() {
  		System.out.println("榨出一杯桔子汁儿");
  	}
  }
  
  class Juicer {
  	public void run(Fruit f) {
  		f.squeeze();
  	}
  
  }

通过反射获取带参构造方法并使用

Constructor

Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(“张三”,20)方法创建对象

	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		//Person p = (Person) clazz.newInstance();				通过无餐构造创建对象
		//System.out.println(p);
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);					//通过有参构造创建对象
		System.out.println(p);
	}

通过反射获取成员变量并使用

Field

Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField(“name”)方法获取,通过set(obj, “李四”)方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值

	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);						//通过有参构造创建对象
		
		//Field f = clazz.getField("name");								//获取姓名字段
		//f.set(p, "李四");												//修改姓名的值
		Field f = clazz.getDeclaredField("name");						//暴力反射获取字段
		f.setAccessible(true);											//去除私有权限
		f.set(p, "李四");	
		
		System.out.println(p);
	}

通过反射获取方法并使用

Method

Class.getMethod(String, Class…) 和 Class.getDeclaredMethod(String, Class…)方法可以获取类中的指定方法,调用invoke(Object, Object…)可以调用该方法,Class.getMethod(“eat”) invoke(obj) Class.getMethod(“eat”,int.class) invoke(obj,10)

	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);						//通过有参构造创建对象
		
		Method m = clazz.getMethod("eat");								//获取eat方法
		m.invoke(p);
		
		Method m2 = clazz.getMethod("eat", int.class);					//获取有参的eat方法
		m2.invoke(p, 10);
	}

通过反射越过泛型检查

ArrayList的一个对象，在这个集合中添加一个字符串数据，如何实现呢？
泛型只在编译期有效,在运行期会被擦除掉

	public static void main(String[] args) throws Exception {
		ArrayList<Integer> list = new ArrayList<>();
		list.add(111);
		list.add(222);
		
		Class clazz = Class.forName("java.util.ArrayList");				//获取字节码对象
		Method m = clazz.getMethod("add", Object.class);				//获取add方法
		m.invoke(list, "abc");
		
		System.out.println(list);
		
	}

通过反射写一个通用的设置某个对象的某个属性为指定的值

public void setProperty(Object obj, String propertyName, Object value) throws Exception {
	Class clazz = obj.getClass();					//获取字节码对象
	Field f = clazz.getDeclaredField(propertyName);	//暴力反射获取字段
	f.setAccessible(true);							//去除权限
	f.set(obj, value);
}

练习

已知一个类，定义如下：

package cn.itcast.heima;

 public class DemoClass {
 	public void run() {
 		System.out.println("welcome to heima!");
 	}
 }

(1) 写一个Properties格式的配置文件，配置类的完整名称。
(2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射的方式运行run方法。

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader("xxx.properties"));	//创建输入流关联xxx.properties
		Class clazz = Class.forName(br.readLine());									//读取配置文件中类名,获取字节码对象
		
		DemoClass dc = (DemoClass) clazz.newInstance();								//通过字节码对象创建对象
		dc.run();
	}

动态代理的概述和实现

A:动态代理概述
- 代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
- 举例：春节回家买票让人代买
- 动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
- 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
- public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
- 最终会调用InvocationHandler的方法
- InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

枚举

A:枚举概述
- 是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。
B:回想单例设计模式：单例类是一个类只有一个实例
- 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。
自己实现枚举类

public class Week {
	
	public static final Week MON = new Week();
	public static final Week TUE = new Week();
	public static final Week WED = new Week();
	
	private Week(){}						//私有构造,不让其他类创建本类对象
}

public class Week2 {
	
	public static final Week2 MON = new Week2("星期一");
	public static final Week2 TUE = new Week2("星期二");
	public static final Week2 WED = new Week2("星期三");
	
	private String name;
	private Week2(String name){
		this.name = name;
	}						//私有构造,不让其他类创建本类对象
	public String getName() {
		return name;
	}
	
	
}


public abstract class Week3 {
	
	public static final Week3 MON = new Week3("星期一") {
		public void show() {
			System.out.println("星期一");
		}
	};
	public static final Week3 TUE = new Week3("星期二"){
		public void show() {
			System.out.println("星期二");
		}
	};
	public static final Week3 WED = new Week3("星期三"){
		public void show() {
			System.out.println("星期三");
		}
	};
	
	private String name;
	private Week3(String name){
		this.name = name;
	}						//私有构造,不让其他类创建本类对象
	public String getName() {
		return name;
	}
	
	public abstract void show();
}

通过enum实现枚举
```
public enum Week {
	MON,TUE,WED;
}
```

public enum Week2 {
	MON("星期一"),TUE("星期二"),WED("星期三");
	
	private String name;
	private Week2(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	public String toString() {
		return name;
	}
}


public enum Week3 {
	MON("星期一"){
		public void show() {
			System.out.println("星期一");
		}
	},TUE("星期二"){
		public void show() {
			System.out.println("星期二");
		}
	},WED("星期三"){
		public void show() {
			System.out.println("星期三");
		}
	};
	
	private String name;
	private Week3(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	public abstract void show();
	
}

注意事项
- 定义枚举类要用关键字enum
- 所有枚举类都是Enum的子类
- 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
- 枚举类可以有构造器，但必须是private的，它默认的也是private的。
- 枚举类也可以有抽象方法，但是枚举项必须重写该方法
- 枚举在switch语句中的使用

枚举类的常见方法

int ordinal()
int compareTo(E o)
String name()
String toString()
T valueOf(Class type,String name)
values()
- 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

	public static void main(String[] args) {
		//demo1();
//		Week2 mon = Week2.valueOf(Week2.class, "MON");		//通过字节码对象获取枚举项
//		System.out.println(mon);
		
		Week2[] arr = Week2.values();
		for (Week2 week2 : arr) {
			System.out.println(week2);
		}
	}

	public static void demo1() {
		Week2 mon = Week2.MON;
		Week2 tue = Week2.TUE;
		Week2 wed = Week2.WED;
		
		/*System.out.println(mon.ordinal());				//枚举项都是有编号的
		System.out.println(tue.ordinal());
		System.out.println(wed.ordinal());
		
		System.out.println(mon.compareTo(tue));			//比较的是编号
		System.out.println(mon.compareTo(wed));*/
		
		System.out.println(mon.name()); 				//获取实例名称
		System.out.println(mon.toString()); 			//调用重写之后的toString方法
	}

JDK5特性

1,自动拆装箱
2,泛型
3,可变参数
4,静态导入
5,增强for循环
6,互斥锁
7,枚举

JDK7特性

A:二进制字面量
B:数字字面量可以出现下划线
C:switch 语句可以用字符串
D:泛型简化,菱形泛型
E:异常的多个catch合并,每个异常用或|
F:try-with-resources 语句

JDK8特性

接口中可以定义有方法体的方法,如果是非静态,必须用default修饰
如果是静态的就不用了

  class Test {
  	public void run() {
  		（final） int x = 10; 	//JDK8中系统默认添加final
  							//局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
  							//因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
  		class Inner {
  			public void method() {
  				System.out.println(x);
  			}
  		}
  
  		Inner i = new Inner();
  		i.method();
  	}
  	
  }

多线程