JAVASE基础（十四）

网络编程

一、网络通信要素

1、ip

2、端口号

规则：网络通信协议

TCP/IP

二、IP

InetAddress

package com.net.lesson01;

import java.net.InetAddress;
import java.net.UnknownHostException;

//测试IP
public class TextInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddresses1 = InetAddress.getByName("127.0.0.1");
            InetAddress inetAddresses2 = InetAddress.getByName("localhost");
            InetAddress inetAddresses3 = InetAddress.getLocalHost();
            System.out.println(inetAddresses1);
            System.out.println(inetAddresses2);
            System.out.println(inetAddresses3);
            //查询网站ip地址
            InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress);
            //常用方法
            //System.out.println(inetAddresses3.getAddress());
            System.out.println(inetAddresses3.getCanonicalHostName());
            System.out.println(inetAddresses3.getHostAddress());//ip
            System.out.println(inetAddresses3.getHostName());//域名，或自己电脑名字

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

三、端口

表示计算机上的一个程序的进程

1.不同进程有不同端口，用来区分软件

2.被规定0~65535

3.TCP/UDP：65535*2 单个协议下，端口号不能重复

4.端口分类：

公有端口：0~1023

HTTP:80 HTTPS:443 FTP:21 Telent:23

程序注册端口：1024~49151，分配给用户或程序

Tomcat:8080 MySQL:3306 Oracle:1521

动态、私有端口：49152~65535

netstat -ano:查看所有端口

package com.net.lesson01;

import java.net.InetSocketAddress;

public class TextInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());//地址
        System.out.println(socketAddress.getPort());//端口

        

    }
}

四、通信协议

五、TCP

客户端

(1)连接服务器 Socket

(2)发送信息

package com.net.lesson02;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;

        try {
            //需要知道服务器地址
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //创建一个socket连接
            socket = new Socket(serverIP,port);
            //发送消息 io流
            os = socket.getOutputStream();
            os.write("hello,world".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

服务端

(1)建立服务的端口 SerrverSocket

(2)等待用户的连接 accept

(3)接收用户的消息

package com.net.lesson02;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //需要有一个地址
            serverSocket = new ServerSocket(9999);
            //等待客户端连接
            socket = serverSocket.accept();
            //读取客户端消息
            is = socket.getInputStream();
            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }

            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

文件上传

服务端

package com.net.lesson02;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //创建服务端口
        ServerSocket serverSocket = new ServerSocket(9000);
        //监听客户端连接
        Socket socket = serverSocket.accept();//阻塞式监听，会一直等待客户端连接
        // 获取输入流
        InputStream is = socket.getInputStream();
        //文件输出
        FileOutputStream fos = new FileOutputStream("receive");
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        //通知客户端接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes());

        //关闭
        fos.close();
        is.close();
        socket.close();

    }

客户端

package com.net.lesson02;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //创建一个输出流
        OutputStream os = socket.getOutputStream();
        //读取文件
        FileInputStream fis = new FileInputStream(new File("E:\\JAVA_SE\\基础语法\\src\\com\\net\\lesson02\\JAVA.png"));
        //写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器我已经传输完了
        socket.shutdownOutput();

        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

        //关闭
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();

    }
}

六、Tomcat

服务端

自定义 S

Tomcat服务器 S

客户端

自定义 C

浏览器 B

七、UDP

不用连接，需要知道对方地址

发送端

package com.net.lesson02;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

//不需要连接服务器
public class UDPClientDemo01 {
    public static void main(String[] args) throws Exception {
        //建立一个Socket
        DatagramSocket socket = new DatagramSocket();


        //创建包
        String msg = "hello,world";


        //发给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        //数据，数据长度，发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length,localhost,port);

        //发送包
        socket.send(packet);

        //关闭
        socket.close();

    }

}

接收端

package com.net.lesson02;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPSeverDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);

        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        //关闭连接
        socket.close();

    }
}

循环发送消息

package com.net.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(8080);

        //准备数据 控制台读取System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true){
            String data = reader.readLine();
            byte[] dates = data.getBytes();
            DatagramPacket packet = new DatagramPacket(dates,0,dates.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

循环接收消息

package com.net.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReveiceDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(6666);

        while (true){
            //准备接收
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet);//阻塞式接收包裹

            //断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);
            if (receiveData.equals("bye")){
                break;
            }


        }

        socket.close();

    }
}

在线咨询：两个人都可以是发送方，也都可以是接收方

package com.net.chat;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

package com.net.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new  Thread(new TalkSend(5555,"localhost",8888)).start();
        new  Thread(new TalkReceive(9999,"学生")).start();
    }
}

package com.net.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromIP, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void run() {

        while (true){
            String data = null;
            try {
                data = reader.readLine();
                byte[] dates = data.getBytes();
                DatagramPacket packet = new DatagramPacket(dates,0,dates.length,new InetSocketAddress(this.toIP,this.toPort));

                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }

            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        socket.close();
    }
}

package com.net.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable {

    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {

            try {
                //准备接收
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);//阻塞式接收包裹

                //断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom+":"+ receiveData);
                if (receiveData.equals("bye")) {
                    break;
                }

            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

八、URL

统一资源定位符：定位资源的，定位互联网上的某一个资源

package com.net.lesson03;

import java.net.MalformedURLException;
import java.net.URL;

public class UrlDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=kuangshen&password=123");
        System.out.println(url.getProtocol());//协议
        System.out.println(url.getHost());//主机IP
        System.out.println(url.getPort());//端口
        System.out.println(url.getPath());
        System.out.println(url.getFile());
        System.out.println(url.getQuery());

    }
}

多线程

一、Thread

继承Thread类具有多线程能力

启动线程：子类对象.start()

不建议使用：避免OOP单继承局限性

package com.thread;

//创建线程方式一：继承Thread类，重写run（）方法,调用start开启线程
//线程开启不一定立即执行，由CPU调度
public class TextThread01 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("helloworld");
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TextThread01 textThread01 = new TextThread01();
        //调用start（）方法开启线程
        textThread01.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(i);
        }
    }
}

二、Runnable

实现接口Runnable具有多线程能力

启动线程：传入目标对象+Thread对象.start()

推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

package com.thread;

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入eunnable接口实现类，调用start方法
public class TextThread02 implements Runnable{

    @Override
    public void run() {

        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("helloworld");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TextThread02 textThread02 = new TextThread02();
        //创建线程对象,通过线程对象来开启线程，代理
//        Thread thread = new Thread(textThread02);
//        thread.start();
        new Thread(textThread02).start();



        for (int i = 0; i < 20; i++) {
            System.out.println(i);
        }
    }
}

案例：龟兔赛跑

package com.thread;

public class Race implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }{
            if (steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }

}

三、Callable

实现Callable接口，需要返回值类型

重写call方法，需要抛出异常

四、静态代理

package com.thread;

//静态代理模式：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：代理对象可以做好多真实对象做不到的事情，真实对象专注做自己的是事

public class StaticProxy {

    public static void main(String[] args) {

        WweddingCompany wweddingCompany = new WweddingCompany(new You());
        wweddingCompany.HappyMarry();

    }

}

interface Marry{

    void HappyMarry();

}

//真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚");
    }
}

//代理角色
class WweddingCompany implements Marry{

    private Marry target;

    public WweddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {

        before();
        this.target.HappyMarry();
        after();

    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

五、Lamda表达式

实质属于函数式编程的概念

避免匿名内部类定义过多

去掉一些没有意义的代码，只留下核心逻辑

总结：1.lambda表达式只能有一行代码的情况下才能简化成为一行，若有多行，则需要加花括号    
     2.前提是接口为函数式接口（接口中只有一个方法）
     3.多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号

package com.thread;
/*
推导Lamda表达式
 */
public class TextLambda01 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }

        like = new Like3();
        like.lambda();

        //5.匿名内部类,没有类名，必须借助接口或父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.lambda简化
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();

    }

}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

package com.thread;

public class TextLambda02 {
    public static void main(String[] args) {

        ILove love = null;

//        ILove love = (int a)->{
//            System.out.println("i love lambda"+a);
//        };
//
//        love = (a)->{
//            System.out.println("i love lambda"+a);
//        };

        love = a -> {
            System.out.println("i love lambda"+a);
        };

        love = a-> System.out.println("i love lambda"+a);
        love.love(520);

    }
}

interface ILove{
    void love(int a);
}

六、线程状态

创建状态：线程对象一旦创建就进入新生状态

就绪状态：调用start（）方法，线程就绪，但不意味着立即调度执行

运行状态

阻塞状态：当调用sleep，wait或同步锁定，阻塞，阻塞解除，重新进入就绪状态

死亡状态：线程中断或结束，一旦进入死亡状态，就不能再次启动

线程停止：

package com.thread;

//测试停止线程
//1.建议线程正常停止->利用次数，不建议死循环
//2.建议使用标志位->设置一个标志位
//3.不要使用stop或destroy等过时或JDK不建议使用的方法
public class TextStop implements Runnable{

    //设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run···Thread"+i++);
        }
    }

    //设置一个公开方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TextStop textStop = new TextStop();

        new Thread().start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //调用stop方法切换标志位，让线程停止
                textStop.stop();
                System.out.println("线程该停止了");
            }
        }

    }

}

线程休眠：

sleep(时间)指定当前线程阻塞的毫秒数

sleep时间达到后线程进入就绪状态

sleep可以模拟网络延时，倒计时等

每个对象都有一个锁，sleep不会释放锁

package com.thread;

//模拟倒计时
public class TextSleep2 {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }

    }

}

线程礼让：

礼让线程，让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让cpu重新调度，礼让不一定成功

package com.thread;

//测试礼让线程
public class TextYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行：

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

package com.thread;

public class TextJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {

        //启动线程
        TextJoin textJoin = new TextJoin();
        Thread thread = new Thread(textJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if (i==200){
                thread.join();
            }
            System.out.println("main"+i);
        }

    }

}

观测线程状态

package com.thread;

public class TextState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("000");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);
        
        //只要线程不中止，就一直输出状态
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(1000);
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }

    }
}

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该先从哪个线程来执行

优先级低只意味获得调度概率低

package com.thread;

//测试线程优先级
public class TextPriority {

    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();


    }

}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

线程分为用户线程和守护线程

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

package com.thread;

//测试守护线程
//上帝守护你
public class TextDemo {
    public static void main(String[] args) {
        God god = new God();
        Youu youu = new Youu();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认false，表示用户线程

        thread.start();
        new Thread(youu).start();

    }

}

//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑你");
        }
    }
}


//你
class Youu implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心活着");
        }
        System.out.println("goodbye,world");
    }
}

七、线程同步

并发：同一个对象被多个线程操作

由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁，存在问题：

1.一个线程持有锁会导致其他所有需要此锁的线程挂起；

2.在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；

3.如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题.

synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能继续执行

缺陷：若将一个大的方法申明为synchronized将会影响效率

package com.thread;

//线程不安全
public class UnSafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"1").start();
        new Thread(station,"2").start();
        new Thread(station,"3").start();

    }

}

class BuyTicket implements Runnable{

    private int ticketNums = 100;
    boolean flag = true;

    @Override
    public void run() {

        while (flag){
            buy();
        }

    }

    private synchronized void buy(){
        //判断是否有票
        if (ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);

    }

}

同步块

synchronized(Obj){}

Obj称之为同步监视器,Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[反射中讲解]

同步监视器的执行过程1.第一个线程访问，锁定同步监视器，执行其中代码.2.第二个线程访问，发现同步监视器被锁定，无法访问.3.第一个线程访问完毕，解锁同步监视器.4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

package com.thread;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TextJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都执行的情形.某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题.

死锁的四个必要条件：

1.互斥条件：一个资源每次只能被一个进程使用。

2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

3.不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。

4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

package com.thread;

//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
    public static void main(String[] args) {

        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();

    }
}

//口红
class LipStick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{

    //需要的资源只有一份,用static保证
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {

        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //化妆，互相持有对方的锁
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipStick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);

                synchronized (mirror){//一秒钟后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }

            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);

                synchronized (lipStick){//两秒钟后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }

            }


        }
    }

}

解决：

package com.thread;

//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
    public static void main(String[] args) {

        Makeup g1 = new Makeup(0,"灰姑凉");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();

    }
}

//口红
class LipStick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{

    //需要的资源只有一份,用static保证
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {

        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //化妆，互相持有对方的锁
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipStick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);


                }
            synchronized (mirror){//一秒钟后想获得镜子
                System.out.println(this.girlName+"获得镜子的锁");

            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);


                }
            synchronized (lipStick){//两秒钟后想获得口红
                System.out.println(this.girlName+"获得口红的锁");

            }


        }
    }

}

Lock

从JDK 5.0开始，Java提供了更强大的线程同步机制—通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

package com.thread;

import java.util.concurrent.locks.ReentrantLock;

public class TextLock {

    public static void main(String[] args) {
        TextLock2 textLock2 = new TextLock2();

        new Thread(textLock2).start();
        new Thread(textLock2).start();
        new Thread(textLock2).start();

    }

}

class TextLock2 implements Runnable{

    int ticketNums = 10;

    //定义lock锁
    private ReentrantLock lock = new ReentrantLock();


    @Override
    public void run() {
        while (true){

            try {
                lock.lock();//加锁
                if (ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }

        }
    }
}

synchronized与Lock的对比

Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)synchronized是隐式锁，出了作用域自动释放

Lock只有代码块锁，synchronized有代码块锁和方法锁

使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)

优先使用顺序：Lock>同步代码块(已经进入了方法体，分配了相应资源)>同步方法(在方法体之外)

八、线程协作

管程法：

package com.thread;

//测试：生产者消费者模型->利用缓冲区解决：管程法

public class TextPC {

    public static void main(String[] args) {

        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();

    }

}

//生产者
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container){
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container){
        this.container = container;
    }

    //消费

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken{
    int id;//产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{

    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计算器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //容器满了需要等待消费者消费
        if (count==chickens.length){
            //通知消费者消费，生产者等待

        }
        //如果没满，就需要丢入产品
        chickens[count]=chicken;
        count++;

        //可以通知消费者消费了

    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if (count==0){
            //等待生产者生产，消费者等待

        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完，通知生产者生产

        return chicken;
    }
}

信号灯法：

九、线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：提高响应速度(减少了创建新线程的时间)

降低资源消耗(重复利用线程池中线程，不需要每次都创建)

便于线程管理(…)：（1）corePoolSize：核心池的大小（2）maximumPoolSize：最大线程数（3）keepAliveTime：线程没有任务时最多保持多长时间后会终止

十、总结：

package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadNew {
    public static void main(String[] args) {

        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("Mythread2");
    }
}

class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        return 100;
    }
}

注解和反射

一、注解

是从JDK5.0开始引入的新技术.

Annotation的作用：（1）不是程序本身，可以对程序作出解释.(这一点和注释(comment)没什么区别）（2）可以被其他程序(比如：编译器等)读取.

Annotation的格式：注解是以"@注释名"在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”.

Annotation在哪里使用？

可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

1、内置注解

@Override：定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明.

@Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不推荐程序员使用这样的元素，通常是因为它很危险或者存在更好的选择.

@SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息.

与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的使用就好了.

@SuppressWarnings(“all”)

@SuppressWarnings("unchecked”)

@SuppressWarnings(value=(“unchecked”,“deprecation”)

2、元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明.

这些类型和它们所支持的类在java.lang.annotation包中可以找到.(@Target,@Retention，@Documented,@Inherited)

@Target：用于描述注解的使用范围(即：被描述的注解可以用在什么地方）

@Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期(SOURCE<CLASS<RUNTIME)

@Document：说明该注解将被包含在javadoc中

@Inherited：说明子类可以继承父类中的该注解

3、自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

分析：

@interface用来声明一个注解，格式：public@interface注解名(定义内容)

注解的参数：参数类型+参数名（）

其中的每一个方法实际上是声明了一个配置参数.

方法的名称就是参数的名称.

返回值类型就是参数的类型(返回值只能是基本类型，Class，String,enum).

可以通过default来声明参数的默认值.

如果只有一个参数成员，一般参数名为value.

注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值.

二、反射

Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c=Class.forName(“java.lang.String”))

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射

Java反射机制提供的功能

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有的成员变量和方法

在运行时获取泛型信息

在运行时调用任意一个对象的成员变量和方法

在运行时处理注解

生成动态代理

优点：可以实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

package com.reflection;

public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("com.reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.reflection.User");
        Class c3 = Class.forName("com.reflection.User");
        Class c4 = Class.forName("com.reflection.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());

    }
}

//实体类 pojo/entity
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

1、Class类

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

Class本身也是一个类

Class对象只能由系统建立对象

一个加载的类在JVM中只会有一个Class实例

一个Class对象对应的是一个加载到JVM中的一个.class文件

每个类的实例都会记得自己是由哪个Class实例所生成

通过Class可以完整地得到一个类中的所有被加载的结构

Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2、获取Class类的实例

a)若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。Class clazz=Person.class;

b)已知某个类的实例，调用该实例的getClass()方法获取Class对象Class clazz=person.getClass();

c)已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出

ClassNotFoundExceptionClass clazz=Class.forName("demo01.Student);

d)内置基本数据类型可以直接用类名.Type

e)还可以利用ClassLoader

package com.reflection;

//测试Class类的创建方式有哪些
public class Text02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是"+person.name);

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //方式二：forname获得
        Class c2 = Class.forName("com.reflection.Student");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得
        Class<Student> c3 = Student.class;
        System.out.println(c3.hashCode());

        //方式四：基本内置的包装类都有一个Type属性
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4);

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}

class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";

    }
}

class Teacher extends Person{
    public Teacher(){
        this.name = "老师";

    }
}

package com.reflection;

import java.lang.annotation.ElementType;

//所有类型的Class
public class Test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//一维数组
        Class c4 = int[][].class;//二维数组
        Class c5 = Override.class;//注解
        Class c6 = ElementType.class;//枚举
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9 = Class.class;//Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一样，就是同一个Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }
}

3、类的加载与ClassLoader的理解

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象.

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

(1)验证：确保加载的类信息符合JVM规范，没有安全方面的问题。

(2)准备：正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

(3)解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

(1)执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。

(2)当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

(3)虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6b6Zb3Ey-1647928727185)(file:///C:\Users\de’l’l\Documents\Tencent Files\1591841900\Image\C2C\15192EC39891896D08224F0284073386.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ls1OeYT-1647928727186)(file:///C:\Users\de’l’l\Documents\Tencent Files\1591841900\Image\C2C\F5B7DFA100601A46E528AC54D58FF907.jpg)]

package com.reflection;

public class Test04 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);

        /*
        1.加载到内存，会产生一个类对应Class对象
        2.链接，链接结束后m=0
        3.初始化
        <clinit>(){
                System.out.println("A类静态代码块初始化");
                m = 300;
                m = 100;
        }
        m = 100

         */

    }
}

class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rnWiOtXa-1647928727186)(file:///C:\Users\de’l’l\Documents\Tencent Files\1591841900\Image\C2C\1B0E47116B7CD47B8AB2E4237C2F473E.jpg)]

4、什么时候会发生类初始化？

类的主动引用(一定会发生类的初始化)

(1)当虚拟机启动，先初始化main方法所在的类

(2)new一个类的对象

(3)调用类的静态成员(除了final常量)和静态方法

(4)使用java.lang.reflect包的方法对类进行反射调用

(5)当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用(不会发生类的初始化)

(1)当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化

(2)通过数组定义类引用，不会触发此类的初始化

(3)引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

package com.reflection;

//测试类什么是初始化
public class Test05 {
    static {
        System.out.println("main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        //Son son = new Son();

        //反射也会产生主动引用
        //Class.forName("com.reflection.Son");

        //不会产生类的引用的方法
        //System.out.println(Son.b);

        //Son[] array = new Son[5];

        //System.out.println(Son.M);

    }
}

class Father{
    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
    }
    static int m = 100;
    static final int M = 1;
}

5、类加载器

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZuazjNMI-1647928727187)(file:///C:\Users\de’l’l\Documents\Tencent Files\1591841900\Image\C2C\C0D50235FCC49B05778A7E3C8B584280.jpg)]

package com.reflection;

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器-->根加载器（c/c++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.reflection.Test06").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置类是哪个加载器加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

    }
}

6、获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field、Method,Constructor、Superclass、Interface Annotation

实现的全部接口

所继承的父类

全部的构造器

全部的方法

全部的Field

注解

package com.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类的信息
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.reflection.User");

        //获得类的名字
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());

        //获得类的属性
        Field[] fields = c1.getFields();//只能找到public属性

        fields = c1.getDeclaredFields();//找到全部属性
        for (Field field : fields) {
            System.out.println(field);
        }

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println("正常的:"+method);
        }

         methods = c1.getDeclaredMethods();//获得本类的所有方法（包括私有方法）
        for (Method method : methods) {
            System.out.println("getDeclaredMethods:"+method);
        }

        //获得指定方法
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得指定构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

    }
}

7、有了Class对象，能做什么？

创建类的对象：调用Class对象的newlnstance)方法

1）类必须有一个无参数的构造器。

2)类的构造器的访问权限需要足够

思考?难道没有无参的构造器就不能创建对象了吗？只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

步骤如下：

1)通过Class类的getDeclaredConstructor(Class····parameterTypes)取得本类的指定形参类型的构造器

2)向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数

3)通过Constructor实例化

调用指定的方法

通过反射，调用类中的方法，通过Method类完成。

1.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。2.之后使用Object invoke(Object obj，Object[]args)进行调用，并向方法中传递要设置的obj对象的参数信息

Object invoke(Object obj,Object…args)

(1)Object对应原方法的返回值，若原方法无返回值，此时返回null

(2)若原方法若为静态方法，此时形参Object obj可为null

(3)若原方法形参列表为空，则Object[]args为null

(4)若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

setAccessible

(1) Method和Field、Constructor对象都有setAccessible()方法。

(2)setAccessible作用是启动和禁用访问安全检查的开关。

(3)参数值为true则指示反射的对象在使用时应该取消Java语言访问检查：

提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。

使得原本无法访问的私有成员也可以访问。

(4)参数值为false则指示反射的对象应该实施Java语言访问检查。

package com.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//动态地创建对象，通过反射
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("com.reflection.User");

        //构造一个对象
        User user = (User) c1.newInstance();//本质是调用类的无参构造
        System.out.println(user);

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        User user2 = (User) constructor.newInstance("du",001,18);
        System.out.println(user2);

        //通过反射调用普通方法
        User user3 = (User) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke  激活
        setName.invoke(user3,"你好");
        System.out.println(user3.getName());

        //通过反射操作属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //不能直接操作私有属性，需要关闭程序安全检测，属性或方法的setAccessible(true)
        name.setAccessible(true);

        name.set(user4,"你好2");
        System.out.println(user4.getName());

    }
}

8、反射操作泛型

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除

为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.

ParameterizedType:表示一种参数化类型，比如Collection

GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardType:代表一种通配符类型表达式

9、获取注解信息

package com.reflection;

import java.lang.annotation.*;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

//练习反射操作注解
public class Test09 {

    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.reflection.Test09.Student2");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的value的值
        TableDu tableDu = (TableDu) c1.getAnnotation(TableDu.class);
        String value = tableDu.value();
        System.out.println(value);

    }

}

@TableDu("db_student")
class Student2{

    @FieldDu(columnName = "db_id",type = "int",length =10)
    private int id;
    @FieldDu(columnName = "db_age",type = "int",length =10)
    private int age;
    @FieldDu(columnName = "db_name",type = "varchar",length =10)
    private String name;

    public Student2() {
    }

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableDu{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldDu{
    String columnName();
    String type();
    int length();
}