java基础_笔记4（线程、反射、类加载器、注解）

已于 2024-05-26 22:14:45 修改
阅读量87 收藏
点赞数
文章标签： java jvm 开发语言
于 2022-09-19 13:41:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64589497/article/details/126844008
版权

一、线程

1.1、线程的概念

  1. 程序就是一段代码

  2. 进程就是一个应用软件的执行

  3. 线程就是进程的一部分，一个进程可以启动多个线程

  4. 对于java程序来说，主启动就会启动jvm，也就是一个进程 。

  5. 然后jvm会启动一个主线程来调用main方法

  6. 同时启动一个垃圾回收线程，最简单的也有两个线程并发

1.2、线程简单的内存模型

在jdk一点八之前基本模型如下三个部分：

每个线程都会单开一个栈，开启之后会从第一个方法开始执行，将方法的栈帧压入栈中，然后方法中如果调用了新的方法会将这个新的方法的栈帧继续压入栈中。如果创建对象，数组等就会将这些对象创建在共享的堆内存中

  1. 栈：存放各个方法的栈帧

  2. 堆：用于存放对象实例、实例变量、数组、垃圾回收管理内存区域解决数据存储问题

  3. 方法区:存放类信息、常量池、静态变量等。

  4. ps：方法区分为永久代和元空间，在jdk8之前方法区采用永久代实现，在jvm中存储，8之后由元空间实现，由操作系统管理，可以自动扩容解决了内存溢出的问题。

  5. 进程之间内存不共享，同进程中线程共享堆和方法区

 

线程的使用：

ps：使用集成类的方式的时候，创建线程对象可以直接创建自定义的类对象，或者使用java原有的线程对象，构造方法传递新的类对象；

但是使用实现接口的时候只能创建java原有的线程对象，然后new类传递进构造方法 

第一种方式：继承Thread类（注意重写run方法）


public class thread_1 {
    public static void main(String[] args) {
        myThread myThread=new myThread();
//        myThread.run();   直接启动该方法的话就不会开启一个新的线程，会直接执行该方法
        myThread.start();//调用该方法就会直接开启一个新的线程，然后java程序就会向下继续执行
                         //开启新的线程本质上就是开启一个新的栈空间，然后方法就结束了，启动
                         //成功的线程会自动调用run方法
        for (int i=1;i<100;i++){
            System.out.println("主线程"+i);
        }
    }
}


class myThread extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            System.out.println("副线程"+i);
        }
    }
        }

来说一下执行结果：主副线程交替不规则执行，说明jvm虚拟机再并发（两个线程一起执行，cpu在线程间切换）执行。

第二种方式：实现Runnable接口，实现run方法

然后直接创建线程对象的时候放入该类

该方法使用匿名内部类的形式直接实现接口之后放入线程对象的构造方法里

public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    System.out.println("副线程"+i);
                }
            }
        });
        thread.start();
        for (int i=0;i<100;i++){
            System.out.println("main线程"+i);
        }

    }

 第二种方式更加实用，因为类可以实现多个接口，但是不可以集成多个类。

1.3、线程的生命周期 

新建状态：刚创建出来的线程对象

调用start（）↓

  1. 就绪状态：又称为可运行状态，表示当前线程具有抢夺cpu时间片的权利，当一个线程抢夺到时间片之后就会执行run方法，进入运行状态。

  2. 阻塞状态：当一个线程遇到语塞事件，例如需要睡眠或者输入。就会放弃占用的时间片，回到就绪之后需要重新抢夺。

  3. 运行状态：run方法的开始执行标志着线程运行，当占有的时间片用完之后就会重新回到就绪状态等待下次抢到cpu，运行完所有的程序之后会进入死亡状态

线程的睡眠和打断：

  1. 线程的睡眠一般使用sleep方法，

  2. 线程的打断可以使用直接关掉线程的stop，但是不推荐

  3. 或者使用触发异常信息的interrupt（）方法

  4. 也可以在类中声明一个变量的形式来改变变量打断睡眠

package Thread;

public class Thread_sleep {
    public static void main(String[] args) {
        Thread thread=new Thread(new myrun());//创建线程对象
        thread.start();//执行线程，开辟新的栈空间
//thread.currentThread()在这里获取的线程对象是主线程，哪怕使用的是副线程调用的。
        for (int i=0;i<3;i++){
            System.out.println("主线程"+i);
            try {
                Thread.sleep(1000);//执行一个停顿一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //thread.stop();//过时了，因为该方法会直接停掉该线程，然后会有语句无法执行
       thread.interrupt();//让该线程的睡眠出错执行catch方法，这样达到终止睡眠的方法
    }
}
class myrun implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("实现Runnable"+ Thread.currentThread().getName());
//通过Thread.currentThread()调用当前的线程对象，获取到线程对象可以调用方法
    }
}

1.4、线程的调度

常见的线程调度模型：

  1. 抢占式线程调度：哪个线程的优先级比较高，哪个线程抢占cpu时间片的概率就会高点。

    java就是采用抢占式线程调度

  2. 均分式线程调度：平均分配cpu的时间片，每个线程占有的cpu的时间片是一样的

实例方法:

  1. void setPriority(int newPriority)int getPriority(）获取线程优先级最低优先级1

  2. 设置线程的优先级:

    默认优先级是5

    最高优先级10

    优先级比较高的获取CPU时间片可能会多一些。

  3. 静态方法：static void yield()

    让位方法

    暂停当前正在执行的线程对象，并执行其他线程

  4. yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。

  5. yield()方法的执行会让当前线程从“运行状态”回到"就绪状态”。

实例：

设置主副线程的优先级为5和7然后再主线程循环的时候，没十次进行一次让位，让出cpu，但是这个时候属于公平竞争，有可能还是由主线程继续抢夺到这个cpu，所以让位下一个时间片不一定会由副线程执行

package Thread;

public class Thread_Priority {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<99;i++){

                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        });
        thread.setPriority(5);
        thread.start();

        Thread.currentThread().setPriority(7);
        for (int i=0;i<99;i++){
            if (i%10==0){
                System.out.println(1);
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

join方法

将副线程合并到主线程执行，变成一个线程，之上而下执行，会阻塞原有的线程

package Thread;

public class Thread_join {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<99;i++){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        });
        thread.setPriority(1);
        thread.start();
        try {
            thread.join();//副线程和主线程合并，将副线程需要执行的内容放到这里，主线程阻塞
//                            开辟的栈并没有合并到一起
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread.currentThread().setPriority(10);
        for (int i=0;i<99;i++){
            if (i%10==0){
                System.out.println(1);
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

 1.5、线程的安全问题

线程的安全问题的三个条件：

  1. 多线程并发

  2. 共享数据

  3. 共同修改共享数据

解决方法1：线程同步机制，将线程排队，通过牺牲一部分效率的方法来保证数据安全

同步和异步的概念：

  1. 同步就是排队，异步就是并发，各执行各的互不干扰

  2. 使用synchronized关键字来保证同步线程安全

实例：

创建一个银行账户类，有一个取钱方法，然后创建一个账户对象，开辟两个线程同时执行这个取钱方法，如果不加上synchronize关键字的话可能会出现数据异常的现象，（但是也不在一定出现）

在取钱方法中加一个一秒的睡眠可以保证，两个程序必然会出现数据错误的问题

然后 synchronize的括号中传递的必须是两个线程都有的对象，可以是当对象，也可以创建一个类中的对象。

可以将snchronized关键字卸载方法上，这样默认就使用this对象，范围是整个方法体

 public int reduce(int money){
        synchronized (this){

        int after=this.balance-money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBalance(after);
        return after;
        }

    }//取钱的方法

public class Thread_error {
    public static void main(String[] args) {
        Acoount acoount=new Acoount("aaa",10000);//创建账户对象
        Thread thread1=new Thread(new myaccount(acoount));//将同一个账户传递进两个线程
        Thread thread2=new Thread(new myaccount(acoount));
        thread1.start();
        thread2.start();//开启两个线程，在执行的时候交错执行。
    }
}

class myaccount implements Runnable{

    private Acoount act;

    public myaccount(Acoount act){
        this.act=act;
    }

    @Override
    public void run() {
        act.reduce(5000);
        System.out.println(act.getName()+"取款成功"+"余额:"+act.getBalance());
    }
}

线程的执行阶段：当共享对象锁的线程进入到锁池找共享对象的对象锁的时候就会释放掉占有的cpu，进入阻塞阶段。如果找到了就会进入就绪状态，如果找不到，就在锁池中等待。

java中三种变量那个不会有线程安全问题

  1. 实例变量：在堆中

  2. 静态变量：在方法区中

  3. 局部变量：在栈中，这个不会有线程安全问题（不共享）

1.6、synchronized有三种写法

  1. 同步代码块synchronized(线程共享对象）{}

    线程共享的概念：是一种共享的引用对象，可以是类的this，可以是类中创建的其他对象，只要是共享的就行。也可以使用方法区的字符串常量池中的字符串引用。这样所有的线程都共享该方法。

    可以是（this，obj，“abc”）

  2. 在实例方法上使用synchronized

    表示共享对象一定是this

    并且同步代码块是整个方法体。

  3. 在静态方法上使用synchronized

    表示找类锁。

  1. 类锁永远只有1把。

  2. 就算创建了100个对象，那类锁也只有一把。

  3. 对象锁：1个对象1把锁，100个对象100把锁。

  4. 类锁：100个对象，也可能只是1把类锁。

理解：synchronized会使用对象锁，一个对象只有一把锁，如果一个对象有两个方法都是用了synchronized关键字，两个线程执行不同方法的时候会抢占同一把对象锁，必须等待。

同时synchronized关键字加在静态方法上会获取类锁，不会获取对象锁，类锁会让所有对象共享同一个锁，同时是静态方法才会排队类锁和对象锁不相同。

1.7、死锁

死锁的原理就是两个线程互相占用一个锁，然后继续获取 对方线程所占用的锁

public class dead_lock {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();
        //创建两个对象
        Thread t1=new mythread1(o1,o2);
        Thread t2=new mythread2(o1,o2);
        //将两个对象传递给两个线程
        t1.start();
        t2.start();
        //开启线程
        //开启线程后t1将获取到o1的对象锁，然后睡眠一秒等待o2被线程t2获取，
        //然后t1线程开始等待获取o2的对象锁，t2线程开始等待o1的对象锁，这样就发生了死锁
    }
}

class mythread1 extends Thread{
    private Object obj1;
    private Object obj2;
    public mythread1(Object obj1,Object obj2){
        this.obj1=obj1;
        this.obj2=obj2;
    }
    @Override
    public void run(){
        synchronized (obj1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2){

            }
        }
    }
}class mythread2 extends Thread{
    private Object obj1;
    private Object obj2;
    public mythread2(Object obj1,Object obj2){
        this.obj1=obj1;
        this.obj2=obj2;
    }
    @Override
    public void run(){
        synchronized (obj2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1){

            }
        }

    }
}

 在开发中使用线程安全的方法：

  1. 首先使用局部变量代替成员变量（实例变量和静态变量）

  2. 如果必须是是实例变量，那么可以创建多个对象

  3. 如果都不行就只能使用synchronized关键字了，但是会降低效率。

守护线程

线程分为两大类：

  1. 一类是用户线程

  2. 一类是守护线程（后台线程）

守护线程的特点：一般是一个死循环，当所有的用户线程结束的时候，守护线程会自动结束

main方法就是一个用户线程

守护线程一般用来：

  1. 每天零点的时候系统备份

  2. 这个时候就会用到一个定时器，可以将定时器设置为守护线程。

  3. t.setDaemon(true)守护线程


public class thread_protect {
    public static void main(String[] args) {
        Thread t=new Thread(new mythread());
        t.setDaemon(true);//添加这个就可以变成守护线程，当所有主线程结束后会自动结束
        t.start();
        for (int i=0;i<100;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"---------"+i);
        }

    }
}

class mythread extends Thread{
    @Override
    public void run(){
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--------->" );
        }
    }
}

定时器：使用方式

  1. 使用sleep方法，设置睡眠时间，比较low

  2. 使用java类库中定义的Timer类，可以直接用

  3. 可以使用spring框架中提供的springTask框架，配置使用

定时器的作用：间隔特定的时间执行特定的程序

这样每十秒就会运行一次

Timer对象的schedule方法有三个参数，第一个是运行方法，是一个抽象类，必须使用新建类来继承；第二个是时间，可以使用转变的确定时间，也可以直接使用当前时间。第三个参数是间隔（毫秒）

public class TimerTest {
    public static void main(String[] args) throws ParseException {
        Timer timer=new Timer();
//        Timer timer1=new Timer(true);创建定时器为守护线程
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date=simpleDateFormat.parse("2022-09-15 22:09:00");//使用该方法将特定的时间赋值给date对象
        timer.schedule(new LogTimerTask(),date,1000*10);
    }
}

class LogTimerTask extends TimerTask{

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strtime=simpleDateFormat.format(new Date());
        System.out.println(strtime+"完成了一次运行");
    }
}

实现线程的第三种方式：jdk8之后的：

实现callable接口，这种方式实现之后可以获取线程的返回值。 

这种方式的优点：可以获取到线程的执行结果，

这种方式的缺点：主线程需要等待浮现副线程的运行结果，会阻塞，效率低

public class Thread_callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建未来任务类
        FutureTask task=new FutureTask(new Callable() {//匿名内部类的形式实现的callable接口，也可以单独实现
            @Override
            public Object call() throws Exception {//call方法相当于run方法，只不过有返回值
                System.out.println("call method begin");
                Thread.sleep(10000);
                System.out.println("call method end");
                int a=100;
                int b=200;
                return a+b;
            }
        });//相当于普通的Runnable接口，但是有返回值
        Thread t=new Thread(task);
        t.start();
        Object o=task.get();//获取返回值数据，必须等待t线程执行结束，效率较低
        System.out.println("main end");
    }
}

关于Object类中的wait方法和notify方法

T线程在o对象上活动。T线程是当前线程对象。当调用o.wait)方法之后,T线程进入无期限等待。当前线程进入等待状态。直到最终调用o.notify0方法。
o.notify0方法的调用可以让正在o对象上等待的线程唤醒。

o.notifyall唤醒所有的等待线程

1.8、消费者生产者

实例，由于两个线程是部分并发的所以，代码执行相对复杂

在while循环里面加上synchronize锁会实现一较高的效率，如果将这个list扩容到10，里面的容量就会一直10，9，10，9这样（如果刚释放锁的那个线程抢的比较快的话会再次执行一遍，可能就会变成8）。但是如果这时候将synchronize放到循环的外面，就会在循环的时候一直持有锁，知道挂起线程，这样更好理解，但是效率会变低。

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

        List list=new ArrayList();
        Thread t1=new Thread(new product(list));
        Thread t2=new Thread(new comsumer(list));
        t1.start();
        t2.start();
        //创建两个线程运行

    }
}

class product implements Runnable{

    private List list;

    public product(List list){
        this.list=list;
    }
    @Override
    public void run() {
        while (true){
            synchronized (list){//1.获取list对象锁
                System.out.println(1);//这里会输出两次
            if (list.size()>0){
                try {
                    System.out.println(4);
                    list.wait();//4.到这里挂起该线程，释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {//2.生产一个商品，重新执行while
                System.out.println(2);
                list.add(1);
                System.out.println("生产了一个"+list.size());
                list.notify();//第二遍执行到这里的时候会将消费者挂起线程唤醒
            }
            }
        }
    }
}

class comsumer implements Runnable{

    private List list;

    public comsumer(List list){
        this.list=list;
    }
    @Override
    public void run() {
        while (true){//3，t2线程在这里等待对象锁
            System.out.println(3);
            synchronized (list) {//5.t1释放对象锁之后，这里获取对象锁
                System.out.println(5);
                if (list.size() == 0) {
                    try {
                        System.out.println(7);
                        list.wait();//7.到这里挂起使用list的消费者
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    list.remove(0);//6.到这里执行
                    System.out.println(6);
                    System.out.println("消费了一个"+list.size());
                    list.notify();//第二遍执行到这里的时候，会将生产者挂起的线程唤醒
                }
            }
        }

    }
}

 二、反射机制

2.1、反射机制有什么用

  1. java中的反射机制可以操作字节码文件

  2. 可以读取和修改字节码文件

  3. 通过反射机制可以操作代码片段class文件

    • java.lang.Class：代表整个字节码，代表一个类型

    • java.lang.reflect.Method：代表字节码中的方法字节码。

    • java.lang.reflect.Constructor:代表字节码中的构造方法字节码。

    • java.lang.reflect.Field:代表字节码中的属性字节码

获取字节码的三种方式

 public static void main(String[] args) {
        //方法一，通过class类的静态方法forname获取，参数是一个完整的包名，可以是自定义的类，也可以是java自带的类

        try {
            Class a=Class.forName("Fanshe.account");
            Class a1=Class.forName("java.lang.String");
            System.out.println(a+"---------"+a1);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }


        //第二种方式，使用对象来直接调用class方法就可以获取字节码,这种方法不能获取基本数据类型
        String  str="aaa";
        Integer i=1;
        Class B=str.getClass();
        Class B1=i.getClass();
        System.out.println(B+"---------"+B1);

        //第三种方式，使用类名直接.class,只有这种方式可以获取基本数据类型的字节码
        Class c=String.class;
        Class c1=int.class;
        Class c2=account.class;
        System.out.println(c+"---------"+c1);
        //获取字节码之后可以通过调用newInstance（）方法来返回该字节码对应的对象
        //该方法的返回值是object，所以需要向下转型才能返回
        try {
            account account= (Fanshe.account) c2.newInstance();
            System.out.println(account);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

使用properties和class字节码的形式创建对象并输出

首先使用properties从文件中获取类的路径

然后通过获取字节码的forname方法来抓取并创建类对象

这样做的好处是可以通过修改文件中类的路径来打到创建不同类的方式

public class properties_fanse {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileReader fileReader=new FileReader("base_java/student");
        Properties p=new Properties();
        p.load(fileReader);
        String path= (String) p.get("username");
        Class c=Class.forName(path);
        try {
            account2 a= (account2) c.newInstance();
            System.out.println(a);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
//文件内容username=Fanshe.account2

    }

静态代码块在类加载的时候执行

使用class.forname(类)可以使该类加载，然后执行静态代码块

所以只希望执行类中静态代码块的话可以使用该方法。

2.2、读取文件路径方式

由于通过项目的相对路径获取绝对路径，所以可以在linux中也可以运行。不需要在idea里面。 

//getContextClassLoader()可以获取到当前线程的类加载器对象
//getResource类加载器对象的方法，用于路径，一般在src下，然后返回绝对路径
public class properties_fanse {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String path1=Thread.currentThread().getContextClassLoader().getResource("student.properties").getPath();
        InputStream reader=Thread.currentThread().getContextClassLoader().getResourceAsStream("student.properties");
        //这种方式可以直接用流返回，搭配properties的时候更加方便
        System.out.println(path1);
        FileReader fileReader=new FileReader(path1);//这样做的缺点是只能在idea里面运行
        Properties p=new Properties();
        p.load(fileReader);
        String path= (String) p.get("username");
        Class c=Class.forName(path);
        try {
            account2 a= (account2) c.newInstance();
            System.out.println(a);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }


    }
}

 获取配置文件的方法：

本质上其实就是文件流，但是是通过一个写好的类来直接获取，比较方便。 

/*可以通过该方式来直接获取src文件下的配置文件
并且在获取的时候不能加上后缀*/
public class jdbc_file {
    public static void main(String[] args) {
        ResourceBundle resourceBundle=ResourceBundle.getBundle("jdbc");
        String classname=resourceBundle.getString("username");
        System.out.println(classname);
    }
}

 2.3、类加载器

分类：

  1. 启动类加载器

  2. 扩展类加载器

  3. 应用类加载器

代码在开始执行之前，会将所有需要的类加载到jvm中，然后通过类加载器。

jre是Java虚拟机的环境

  1. 首先通过“启动类加载器”加载.

    注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.\jre\lib\rt.jar

    rt.jar中都是JDK最核心的类库。

  2. 如果通过启动类加载器”加载不到的时候，会通过“扩展类加载器”加载。

    注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0\jre\lib\ext.jar

  3. 如果"扩展类加载器”没有加载到，那么会通过应用类加载器”加载.

    注意：应用类加载器专门加载：classpath中的类。

双亲委派机制：

优先从启动类加载器中加载，这个类称为父，然后从扩展类加载器中加载，称为母

如果都加载不到才会从应用加载器中加载。应用加载器存放的就是类路径下（一般是src）自己写的类中加载。这样就保证了安全。 

2.4、反射机制实例

通过反射机制来捕捉类中的字段：

//通过捕捉字节码来输出类中的各种数据
/*
private int sno;
public String name;
protected String sex;
int age;
*/
public class Refiect {
    public static void main(String[] args) throws ClassNotFoundException {
        Class Stu=Class.forName("Fanshe.Student");
        Field[] fields=Stu.getFields();//只能获取public修饰的字段
        Field[] fields1=Stu.getDeclaredFields();//可以获取所有字段
        for (Field field:fields){
            System.out.println(field);//输出获取到的字段所有信息
            System.out.println(field.getName());//输出字段的名字
            Class stutype=field.getType();//首先获取字段类型的字节码
            System.out.println(stutype.getSimpleName());//然后调用方法输出类型
            System.out.println(field.getModifiers());//直接调用该方法可以直接输出修饰符权限，使用数字代替
            System.out.println(Modifier.toString(field.getModifiers()));//通过该方法将数字转换为修饰符
        }
        for (Field field:fields1){
            System.out.println(field);//输出获取到的字段所有信息
            System.out.println(field.getName());//输出字段的名字
            Class stutype=field.getType();//首先获取字段类型的字节码
            System.out.println(stutype.getSimpleName());//然后调用方法输出类型
            System.out.println(field.getModifiers());//直接调用该方法可以直接输出修饰符权限，使用数字代替
            System.out.println(Modifier.toString(field.getModifiers()));//通过该方法将数字转换为修饰符
        }
    }
}

 反编译FIeld

//获取类的字段信息
public class Refiect_fan {
    public static void main(String[] args) throws ClassNotFoundException {
        StringBuffer s=new StringBuffer();//字符串缓冲流，可以用来拼接字符串，不然就要使用String一直赋予，这样很浪费
        Class stu=Class.forName("java.lang.StringBuffer");
        s.append(Modifier.toString(stu.getModifiers())+ " class"+" "+stu.getSimpleName()+"(){");
        Field[] fields=stu.getDeclaredFields();
        for (Field field:fields){
            s.append("\n");
            s.append("\t");
            s.append(Modifier.toString(stu.getModifiers())+" ");
            s.append(field.getType().getSimpleName()+" ");
            s.append(field.getName()+";");
        }
        s.append("\n"+"}");
        System.out.println(s);
    }
}

 通过反射机制来访问对象属性

public class fanshe_field {
    public static void main(String[] args) throws Exception {
        Class c=Class.forName("Fanshe.Student");
            Object student=  c.newInstance();//用字节码创建对象
            Field fieldSno=c.getDeclaredField("sno");//获取对象属性
            fieldSno.setAccessible(true);//如果变量是私有的，则必须使用这个打破封装
            Field fieldSex=c.getDeclaredField("sex");
            fieldSex.set(student,"man");//赋值
            fieldSno.set(student,586);
            System.out.println(fieldSno.get(student)+"\n"+fieldSex.get(student));
    }
}

 可变参数：

//可变长度参数，就是类似于一个数组
//只能放到方法里面的最后一个位置，只有一个存在
//参数的个数事0~n个
//使用方法。类型...
public class change_number {
    public static void main(String[] args) {
        change_canshu.inta("dsa",1,2,3,4,5,3,31,1);
        change_canshu.Stringa(515,"sd","a");
    }
}

class change_canshu{
    public static void inta(String a,int... b){
        System.out.println(a);
        for (int i:b){
            System.out.println(i);
        }

    }

    public static void Stringa(Integer a,String... b){
        System.out.println(a);
        for (String i:b){
            System.out.println(i);
        }

    }
}

 通过反射机制使用方法：

public class fanshe_methods {
    public static void main(String[] args) throws Exception{
        Class c=Class.forName("Fanshe.Student");
        Object o=c.newInstance();//创建对象
        Method methodLogin=c.getDeclaredMethod("login", String.class, String.class);//创建方法对象
        Object objects=methodLogin.invoke(o,"admin","admin");//调用方法
        System.out.println(objects);//输出true
        Method[] methods=c.getDeclaredMethods();
        for (Method method:methods){
            System.out.println(method.getName());//方法名logout
            System.out.println(method.getReturnType());//方法返回值类型void
            System.out.println(Modifier.toString(method.getModifiers()));//方法修饰符public
            Class[] list=method.getParameterTypes();//方法参数类型String，String
            for (Class type:list){
                System.out.println(type.getSimpleName());
            }
        }

    }
}

反射机制使用构造方法:

public class fanshe_construct {
    public static void main(String[] args) throws Exception{
        Class c=Class.forName("Fanshe.Student");
        Constructor con=c.getDeclaredConstructor(int.class,String.class,String.class,int.class);
        Student student= (Student) con.newInstance(123,"张三","男",13);
        System.out.println(student);
    }
}

 反射机制获取父类和接口

public class fanshe_fatherAndInterfaces {
    public static void main(String[] args) throws Exception{
        Class c=Class.forName("java.lang.String");
        Class classSuper=c.getSuperclass();//获取父类
        System.out.println(classSuper.getSimpleName());

        Class[] classes=c.getInterfaces();//获取接口
        for (Class class1:classes){
            System.out.println(class1);
        }
    }
}

三、注解

3.1、基本解释

标示性注解：给编译器作参考的:

  1. @Override注解就是用来标识该方法是重写父类的方法

  2. 这个注解和运行阶段没有关系，并且只能标注方法

java.lang包下的注释类型：

  1. Deprecated 用 @Deprecated 注释的程序元素

    不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。

    也就是标识该元素是过时的，会加上一个横杠

  2. @Override标识该方法是重写父类的方法

    SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的 所有程序元素）中取消显示指定的编译器警告。 元注解 什么是元注解？

    用来标注~注解类型”的“注解”，称为元注解。

常见的元注解有哪些？

  1. Target：一般用于标识该注解是用在哪一个范围的，比如方法上，类上或者元素上

  2. Retention：表示存在的时间，如果不设置，该注解在运行的时候就不存在

关于Target注解：

  1. 这是一个元注解，用来标注"注解类型”的"注解”

  2. 这个Target注解用来标注“被标注的注解”可以出现在哪些位置上。

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})//类，方法，字段

关于Retention注解：

  1. 这是一个元注解，用来标注“注解类型”的“注解”

  2. 这个Retention注解用来标注"被标注的注解”最终保存在哪里。

  3. @Retention(RetentionPolicy.SOURCE)：表示该注解只被保留在java源文件中。

  4. @Retention(RetentionPolicy.CLASS)：表示该注解被保存在class文件中。

  5. @Retention(RetentionPolicy.RUNTIME)：表示该注解被保存在class文件中，并在运行时存在

一般可以在注解中添加元素，如果是直接定义的元素必须在调用的时候赋值，如果已经使用default赋值过了就可以省略

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface myAnotation {
    String name();

    int age() default 22;
}


@myAnotation(name = "dsa",age = 11)//age可以不写

属性的类型可以是：

byte shart int Long float double boolean char String Class 教举类型

以及以上每一种的数组形式。

洛空_
关注
【狂神说笔记—— Java基础13-注解与反射】
weixin_46055348的博客
07-10 271
【狂神说笔记—— Java基础13-注解与反射】
详解 Java 类加载与反射（笔记）
菜鸟踩坑
08-19 1117
Java 类加载机制 Java 内存分析 jvm把class文件加载到内存，并对数据进行校验、解析和初始化，最终形成jvm可以直接使用的java类型的过程。 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。 链接：将java类的二进制代码合并到jvm的运行状态之中的过程，链接过程又分为3个过程： （1）、验证：确保加载的类信息符合jvm规范，没有
注解与反射（Java，类加载机制，双亲委派机制）
weixin_44553952的博客
05-31 1261
元注解的作用就是负责注解其他注解，Java定叉了4个标准的meta- annotation类型，他们被用来提供对其他 annotation类型作说明。这些类型和它们所支持的类在 java. lang annotation包中可以找到。@ Target：用于描述注解的使用范围（即被描述的注解可以用在什么地方）。@Target注解用于指定被修饰的注解可以应用的目标元素类型。它包含一个类型的数组作为参数，指定了注解可以应用的元素类型，如类、方法、字段等。例如，如果一个注解被。
java类加载器与反射学习笔记
渐入佳境Coder
10-05 646
概要: java类加载机制 Java类加载器除了根类加载器外,其他累加器都是使用Java语言编写的,因此程序员完全可以开发自己的类加载器,通过使用自定义类 加载器 ,可以完成一些特定的功能。 java反射机制 重点介绍java.lang.reflect包下的接口和类,包括Class、Method、Field、Constructor和Array等,这些类分别代表类、方法、成员变量 、构造器和
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1256
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java学习笔记24：Java_xml_枚举_注解_类加载器_反射_http服务器改写_管理系统与服务器集成_单元测试_日志
JasonYangQ的博客
08-08 8248
目标 条件语句作用 if语法 if…else… 多重判断 if嵌套 一. 了解条件语句 假设一个场景： 同学们这个年龄去过网吧吗？ 去网吧进门想要上网必须做的一件事是做什么？（考虑重点） 为什么要把身份证给工作人员？ 是不是就是为了判断是否成年？ 是不是如果成年可以上网？如果不成年则不允许上网？ 其实这里所谓的判断就是条件语句，即条件成立执行某些代码，条件不成立则不执行这些代码。 二. if 语法 2.1 语法 if 条件: 条件成立执行的代码1 条件成立执行的代码2 ...
【Java基础】注解与反射
qq_42294095的博客
05-30 843
@Override、@Deprecated、@SuppressWarnings、annotation、Reflection、ORM
B站【狂神说Java笔记】-注解和反射
2401_85835698的博客
08-12 885
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。最新整理面试题上述的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题最新整理电子书最新整理大厂面试文档以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。参考文章链接：https://mp.weixin.qq.com/s?
Java 注解与反射（狂神笔记）
sdau20163940的博客
04-07 306
注解和反射学习笔记 注解：Annotation 反射：Reflection 1.什么是注解？ Annotation是从JDK5.0开始引入的新技术. Annotation的作用： 不是程序本身，可以对程序作出解释.（这一点和注释（comment）没什么区别） 可以被其他程序（比如：编译器等）读取. Annotation的格式： 注解是以“@注释名“在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings（value=“unchecked”）. Annotation在哪里使用？
Java学习笔记 反射与注解
man_zuo的博客
10-10 379
前言 反射是框架（如Spring等）的灵魂，掌握java反射的知识可以让你更好的理解框架的底层实现。而我们经常使用的一些Spring注解就是通过反射来获取的。 反射 动态语言VS静态语言 动态语言:是一类可以在运行时可以改变其结构的语言(引进新的对象,函数或者删除已有的函数),通俗的点说就是在运行代码的时候可以根据某些条件改变自身结构,如C#,JavaScript,PHP,Python等 静态语言:运行时结构不可变的语言就是静态语言,如Java,C,C++. Java虽然不是动态语言,但是可以通过反射机
Java基础知识笔记.rar
03-11
这份“Java基础知识笔记”涵盖了学习Java编程所必需的关键概念和技术。笔记详细地讲解了以下核心知识点： 1. **Java环境搭建**：首先，你需要安装Java Development Kit (JDK)，设置好环境变量`JAVA_HOME`、`PATH`和...
java学习笔记markdown
03-12
8. **反射机制**：探讨Java反射API的使用，包括动态获取类信息、创建对象、调用方法等功能，这对于理解和调试程序有很大的帮助。 9. **JVM内部机制**：简述Java虚拟机的工作原理，包括类加载、内存管理、垃圾回收...
狂神说JAVA的所有笔记.zip
01-17
异常处理是JAVA中的重要安全机制，集合框架是存储和操作数据的主要工具，IO流用于文件操作和数据传输，多线程则可以实现程序的并发执行，网络编程则是开发分布式应用的基础，反射提供了运行时动态操作类和对象的能力...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 261
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 575
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 556
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 447
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 701
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 298
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Java_SE基础教程：毕向东老师笔记概览
“传智播客Java_SE基础毕向东老师全程笔记” 这是一份全面涵盖Java基础知识的教程笔记，由传智播客的资深讲师毕向东教授。这份笔记详细讲解了从编程基础到高级特性的各个Java核心概念，适合初学者入门和巩固Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值